tmp

courses/python_oop/abstract/iter_3.py

@@ -255,6 +255,7 @@ def main():
     # test_4()
     # test_5()
     # test_6()
+    pass
 
 if __name__ == '__main__':
     main()

courses/python_oop/abstract/protocol_2.py

@@ -0,0 +1,74 @@
+from typing import Protocol
+
+'''
+Абстрактные базовые классы
+
+- Абстракнтые классы нельзя использовать по отдельности, и их можно использовать
+только путем реализации дочернего класса. Поэтому ABC по своей сути принадлежат
+к своим подклассам как часть строгой иерархии классов.
+
+- Хорошо подходят для проверки в реальном времени при создании экземпляра 
+дочернего класса. ABC выдаст ошибку при инициализации, если дочерний элемент
+не реализует все его абстрактные методы.
+
+Протоколы
+
+- Не используют иерархию.
+
+- Используются в определенном месте и сообщают нижестоящему коду, какой
+должна быть структура входного объекта. Протоколы принадлежат тому месту,
+где они используются.
+
+- Подходит для определения интерфейсов, особенно для сторонних библиотек, 
+когда мы не хотим тесно связывать наш код с конкретной сторонней библиотекой.
+
+Где спользовать
+
+- Используйте ABC, если хотите повторно использовать код.
+
+- Используйте ABC, если вам требуется строгая иерархия классов в вашем 
+приложении.
+
+- Используйте ABC, если вам понадобится несколько реализаций класса с 
+несолькокими методами.
+
+- Используйте протоколы для аннотаций строгого типа.
+
+- Используйте протоколы для абстрактных интерфейсов для сторонних библиотек.
+
+'''
+
+
+
+
+
+class Animal(Protocol):
+    def walk(self) -> None:
+        ...
+
+    def speak(self) -> None:
+        ...
+
+
+class Dog:
+    def walk(self) -> None:
+        print('This is dog walking')
+
+    def speak(self) -> None:
+        print('Woof!')
+
+def make_animal_speak(animal: Animal) -> None:
+    animal.speak()
+
+
+def test_1():
+    dog = Dog()
+    make_animal_speak(dog)
+
+
+def main():
+    test_1()
+
+if __name__ == '__main__':
+    main()
+

courses/python_oop/dunder_method/repr.py

@@ -0,0 +1,130 @@
+
+'''
+Функции str() и print() вызывают __str__()
+repr() - __repr__()
+
+Если __str__ нет, то будет вызваться __repr__
+'''
+
+
+class User:
+
+    def __init__(self, first_name):
+        self.first_name = first_name
+
+    def __str__(self):
+        return f'User {self.first_name}'
+
+    def __repr__(self):
+        return f'Repr Usef {self.first_name}'
+
+class Pizza:
+    pass
+
+
+def test_1():
+    # print(repr([1, 2, 3]))
+    user = User('John')
+    print(repr(user))
+    print(repr(Pizza()))
+
+    
+
+class UnknownUser:
+    pass
+
+
+def test_2():
+    users = [UnknownUser(), UnknownUser()]
+    print(users)
+
+    users_with_name = [User('Billy'), User('Jimmy')]
+    print(users_with_name)
+    print(users_with_name[0])
+    print(users_with_name[1])
+
+
+class SuperUser:
+    def __init__(self, first_name, last_name):
+        self.first_name = first_name
+        self.last_name = last_name
+
+    def __str__(self):
+        return f"__str__ method: {self.first_name} {self.last_name}"
+
+    def __repr__(self):
+        return f"__repr__ method: {self.first_name} {self.last_name}"
+
+
+def test_3():
+    user = SuperUser("Vasya", "Pypkin")
+    print(f"{repr(user)}")
+    # или лучше воспользоваться !r
+    print(f"{user!r}") # !r вызовет не __str__, а __repr__
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~        
+
+class Pizza:
+    
+    def __init__(self, name, ingredients):
+        self.name = name
+        if ingredients is None:
+            self.ingredients = []
+        else:
+            self.ingredients = ingredients
+            
+    def __repr__(self):
+        self.ingredients.sort(key=lambda x: x.weight, reverse=True)
+        ret = f'Пицца {self.name} состоит из:\n'
+        for ing in self.ingredients:
+            ret += ing.__repr__() + '\n'
+        return ret[:-1]
+
+class Ingredient:
+    
+    def __init__(self, name, weight):
+        self.name = name
+        self.weight = weight
+
+    def __repr__(self):
+        return f'{self.name}: {self.weight}г.'
+
+
+def test_4():
+    barbecue = Pizza('BBQ', [
+        Ingredient('chicken', 200),
+        Ingredient('mozzarella', 300),
+        Ingredient('sauce bbq', 150),
+        Ingredient('red onion', 150)
+    ])
+
+    print(barbecue)
+
+
+def test_5():
+    ing = [
+        Ingredient('chicken', 200),
+        Ingredient('mozzarella', 300),
+        Ingredient('sauce bbq', 150),
+        Ingredient('red onion', 150)
+    ]
+
+    ing.sort(key=lambda x: x.weight, reverse=True)
+    print(ing)
+    
+
+    # foo = {x.name: x.weight for x in ing}
+    # foo2 = sorted(foo.items(), key=lambda item: item[1], reverse=True)
+    # print(foo)
+    # print(foo2)
+
+
+def main():
+    # test_1()
+    # test_2()
+    # test_3()
+    test_4()
+    # test_5()
+
+if __name__ == '__main__':
+    main()

courses/python_oop/method_practic.py

@@ -2,6 +2,7 @@
 # Практика по property
 
 from string import digits
+from math import sqrt
 
 class User:
 
@@ -44,8 +45,45 @@ class User:
         self.__password = value
 
 
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class Point:
+
+    def __init__(self):
+        self.x = None
+        self.y = None
+
+    def set_coordinates(self, x, y):
+        self.x = x
+        self.y = y
+
+    def get_distance_to_origin(self):
+        if self.x is None or self.y is None:
+            return None
+        return sqrt(self.x ** 2 + self.y ** 2)
+
+    def display(self):
+        if self.x is None or self.y is None:
+            print('Координаты не заданы')
+        else:
+            print(f'Point({self.x}, {self.y})')
+
+
+def test_1():
+    p3 = Point()
+    p3.display()
+    print(p3.get_distance_to_origin())
+    p3.x = 4
+    p3.display()
+    print(p3.get_distance_to_origin())
+    p3.y = 3
+    p3.display()
+    print(p3.get_distance_to_origin())
+
+
 def main():
-    user1 = User('Ivan', '123df')
+    # user1 = User('Ivan', '123df')
+    test_1()
 
 
 if __name__ == '__main__':