Question

Re-write this Python code that counts down from 5 to 0 in 5 seconds in a more efficient way:

import time
seconds = 5
print("Remaining time: " + str(seconds))
seconds = seconds - 1
time.sleep(1)
print("Remaining time: " + str(seconds))
seconds = seconds - 1
time.sleep(1)
print("Remaining time: " + str(seconds))
seconds = seconds - 1
time.sleep(1)
print("Remaining time: " + str(seconds))
seconds = seconds - 1
time.sleep(1)
print("Remaining time: " + str(seconds))
seconds = seconds - 1
time.sleep(1)
print("Remaining time: " + str(seconds))

Imagine you are writing a program that will be used to manage production at a cookie factory. Describe one object you will create; it should have at least two methods and three attributes.
Look at the following program. Is it procedural or object-oriented? What would you do to convert it to the other type?

song1 = "Let's Dance"
song1_info = [128, 34, 304]

song2 = "Party Time!"
song2_info = [144, 32, 439]

song3 = "My Dreams"
song3_info = [93, 41, 339]

Describe in your own words what this program does:

class Meals:
def __init__(self, name):
self.name = name

fish = Meals("salmon")
print(fish.name)

Write a Python module that solves a problem.

Answer 1

### Efficient Countdown Code

The provided countdown code can be made more efficient by using a loop. This way, we avoid repetitive code and make the countdown more succinct:

```python
import time

def countdown(seconds):
for i in range(seconds, -1, -1):
print(f"Remaining time: {i}")
time.sleep(1)

countdown(5)
```

### Object Creation Example

In a cookie factory management system, one useful object could be a `CookieBatch` class.

#### `CookieBatch` Class

**Attributes:**
1. `flavor`: The flavor of the cookies (e.g., chocolate chip, oatmeal raisin).
2. `quantity`: The number of cookies in the batch.
3. `baking_time`: The time required to bake the cookies (in minutes).

**Methods:**
1. `bake()`: Simulates the baking process and prints a message once baking is complete.
2. `package()`: Simulates the packaging process of the cookies and displays the quantity and flavor for packaging.

```python
class CookieBatch:
def __init__(self, flavor, quantity, baking_time):
self.flavor = flavor
self.quantity = quantity
self.baking_time = baking_time

def bake(self):
print(f"Baking {self.quantity} {self.flavor} cookies for {self.baking_time} minutes...")
# Place for actual baking logic
print("Baking complete!")

def package(self):
print(f"Packaging {self.quantity} {self.flavor} cookies.")
# Place for actual packaging logic
```

### Procedural vs. Object-Oriented

The provided program is procedural as it uses a set of variables and lists to store information without any encapsulation or abstraction that defines objects.

#### Converting to Object-Oriented

To convert the code to an object-oriented approach, you could create a `Song` class that encapsulates the properties of a song:

```python
class Song:
def __init__(self, title, tempo, duration):
self.title = title
self.tempo = tempo # beats per minute
self.duration = duration # seconds

def play(self):
print(f"Playing '{self.title}' at {self.tempo} BPM for {self.duration} seconds.")

# Creating song instances
song1 = Song("Let's Dance", 128, 34)
song2 = Song("Party Time!", 144, 32)
song3 = Song("My Dreams", 93, 41)

# Function to play all songs
def play_all_songs(songs):
for song in songs:
song.play()

# List of songs
songs = [song1, song2, song3]
play_all_songs(songs)
```

### Explanation of the Class Example

The given class `Meals` is quite simple. It defines a single class to represent a meal, initialized with a name. In the provided example, an instance of the class is created for a salmon meal. It demonstrates basic object-oriented principles by encapsulating the property of the meal's name.

### Python Module Example

Here’s a simple Python module that could solve a problem. This module provides basic functionality for a calculator.

```python
# calculator.py

def add(a, b):
"""Return the sum of a and b."""
return a + b

def subtract(a, b):
"""Return the difference of a and b."""
return a - b

def multiply(a, b):
"""Return the product of a and b."""
return a * b

def divide(a, b):
"""Return the quotient of a and b. Raises an error if dividing by zero."""
if b == 0:
raise ValueError("Cannot divide by zero.")
return a / b

if __name__ == '__main__':
# Example usage
print("Basic Calculator")
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

print(f"Add: {add(num1, num2)}")
print(f"Subtract: {subtract(num1, num2)}")
print(f"Multiply: {multiply(num1, num2)}")
print(f"Divide: {divide(num1, num2)}")
```

This module can be imported into other Python scripts for use, making it a reusable component of software applications.