מחלקות – חלק 2

In [ ]:

    

class Ingredient:
    def __init__(self, name, carbs, fats, proteins):
        self.name = name
        self.carbs = carbs
        self.fats = fats
        self.proteins = proteins
    
    def calculate_calories(self):
        return (
            self.carbs * 4
            + self.fats * 9
            + self.proteins * 4
        )


    

In [ ]:

    

mango = Ingredient('Mango', carbs=15, fats=0.4, proteins=0.8)
mango.calculate_calories()


    

In [ ]:

    

class Ingredient:
    def __init__(self, name, carbs, fats, proteins):
        self.name = name
        self.carbs = carbs
        self.fats = fats
        self.proteins = proteins
    
    def calculate_calories(self):
        return (
            self.carbs * 4
            + self.fats * 9
            + self.proteins * 4
        )

    def is_healthy(self):
        return self.calculate_calories() < 100


    

In [ ]:

    

HEALTHY_CALORIES_UPPER_BOUND = 100


class Ingredient:
    def __init__(self, name, carbs, fats, proteins):
        self.name = name
        self.carbs = carbs
        self.fats = fats
        self.proteins = proteins
    
    def calculate_calories(self):
        return (
            self.carbs * 4
            + self.fats * 9
            + self.proteins * 4
        )

    def is_healthy(self):
        return self.calculate_calories() < HEALTHY_CALORIES_UPPER_BOUND


    

In [ ]:

    

class Ingredient:
    def __init__(self, name, carbs, fats, proteins):
        self.name = name
        self.carbs = carbs
        self.fats = fats
        self.proteins = proteins
        self.HEALTHY_CALORIES_UPPER_BOUND = 100

    def calculate_calories(self):
        return (
            self.carbs * 4
            + self.fats * 9
            + self.proteins * 4
        )

    def is_healthy(self):
        return self.calculate_calories() < self.HEALTHY_CALORIES_UPPER_BOUND


    

In [ ]:

    

class Ingredient:
    HEALTHY_CALORIES_UPPER_BOUND = 100

    def __init__(self, name, carbs, fats, proteins):
        self.name = name
        self.carbs = carbs
        self.fats = fats
        self.proteins = proteins

    def calculate_calories(self):
        return (
            self.carbs * 4
            + self.fats * 9
            + self.proteins * 4
        )

    def is_healthy(self):
        return self.calculate_calories() < self.HEALTHY_CALORIES_UPPER_BOUND


    

In [ ]:

    

banana = Ingredient('Banana', carbs=23, fats=0.3, proteins=1.1)
melon = Ingredient('Melon', carbs=8, fats=0.2, proteins=0.8)

print(banana.HEALTHY_CALORIES_UPPER_BOUND)
print(melon.HEALTHY_CALORIES_UPPER_BOUND)


    

In [ ]:

    

print(f"Is Banana healthy? -- {banana.is_healthy()}")
print(f"Is Melon healthy? -- {melon.is_healthy()}")


    

In [ ]:

    

SomethingINeedForMyRecipe = Ingredient
honey = SomethingINeedForMyRecipe('Honey', carbs=82, fats=0, proteins=0.3)
honey.calculate_calories()


    

In [ ]:

    

print(SomethingINeedForMyRecipe)


    

In [ ]:

    

type(honey)


    

In [ ]:

    

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"{self.name} is {self.age} years old."


class Superstar:
    def __init__(self, name, age):
        self.name = f'🌟Superstar {name}🌟'
        self.age = age - 5  # Your skin is so young!
    
    def __str__(self):
        return f"{self.name} is {self.age} years old."


classes = [User, Superstar]
for class_object in classes:
    print(f"The result from {class_object} is...")
    kipik = class_object("Kipik the Turtle", 75)
    print(kipik)
    print('-' * 50)


    

In [ ]:

    

class Ingredient:
    HEALTHY_CALORIES_UPPER_BOUND = 100

    def __init__(self, name, carbs, fats, proteins):
        self.name = name
        self.carbs = carbs
        self.fats = fats
        self.proteins = proteins

    def calculate_calories(self):
        return (
            self.carbs * 4
            + self.fats * 9
            + self.proteins * 4
        )

    def is_healthy(self):
        return self.calculate_calories() < self.HEALTHY_CALORIES_UPPER_BOUND


    

In [ ]:

    

cinnamon = Ingredient('Cinnamon', carbs=81, fats=1.2, proteins=4)


    

In [ ]:

    

Ingredient.HEALTHY_CALORIES_UPPER_BOUND


    

In [ ]:

    

print(f"healthy if calories < 100: {cinnamon.is_healthy()}")
Ingredient.HEALTHY_CALORIES_UPPER_BOUND = 400
print(f"healthy if calories < 400: {cinnamon.is_healthy()}")


    

In [ ]:

    

Ingredient.name


    

In [ ]:

    

Ingredient.is_healthy()


    

In [ ]:

    

cinnamon.is_healthy()


    

In [ ]:

    

Ingredient.is_healthy(cinnamon)


    

In [ ]:

    

class Dish:
    """Create a new dish for the restaurant using our ingredients.
    
    Args:
        name (str): The name of the dish.
        is_vegetarian (bool): `True` if the dish is vegetarian.
        ingredients (list of Ingredient): All the required ingredients
                                          for the dish.

    Attributes:
        name (str): The name of the dish.
        is_vegetarian (bool): `True` if the dish is vegetarian.
        ingredients (list of Ingredient): All the ingredients that are
                                          required to prepare the dish.
    """
    def __init__(self, name, is_vegetarian, ingredients):
        self.name = name
        self.is_vegetarian = is_vegetarian
        self.ingredients = ingredients
    
    def get_total_calories(self):
        """Calculate calories based on the list of the ingredients."""
        calories = 0
        for ingredient in self.ingredients:
            calories = calories + ingredient.calculate_calories()
        return calories
    
    def __str__(self):
        calories = self.get_total_calories()
        return f"{self.name} has {calories:.7} calories in it."


    

In [ ]:

    

ingredients = [
    Ingredient('Butter', carbs=0.1, fats=81.9, proteins=0.9),
    Ingredient('Honey', carbs=82, fats=0, proteins=0.3),
    Ingredient('Flour', carbs=79, fats=1.8, proteins=7),
]
bread = Dish("Lembas Bread", is_vegetarian=True, ingredients=ingredients)
print(bread)


    

In [ ]:

    

class Dish:
    MAX_INGREDIENTS = 7
    
    """Create a new dish for the restaurant using our ingredients.
    
    Args:
        name (str): The name of the dish.
        is_vegetarian (bool): `True` if the dish is vegetarian.

    Attributes:
        name (str): The name of the dish.
        is_vegetarian (bool): `True` if the dish is vegetarian.
        ingredients (list of Ingredient): All the required ingredients
                                          for the dish.
    """
    def __init__(self, name, is_vegetarian):
        self.name = name
        self.is_vegetarian = is_vegetarian
        self.ingredients = []

    def can_add_ingredient(self):
        """Return True if we should allow to add another ingredient."""
        return (
            self.MAX_INGREDIENTS is None
            or len(self.ingredients) < self.MAX_INGREDIENTS
        )

    def add_ingredient(self, ingredient):
        """Add an ingredient to the dish.
        
        If the class variable MAX_INGREDIENTS is set, and there are
        at least MAX_INGREDIENTS ingredients in the dish, the call
        to this function will fail.
        
        Args:
            ingredient (Ingredient): An `Ingredient` instance to add.
        """
        if not self.can_add_ingredient():
            return
        self.ingredients.append(ingredient)

    def remove_ingredient(self, ingredient):
        """Remove an ingredient from the dish.
        
        Args:
            ingredient (Ingredient): An `Ingredient` instance to add.

        Raises:
            ValueError: If the supplied ingredient is not in the
                        ingredients list.
        """
        self.ingredients.remove(ingredient)
    
    def get_total_calories(self):
        """Calculate calories based on the list of the ingredients."""
        calories = 0
        for ingredient in self.ingredients:
            calories = calories + ingredient.calculate_calories()
        return calories

    def __str__(self):
        calories = self.get_total_calories()
        return f"{self.name} has {calories:.7} calories in it."


    

In [ ]:

    

# ניצור מנה של קוקטייל
great_cocktail = Dish("Black Magic Julep", is_vegetarian=True)

# נכין את הרכיבים בצד
ingredients = [
    Ingredient("Angostura bitters", carbs=80, fats=0, proteins=0),
    Ingredient("Fernet branca", carbs=46.41, fats=0, proteins=0),
    Ingredient("Four roses", carbs=69, fats=0, proteins=0),
    Ingredient("Mint leaves", carbs=15, fats=3.8, proteins=0.9),
    Ingredient("Amaro Averna", carbs=20.9, fats=15.7, proteins=2.8),
    Ingredient("Amaro Montenegro", carbs=54, fats=0, proteins=0),
    Ingredient("Amaro Nonino", carbs=33, fats=0, proteins=0),
]

# נצרף את 7 הרכיבים לקוקטייל
for ingredient in ingredients:
    great_cocktail.add_ingredient(ingredient)

# נבדוק שהכל עבד כשורה
print(len(great_cocktail.ingredients))
print(great_cocktail)

# נוסיף את הרכיב השמיני
sugar = Ingredient("Sugar", carbs=100, fats=0, proteins=0)
great_cocktail.add_ingredient(sugar)

# נוודא שלא התווסף
print('-' * 40)
print("Tried adding the 8th ingredient.")
print(f"Success: {sugar in great_cocktail.ingredients}")


    

In [ ]:

    

great_cocktail.remove_ingredient(sugar)


    

In [ ]:

    

great_cocktail.ingredients.append(sugar)
print(len(great_cocktail.ingredients))


    

In [ ]:

    

class Dish:
    MAX_INGREDIENTS = 7
    
    """Create a new dish for the restaurant using our ingredients.
    
    Args:
        name (str): The name of the dish.
        is_vegetarian (bool): `True` if the dish is vegetarian.

    Attributes:
        name (str): The name of the dish.
        is_vegetarian (bool): `True` if the dish is vegetarian.
        _ingredients (list of Ingredient): All the required ingredients
                                           for the dish.
    """
    def __init__(self, name, is_vegetarian):
        self.name = name
        self.is_vegetarian = is_vegetarian
        self._ingredients = []

    def can_add_ingredient(self):
        """Return True if we should allow to add another ingredient."""
        return (
            self.MAX_INGREDIENTS is None
            or len(self._ingredients) < self.MAX_INGREDIENTS
        )

    def add_ingredient(self, ingredient):
        """Add an ingredient to the dish.
        
        If the class variable MAX_INGREDIENTS is set, and there are
        at least MAX_INGREDIENTS ingredients in the dish, the call
        to this function will fail.
        
        Args:
            ingredient (Ingredient): An `Ingredient` instance to add.
        """
        if not self.can_add_ingredient():
            return
        self._ingredients.append(ingredient)

    def remove_ingredient(self, ingredient):
        """Remove an ingredient from the dish.
        
        Args:
            ingredient (Ingredient): An `Ingredient` instance to add.

        Raises:
            ValueError: If the supplied ingredient is not in the
                        ingredients list.
        """
        self._ingredients.remove(ingredient)
    
    def get_total_calories(self):
        """Calculate calories based on the list of the ingredients."""
        calories = 0
        for ingredient in self._ingredients:
            calories = calories + ingredient.calculate_calories()
        return calories

    def __str__(self):
        calories = self.get_total_calories()
        return f"{self.name} has {calories:.7} calories in it."


    

In [ ]:

    

class User:
    def __init__(self, name, age, hobbies):
        self.name = name
        self._age = age
        self.__hobbies = hobbies
    
    def __str__(self):
        return (
            f"{self.name} is {self._age} years old. "
            + f"He loves {self.__hobbies.lower()}."
        )


    

In [ ]:

    

character = User("Franklin", 200, "Lacing shoes")
print(character)


    

In [ ]:

    

character.name = "Cookie Monster"  # עם זה אין שום בעיה
character._age = 54                # זה לא מנומס ומסוכן
character.__hobbies = "Cookies"    # זה כבר ממש לא סבבה


    

In [ ]:

    

print(character)


    

In [ ]:

    

character._User__hobbies = "Cookies"
print(character)


    

In [ ]:

    

class Ingredient:
    def __init__(self, name, carbs, fats, proteins):
        self.set_name(name)
        self.set_carbs(carbs)
        self.set_fats(fats)
        self.set_proteins(proteins)

    def set_name(self, new_name):
        self._name = new_name

    def get_name(self):
        return self._name

    def set_carbs(self, updated_carbs):
        self._carbs = updated_carbs

    def get_carbs(self):
        return self._carbs
    
    def set_fats(self, updated_fats):
        self._fats = updated_fats

    def get_fats(self):
        return self._fats

    def set_proteins(self, updated_proteins):
        self._proteins = updated_proteins

    def get_proteins(self):
        return self._proteins
    
    def get_calories(self):
        return (
            self.get_carbs() * 4
            + self.get_fats() * 9
            + self.get_proteins() * 4
        )


    

In [ ]:

    

strawberries = Ingredient("Strawberries", carbs=8, fats=0.4, proteins=0.7)

print(f"Before: {strawberries.get_calories()}")
# ננסה לערוך את כמות השומנים בתותים ל־0.3 במקום
strawberries.set_fats(strawberries.get_fats() - 0.1)

print(f"After: {strawberries.get_calories()}")


    

In [ ]:

    

import datetime
import time


class User:
    """A user can connect and can contact with other users.

    Args:
        nickname (str): The username of the user.

    Attributes:
        nickname (str): The username of the user.
        _contacts (list of User): Other users whose added to the
                                  user's contacts.
        last_seen (float): The last time the user connected in seconds
                           since the Epoch.
    """
    SECONDS_UNTIL_DISCONNECTED = 60

    def __init__(self, nickname):
        self.nickname = nickname
        self._contacts = []
        self.last_seen = time.time()

    def is_online(self):
        """Determine if the user is currently connected.

        "Connected user" is a user that logged in at the last X
        seconds, where X is a constant defined as a class variable.

        Returns:
            bool: True if the user currently connected, False otherwise.
        """
        seconds_since_seen = time.time() - self.last_seen
        return seconds_since_seen < self.SECONDS_UNTIL_DISCONNECTED

    def connect(self):
        """Makes the user connected.

        Returns:
            None.
        """
        self.last_seen = time.time()
    
    def add_contact(self, contact):
        """Add contact to the user's contacts.

        Args:
            contact (User): A user to add to the user's contacts.

        Returns:
            bool: True if the addition was successful, False otherwise.
        """
        if contact in self._contacts:
            return False
        self._contacts.append(contact)
        return True

    def remove_contact(self, contact):
        """Remove a contact from the user's contacts.

        Args:
            contact (User): A user to remove from the user's contacts.

        Returns:
            bool: True if the deletion was successful, False otherwise.
        """
        if contact not in self._contacts:
            return False
        self._contacts.remove(contact)
        return True

    def get_contacts(self):
        """Return the user's contacts list."""
        return self._contacts
    
    def pretty_last_seen(self, dateformat='%Y-%m-%d %H:%M:%S'):
        """Show prettified date of when the user last connected.

        Args:
            dateformat (str): The format in which the time will
                              be displayed. 

        Returns:
            str: Last time the user connected.
        """
        localtime = time.localtime(self.last_seen)
        return time.strftime(dateformat, localtime)
    
    def __str__(self):
        """Show the user's details.

        Returns:
            str: The user representation currently.
        """
        if self.is_online():
            seen_message = 'Online'
        else:
            seen_message = self.pretty_last_seen()
        return f"{self.nickname} ({seen_message})"


class Message:
    """A deliverable message with status.
    
    A message can be sent from one user to another and
    can be mark as read by the recipient.
    
    Args:
        sender (User): The message sender's user.
        recipient (User): The message recipient's user.
        content (str): The body of the message.

    Attributes:
        send_date (float): The time the message was sent 
                           in seconds since the Epoch.
        seen (bool): True if the recipient saw the message.
        sender (User): The message sender's user.
        recipient (User): The message recipient's user.
        content (str): The body of the message.
    """

    def __init__(self, sender, recipient, content):
        self.send_date = time.time()
        self.seen = False
        self.sender = sender
        self.recipient = recipient
        self.content = content

    def pretty_send_date(self, dateformat='%Y-%m-%d %H:%M:%S'):
        """Show prettified date of when the message was sent.

        Args:
            dateformat (str): The format in which the time will be
                              displayed. 

        Returns:
            str: The time the message was sent.
        """
        localtime = time.localtime(self.send_date)
        return time.strftime(dateformat, localtime)

    def mark_as_read(self):
        """Mark the message as read.

        Returns:
            None.
        """
        self.seen = True

    def __str__(self):
        """Return the message's details.

        Returns:
            str: The message representation.
        """
        message = (
            f"From: {self.sender}\n"
            f"To: {self.recipient}\n"
            f"{self.pretty_send_date()}\n"
            f"-------------------\n"
            f"Message: {self.content}\n"
        )
        if self.seen:
            message = message + f"(Seen)"
        return message.strip()


def link_everyone(users):
    for user in users:
        for another_user in users:
            if user != another_user:
                user.add_contact(another_user)


print("First example:\n----")
anonymous = User("Zarop")
almog = User("Almog")
advertisement = "Click to get your Cookie!"
message = Message(sender=anonymous, recipient=almog, content=advertisement)
print(message)

print("\n\nSecond example:\n----")
users = [User("Athos"), User("Porthos"), User("Aramis"), User("D'Artagnan")]
link_everyone(users)
print("Contacts: " + str(len(users[0].get_contacts())))
message = Message(
    sender=users[0],
    recipient=users[1],
    content="Tous pour un, un pour tous, c'est notre devise"
)
print(message)
message.mark_as_read()
print("\nAfter read:\n")
print(message)