OOP theory & problems

Author: DimDob

OOP/OOP theory/Документиране и декоратори/Декоратор.py

@@ -0,0 +1,25 @@
+#Функция на декоратора:
+def F(Alpha):
+    class Bravo:
+        value = Alpha()
+    Bravo.__name__ = f"My{Alpha.__name__}"
+    return Bravo
+#Клас с декоратор
+@F # == Charlie = F(Charlie)
+class Charlie:
+    def __init__(self):
+        self.number = 123
+    def show(self):
+        print(f"Поле number: {self.number}")
+#Създаване на обект:
+obj = Charlie()
+#Проверка на резултата:
+obj.value.show()
+print(f"Клас на обекта obj: {obj.__class__.__name__}")
+print(f"Клас на полето value: {obj.value.__class__.__name__}")
+
+#Чрез @F класът Charlie се предефинира (пренаписва). За основа се взема описанието на класа Charlie и с помощта на този клас се създава нов клас.
+#ТОЙ СЕ СЪЗДАВА В СЪОТВЕТСТВИЕ С ИНСТРУКЦИЯТА F(Charlie). Референция към създадения клас се записва в идентификатора Charlie.
+#На практика се изпълнява командата Charlie = F(Charlie). Затова ако по-рано референция към новия клас получавахме с инструкцията F(Charlie),
+#то сега референция към новия клас дава инструкцията Charlie. Затова и командата на ред 18 дава, че класът на обекта obj е всъщност MyCharlie,
+#а името на класа на полето value, когато бъде извикано - Charlie.

OOP/OOP theory/Документиране и декоратори/Документиране и декоратори.py

@@ -0,0 +1,28 @@
+#Първи клас:
+class Alpha:
+    "Това е клас алфа" #Този текстов литерал (ред) се нарича документиращ низ на класа
+    pass
+#Втори клас:
+class Bravo:
+    "Това е клас Bravo"
+    pass
+#Информация за класовете:
+print(Alpha.__doc__)
+print(Bravo.__doc__)
+#Обекти на класовете:
+A = Alpha()
+B = Bravo()
+
+#Изменение на документиращия низ:
+Alpha.__doc__  = "Първи клас"
+B.__class__.__doc__ = "Втори клас"
+
+#Информация за класовете:
+print(A.__class__.__doc__)
+print(B.__doc__)
+
+#До документиращия низ достигаме чрез 1. името на класа.__doc__ или 2.обектите на класа._class__.__doc__/ във втория случай чрез __class__ ние получаваме референция към класа на обекта./)
+print(A.__doc__)
+print(B.__doc__)
+#A.__class__.__doc__ != A.__doc__, защото обектът няма атрибут, съответно търсенето продължава в класа (във втория случай).
+

OOP/OOP theory/Документиране и декоратори/Функция, която получава референция към клас и връща референция към клас (как работи декораторът).py

@@ -0,0 +1,27 @@
+#Декораторът е някаква инструкция, която на основата на описания клас позволява да бъде получен друг клас:
+#За целта се използва функция, която като аргумент получава някакъв обект(тъй като класовете се реализират посредством обекти) и връща като резултат друг обект, реализиращ друг клас.
+
+#Функция, която получава референция към клас и връща като резултат референция към клас:
+def F(Alpha):
+    #Вътрешен клас
+    class Bravo:
+        value = Alpha()
+    Bravo.__name__ = "My" + Alpha.__name__
+    return Bravo
+#Описание на клас
+class Charlie:
+    #Конструктор
+    def __init__(self):
+        self.number = 123
+    #Метод за показване стойността на полето:
+    def show(self):
+        print(f"Поле number: {self.number}")
+#Създаване на обект на основата на клас, получен при извикването на функцията:
+obj = F(Charlie)()
+#Проверка на резултата:
+obj.value.show()
+print(f"Клас на обекта obj: {obj.__class__.__name__}")
+print(f"Клас на полето value: {obj.value.__class__.__name__}")
+
+#Функция F приема като аргумент клас. Технически обяснено в качеството на аргумент функцията получава референция към обект, посредством който се реализира клас.
+#

OOP/OOP theory/Копиране на обекти/Копиране на обекти.py

@@ -0,0 +1,51 @@
+#Ние получаваме достъп до обектите посредством променливи, които се отнасят към тях. Променливите не съдържат обектите в качеството на стойности.
+
+from copy import *
+#Описвам клас:
+class MyClass:
+    pass
+#Създавам обект:
+A = MyClass()
+#Полета на обекта:
+A.value = 100
+A.nums = [1,2,3]
+#Присвоявам референция към обекта:
+B = A
+#!Важно! Към този момент А и В се отнасят към ЕДИН И СЪЩИ АДРЕС в паметта и се отнасят към един и същи обект.
+#Копие на обекта:
+C = copy(A)
+#Пълно к0опие на обекта:
+D = deepcopy(A)
+print(f"Създадени са обектите")
+#Полета на обектите:
+print(f"A: {A.value} и {A.nums}")
+print(f"B: {B.value} и {B.nums}")
+print(f"C: {C.value} и {C.nums}")
+print(f"D: {D.value} и {D.nums}")
+print()
+print(f"A.value = 200 и А.nums[1] = 0")
+#Нови стойности за полетата:
+A.value = 200
+A.nums[1] = 0
+
+#Полета на обектите:
+print(f"A: {A.value} и {A.nums}")
+print(f"B: {B.value} и {B.nums}")
+print(f"C: {C.value} и {C.nums}") #Обект С е 'повърхностно' копие на обект А. То се създава посредством копирането на стойностите на полетата в обект А.
+#value в копие С НЕ се променя, защото неговата стойност е ЧИСЛО, а поле nums ще има същата стойност, каквато има в обект А, защото ТЕ ИМАТ ЕДИН И СЪЩ АДРЕС.
+print(f"D: {D.value} и {D.nums}") #Обект D е цяло копие на обект А, съответно промени в него не се оказват.
+print(f"Изтрива се А")
+print()
+#Във всички копия, освен в D, понеже е deepcopy(), т.е. адреса му в паметта е същия като на клас MyClass, стойностите се променят.
+
+#Изтривам променливата:
+del A
+print(f"B.value = 300 и B.nums[2] = 4")
+#Нови стойности за полетата:
+B.value = 300
+B.nums[2] = 4
+
+#Полета на обектите:
+print(f"B: {B.value} и {B.nums}")
+print(f"C: {C.value} и {C.nums}")
+print(f"D: {D.value} и {D.nums}")

OOP/OOP theory/Обект за реализация на клас/Обект за реализация на клас 2.py

@@ -0,0 +1,51 @@
+#Описание на клас:
+class MyClass:
+    #Конструктор:
+    def __init__(self): #Init method is also called CONSTRUCTOR
+        self.value = 123
+        print(f'Създава се обект: {self.value}')
+    #Destructor/Деструктор:
+    def __del__(self):
+        print(f'Изтрива се обект {self.value}') #Del method is also called DESTRUCTOR
+    #Метод за присвояване на стойност на полето:
+    def set(self,n):
+        self.value = n
+
+    #Метод за показване на стойността на полето:
+    def show(self):
+        print(f"Поле на обекта: {self.value}")
+#Създаване на обект:
+obj = MyClass()
+#Извикване на методите от обекта:
+obj.show()
+obj.set(100)
+#Извикване на методите ОТ КЛАСА:
+MyClass.show(obj)
+MyClass.set(obj, 200)
+
+#Проверка на стойността на полето:
+obj.show()
+
+#Явно извикване на конструктора:
+MyClass.__init__(obj)
+#Явно извикване на деструктора:
+MyClass.__del__(obj)
+
+#Проверка на стойността на полето:
+obj.show()
+
+#Изменение на стойността на полето:
+obj.value = 321
+obj.show()
+
+#Явно извикване на конструктора чрез обекта:
+obj.__init__()
+
+#Явно извикване на деструктора чрез обекта:
+obj.__del__()
+
+#Важно е да се подчертае, че само по себе си извикването на конструктора или деконструктора не води съответно до създаването/изтриването на обект.
+#Конструкторът е метод, който се извиква автоматично непосредствено след създаването на обекта, а деструкторът е метод, който се извиква автоматично непосредсвтвено преди изтриването на обекта.
+
+#Проверка на стойноста на полето:
+obj.show()

OOP/OOP theory/Обект за реализация на клас/Обект за реализация на клас.py

@@ -0,0 +1,59 @@
+class MyClass:
+    #Поле на класа:
+    color = 'Червен'
+    #Методи на класа:
+    def set(txt):
+        MyClass.color = txt
+    def show():
+        print(MyClass.color)
+#Извикване на методите на класа:
+MyClass.show()
+MyClass.set("Зелен")
+#Показване стойността на полето на класа:
+print(MyClass.color)
+#Задаваме нова стойност за полето на класа:
+MyClass.color = 'Син'
+#извикваме метода на класа:
+MyClass.show()
+#Създаваме обекти на класа:
+A = MyClass()
+B = MyClass()
+#Проверка на стойността на полето:
+print(f'Клас: {MyClass.color}')
+print(f'Обект А: {A.color}')
+print(f'Обект В: {B.color}')
+#Присвояваме стойност на полето:
+A.color = 'Бял'
+#Проверяваме стойността на полето:
+print(f'Клас: {MyClass.color}')
+print(f'Обект А: {A.color}')
+print(f'Обект В: {B.color}')
+#Защо при извикването на Обект А се принтира 'Бял', а не 'Син'? Защото на пръв поглед обекти А и В са еднакви, но всъщност не са- те имат различни места в РАМ паметта.
+MyClass.color = 'Оранжев'
+print(f'Клас: {MyClass.color}')
+print(f'Обект А: {A.color}')
+print(f'Обект В: {B.color}')
+#Защо при изхода обект А остана 'Бял'? Защото при създаването на обекти А/В на класа MyClass, ние всъщност създаваме референция към самия обект MyClass,
+#! Класът се реализира на основата на някакъв обект (в случая А и В), а името на класа съдържа РЕФЕРЕНЦИЯ към самия обект.
+print(type(A))
+print(type(B))
+print(type(MyClass))
+print()
+#Чрез type()/id() ние разбираме типа на данните (в случая класове) и техните адреси в РАМ паметта. Всички три типа, макар и на пръв поглед еднакви, са различни, ознавайки това от различните им адреси в паметта.
+print(id(A))
+print(id(B))
+print(id(MyClass))
+print()
+
+MyClass.color = ("Жълт")
+#Проверяваме стойността на полето:
+print(f'Клас: {MyClass.color}')
+print(f'Обект А: {A.color}')
+print(f'Обект В: {B.color}')
+print()
+#Защо А.колор връща 'син', а класът и обект В връщат 'Жълт'? Защото на обект В, който е референция към класа, не е придадена стойност на променлива color.
+del A.color
+print(f'Клас: {MyClass.color}')
+print(f'Обект А: {A.color}')
+print(f'Обект В: {B.color}')
+#След изтриване на обект А, търсенето на A.color няма да се осъществява в обект А, а в класа MyClass.

OOP/OOP theory/Операции с атрибутите на класовете и обектите/Задачки.txt

@@ -0,0 +1,3 @@
+https://pastebin.com/Vx6M6bRy
+https://pastebin.com/2ganVicZ
+https://pastebin.com/63v9mXqe

OOP/OOP theory/Операции с атрибутите на класовете и обектите/Операции с атрибутите на класовете и обектите.py

@@ -0,0 +1,77 @@
+#Първо заявеният атрибут се търси в обекта, а ако не бъде намерен там - тогава се търси в класа, на основата на който е създаден обектът.
+#Достъп до речника, посредством койот е реализиран обектът, може да бъде получен с помощта на специалния метод __dict__
+#Ако полето е заявено за класа, ще получим речника за обекта, посредством който е реализиран класът. Ако полето се заявява за обекта, като резултат ще получим речника, посредством който е реализиран даденият обект.
+
+#Създаваме два класа:
+class Alpha:
+    pass
+class Bravo:
+    name = 'Bravo'
+    def display():
+        print(f"Поле name: {Bravo.name}")
+    def show(self): #self е аргумент - референция към обекта, от който се извиква методът.
+        print(f'Поле value: {self.value}') #При извикването му се показва стойността на value от обекта, от който се извиква методът.
+    def __init__(self):
+        self.value = 123
+#Сега създавам обектите:
+A = Alpha()
+B = Bravo()
+
+#Атрибутите на първия клас:
+print("Клас Alpha")
+n = 1
+for s in Alpha.__dict__:
+    print("["+str(n)+"] "+s+":", Alpha.__dict__[s])
+    n += 1
+#Атрибути на втория клас:
+print(f"Клас Bravo:")
+n = 1
+for s in Bravo.__dict__:
+    print(f"[{n}] {s}: {Bravo.__dict__[s]}")
+    n += 1
+#Атриб ите:
+print(f"Обект А: {A.__dict__}")
+print(f"Обект В: {B.__dict__}")
+#И двата класа съдържат повече атрубити, отколкото са оказани в кода. Тези 'скрити' атрибути са т.нар 'служебни' атрибути, които са достъпни за класовете по подразбиране. Сред тях е и полето __dict__.
+#A и В са обекти, референции към класовете Алфа и Браво. За обектите се показват само онези атрибути, които са зададени непосредствено за обекта.
+
+#Извикване на метода на класа:
+Bravo.display()
+print()
+#Създаване на атрибут на класа:
+Alpha.display = Bravo.display #Вследствие от тази команда в клас Alpha се създава атрибут display. Стойност на атрибута се явява адресът на обекта, чрез който е реализиран метод display() от класа Bravo.
+
+#Изтриване на атрибут на класа:
+del Bravo.display
+#Извикване на метода от обекта:
+B.show()
+#Създаване на атрибут на класа:
+A.color = 'Червен'
+#Създаване на атрибут на обекта:
+B.show = lambda: print(f"Обект В: {B.value}") #Използвайки ламбда-функция създавам атрибут value към обект В, аналогично на B.value = Bravo.value
+
+#Атрибути на първия клас:
+print(f"Клас Alpha")
+
+n = 1
+for s in Alpha.__dict__:
+    print(f"[{n}] {s}: {Alpha.__dict__[s]}")
+    n += 1
+print()
+#Атрибути на втория клас
+
+n = 1
+for s in Bravo.__dict__:
+    print(f"[{n}] {s}: {Bravo.__dict__[s]}")
+    n += 1
+
+#Атрибути на обектите:
+print(f"Обект А: {A.__dict__}")
+print(f"Обект В: {B.__dict__}")
+
+print()
+
+#Извикване на методи:
+Alpha.display()
+Bravo.show(B)
+B.show()

OOP/small OOP problems/OOP problem 1 .py

@@ -0,0 +1,20 @@
+import statistics
+
+
+class MyClass():
+    def __init__(self, arg_list):
+        arg_list = [x for x in arg_list if x.isnumeric()]
+        self.arg_list = arg_list
+        self.arg_list = [int(x) for x in self.arg_list]
+
+    def show(self):
+        return print(f'The argument list: {self.arg_list}')
+
+    def average(self):
+        return print(f'Average value in args list is: {statistics.mean(self.arg_list):.2f}')
+
+
+current_list = [x for x in input().split()]
+obj = MyClass(current_list)
+obj.show()
+obj.average()

OOP/small OOP problems/OOP problem 2.py

@@ -0,0 +1,17 @@
+class MyClass():
+    def __init__(self, el_one, el_two):
+        self.el_one = el_one
+        self.el_two = el_two
+
+    def show(self):
+        if type(self.el_one) == str and type(self.el_one) == type(self.el_two):
+            return self.el_one + self.el_two
+        elif type(self.el_one) == int and type(self.el_one) == type(self.el_two):
+            return self.el_one + self.el_two
+
+
+obj = MyClass(1, 2)
+print(obj.show())
+
+obj_2 = MyClass('Hello ', 'World!')
+print(obj_2.show())