exam-prep-helper

# INHERITANCE - Наследяване
Този принцип позволява създаването на нови класове, които наследяват поведението(атрибути и методи) от вече съществуващи класове.
Както и може да го променим/разширим според нашите нужди.

Класът, който предава своите атрибути и методи,
се нарича -"Parent"=="родителски клас" (също наричан "Super"=="супер клас" или "Base"=="базов клас"),

а класът, който наследява тези атрибути и методи,
се нарича "Child"=="детски клас" (също наричан "Derived"=="потомък"=="производен клас").

Многожествено наследяване може да се постигне с Mixins.

===================================================================================================================================
# "ENCAPSULATION" - Инкапсулация
Принцип, който се отнася до скриването на детайли от реализацията на един обект и предоставянето на публичен интерфейс, чрез който други обекти могат да взаимодействат с него. Този принцип цели да улесни управлението на сложността на кода и да предпази данните и функционалността на обекта от неправилни манипулации.

 - PROTECTED (защитен): "_protected_this_func"
        Те не са предназначени да бъдат използвани извън класа, но все още са достъпни отвън.

- PRIVATE (частен): "__private_this_func"
    Считат за частни. Те са много ограничени и не могат да бъдат достъпвани директно отвън на класа.

Въпреки това може да се достъпи по този "tricky" начин:
    Instance = Class()
    print(instance._Class__variable)

"Getters" и "setters" се използват за четене и записване на стойности на атрибути на обект.
Тези методи позволяват контролиран достъп до атрибути и допълнителна логика при четене или записване на стойности.
Този подход подобрява инкапсулацията на данните и улеснява поддръжката на кода.
В Python този модел на четене и записване се реализира със специални методи,
известни като "property" и "setter"

===================================================================================================================================
# "POLYMORPHISM" - Полиморфизъм
Способността на обекти от различни класове да бъдат третирани като обекти на общ родителски клас.
Това позволява да се извършват общи операции над обекти от различни типове, без да е необходимо да се знае точно какъв тип е всеки обект.Полиморфизмът предоставя гъвкавост и улеснява разширяването на системата.

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# Функция, която приема обекти от тип Animal и извиква метода speak()
def animal_sound(animal):
    return animal.speak()

# Извикване на функцията animal_sound с обекти от различни типове
dog = Dog()
cat = Cat()
print(animal_sound(dog))  # Изход: Woof!
print(animal_sound(cat))  # Изход: Meow!

===================================================================================================================================
# "ABSTACTION" - Абстракция
Отнася се до създаването на абстрактни класове, които дефинират общи характеристики и методи, но оставят детайлите на реализацията на конкретните подкласове. Абстракцията позволява скриване на детайлите и фокусиране върху същността на обектите.
Дончо - "Абстракцията е да изпълниш дадена работа, без да кажеш, как точно я вършиш."

from abc import ABC, abstractmethod

# Абстрактен клас
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Конкретни класове, които наследяват абстрактния клас и реализират метода area()
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side * self.side

# Използване на абстрактния клас и неговите конкретни имплементации
circle = Circle(5)
square = Square(4)

print(circle.area())  # Изход: 78.5
print(square.area())  # Изход: 16

===================================================================================================================================

Всички методи и принципи, които споменахме - наследяване (inheritance), инкапсулация (encapsulation), полиморфизъм (polymorphism) и абстракция (abstraction) - са ключови концепции на обектно-ориентираното програмиране (ООП) и често се използват заедно за създаване на структуриран, лесно разбираем и поддръжаем код.
Ето как се свързват тези концепции:

    #Наследяване (Inheritance):
Наследяването ни позволява да създаваме нови класове, които наследяват атрибути и методи от вече съществуващи класове.
Това спомага за преизползването на код и организацията на кода във вид на хиерархия.
Взаимодействието между различни класове създава възможност за полиморфизъм.
Класовете могат да се третират като обекти на общ родителски клас,
което позволява извикването на методи от същия интерфейс, независимо от реалния тип на обекта.

    #Инкапсулация (Encapsulation):
Инкапсулацията ни позволява да скриваме детайлите на реализацията на класове и да предоставяме публични методи (интерфейс) за взаимодействие с тези класове. Това подобрява инкапсулацията на данните и прави кода по-чист и лесно поддържаем.
Методите "getter" и "setter" са честа форма на инкапсулация, като те позволяват контролиран достъп до атрибутите на класовете.

    #Полиморфизъм (Polymorphism):
Полиморфизмът се основава на наследяването и позволява обекти от различни типове да се третират като обекти на общ родителски клас. Това улеснява извършването на операции върху тези обекти, дори когато те имат различни реализации.
Полиморфизмът подчертава гъвкавостта на кода и се използва за обработка на множество обекти с общ интерфейс по един и същи начин.

    #Абстракция (Abstraction):
Абстракцията се използва за определяне на общи интерфейси и характеристики,
които отделят същността на обектите от техните детайли на реализация.
Полиморфизмът и абстракцията си взаимодействат, тъй като полиморфизмът ни позволява да използваме абстрактни класове или интерфейси за обработка на множество конкретни обекти. Това намалява зависимостта от конкретни реализации и улеснява поддръжката на кода.
===================================================================================================================================


***********************************************************************************************************************
# SOLID-Principles:

# 1. Single responsibility:
    Един клас или функция, трябва да бъде отговорен само за една специфична функция/действие
    и трябва да има само една причина да бъде променян.

# 2. Open/Closed:
    Един клас трябва да бъде отворен за екстендване(разширяване),
    но затворен за променянепо-този начин си подсигуряваме работещ код, който не изисква рефакториране.
    Това означава, че трябва да можем да добавяме нова функционалност, без да променяме съществуващия код.
    "Open for extend, but closed for modifications"

# 3. Liskov substitution:
    Обекти от суперкласа трябва да могат да бъдат заменени с обекти от неговите подкласове,
    без да се нарушава коректността на програмата.
    Усещаме се, че нарушаваме принципа, като имаме методи в класа, които реално той не може/не трябва да има

# 4. Interface Segregation:
    Клиентите не бива да са зависими от методи, които не използват.
    Постига се чрез разделянето на големи интерфейси на по-малки и специфични(чрез "Mixins").

# 5. Dependency inversion:
    Бащиният клас трябва да не знае нищо за класа, който го наследява.
    Детайлите зависят на абстракцията, а не абстракцията на детайлите.
    # 5.1 Dependency Injection - подчаст на Dependency Inversion:
        Инжектираме готова инстанция в класа.
        Въпрос на контекст е дали в метод или инит.

***********************************************************************************************************************



# LISTS as STACKS and QUEUES:
1. Stack = LIFO(LAST in FIRST out)

2. Queue = FIFO(FIRST in FIRST out)
- "ADD at index[0]" - my_queue.appendleft()
- "REMOVE at index[0]" - my_queue.popleft()
----------------------------------------------------------------------------
Queues in Python are FASTER then LISTS when getting item by index?
# False!
----------------------------------------------------------------------------
Queues in Python are FASTER then LISTS when popping elements from the start?
# True!
----------------------------------------------------------------------------
What is the structure that stands behind the deque in Python?
# Linked lists!



# TUPLES:
Tuple 'n_tuple' with a list as one of its item.
n_tuple = (1, 1, [3,4])

Items with same value have the same id.
id(n_tuple[0]) == id(n_tuple[1])
# True
Items with different value have different id.
id(n_tuple[0]) == id(n_tuple[2])
# False
------------------------------------------------------------------------------
# Combining two tuples to form a new tuple
x = (1,2,3,4)
y = (5,6,7,8)

z = x + y

z = (1, 2, 3, 4, 5, 6, 7, 8)
------------------------------------------------------------------------------
# The multiplication operation simply leads to repetition of the tuple.
x = (1,2,3,4)
z = x*2
z = (1, 2, 3, 4, 1, 2, 3, 4)




# SETS:
https://i.pinimg.com/originals/92/74/49/927449ed2c05f7cabe41d12d0db4c0ac.png
Sets operations:
    -UNION
    -INTERSECTION
    -DIFFERENCE
    -SYMETRIC DIFFERENCE
------------------------------------------------------------------------------
emptySet = set()    emptyDict = dict()
                    emptyDict = {}
------------------------------------------------------------------------------
Add:                        Remove:
# mySet.add('example')      # mySet.remove('example')
                            (if 'example' not in your set -> KeyError!)

It is important to note that the method raises a KeyError! if the set is empty.
You can use the clear method to remove all values from a set -> mySet.clear()

# Initialize 3 sets
set1 = set([1, 2, 3])
set2 = set([10, 20, 30])
set3 = {'a', 'b', 'c'}

set1.update(set2)
set1 = {1, 2, 3, 10, 20, 30}
set1.update(set3)
set1 = {1, 2, 3, 10, 20, 30, 'a', 'b', 'c'}