15 OOP 2: Inheritance, Polymorphism

լուսանկարի հղումը, Հեղինակ՝ Alexander starcew

(ToDo)

Song reference - ToDo

🎦 Տեսադասեր + լրացուցիչ (ToDo)

ToDo 1. Տեսություն 2025
2. Տեսություն 2023 (ToDo)
3. Գործնական 2025
4. Գործնական 2023 (ToDo)
5. Որոշ տնայինների լուծումներ (ToDo)

Google Forms ToDo

📚 Նյութը

Հավելյալ նյութեր

Inheritance (Ժառանգականություն)

Կարգին հաղորդում ունեինք, եկեք փորձենք կարգին սկետչ շոուի կլասը սարքել

class KarginHaxordum:
    vorak = "Ֆանտաստիկ"

    def __init__(self, hamar, derasanner, text):
        if hamar < 1:
             print("պետքա բնական թիվ լինի")
        self.hamar = hamar
        self.derasanner = derasanner
        self.text = text    


    def nkarel(self, vorak=None, derasanner=None, text=None): # կլասսի միջի ֆունկցիային անվանում ենք մեթոդ
        if vorak is None:
            vorak = self.vorak
        if derasanner is None:
            derasanner = self.derasanner
        if text is None:
            text = self.text

        print(f"Որակը՝ {vorak}")
        print(f"Կանչել {' '.join(derasanner)}")
        print(f"Խնրդել որ ասեն -> {text}")

class KarginSketchShow:
    vorak = "դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը"

    def __init__(self, hamar, derasanner, text):
        if hamar < 1:
            print("պետքա բնական թիվ լինի")
        self.hamar = hamar
        self.derasanner = derasanner
        self.text = text

    def nkarel(self, vorak=None, derasanner=None, text=None): # կլասսի միջի ֆունկցիային անվանում ենք մեթոդ
        if vorak is None:
            vorak = self.vorak
        if derasanner is None:
            derasanner = self.derasanner
        if text is None:
            text = self.text

        print(f"Որակը՝ {vorak}")
        print(f"Կանչել {' '.join(derasanner)}")
        print(f"Խնրդել որ ասեն -> {text}")

Կրկնվող կոդ -> օգտագործում ենք բութ մատի օրենքը -> կարանք ավելի լավ անենք

մի քիչ հեշտ դեպքից սկսենք

class KarginHaxordum:
    erkir = "Հայաստան"
    vorak = "ֆանտաստիկ"

    def glux_goval(self):
        print(f"Մեր որակը` {self.vorak}")

h = KarginHaxordum()

print(h.erkir)
print(h.vorak)
h.glux_goval()

Հայաստան
ֆանտաստիկ
Մեր որակը` ֆանտաստիկ

class KarginHaxordum:
    erkir = "Հայաստան"
    vorak = "ֆանտաստիկ"

    def glux_goval(self):
        print(f"Մեր որակը՝ {self.vorak}")

class KarginSketchShow:
    erkir = "Հայաստան"
    vorak = "դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը"

    def glux_goval(self):
        print(f"Մեր որակը` {self.vorak}")

վերևինի փոխարեն կարանք գրենք՝

class KarginSketchShow(KarginHaxordum):
    vorak = "դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը"

    budget = 500

s = KarginSketchShow()

print(s.vorak)
print(s.erkir)

դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը
Հայաստան

print(s.erkir)

Հայաստան

print(s.budget)

print(s.glux_goval())

Մեր որակը` դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը
None

Method overwrite

class KarginSketchShow(KarginHaxordum): 
    vorak = "դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը"

    def glux_goval(self): 
        print("մենք համեստ ենք, գլուխ չենք գովա")

s = KarginSketchShow()

print(s.vorak)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [23], in <cell line: 1>()
----> 1 s = KarginSketchShow()
      3 print(s.vorak)

TypeError: KarginHaxordum.__init__() missing 3 required positional arguments: 'hamar', 'derasanner', and 'text'

print(s.erkir)

Հայաստան

s.glux_goval()

մենք համեստ ենք, գլուխ չենք գովա

init-ի նրբությունները

class KarginHaxordum:
    erkir = "Հայաստան"
    vorak = "Ֆանտաստիկ"

    def __init__(self, hamar, derasanner, text):
        if hamar < 1:
            print("պետքա բնական թիվ լինի")
        self.hamar = hamar
        self.derasanner = derasanner
        self.text = text

    def nkarel(self, vorak=None, derasanner=None, text=None): 
        if vorak is None:
            vorak = self.vorak
        if derasanner is None:
            derasanner = self.derasanner
        if text is None:
            text = self.text

        print(f"Որակը՝ {vorak}")
        print(f"Կանչել {' '.join(derasanner)}")
        print(f"Խնրդել որ ասեն -> {text}")

class KarginSketchShow(KarginHaxordum):
    vorak = "դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը"

    def glux_goval(self):
        print("մենք համեստ ենք, գլուխ չենք գովա")

s = KarginSketchShow()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [31], in <cell line: 1>()
----> 1 s = KarginSketchShow()

TypeError: KarginHaxordum.__init__() missing 3 required positional arguments: 'hamar', 'derasanner', and 'text'

s = KarginSketchShow(509, ["Մկո", "Մավսես"], "պանիր")

s.hamar

s.glux_goval()

մենք համեստ ենք, գլուխ չենք գովա

Իսկ ինչ եթե ուզում ենք ինչ-որ պարամետրներ էլ ներառենք

class KarginSketchShow(KarginHaxordum):
    vorak = "դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը"

    def __init__(self, mtqi_hexinak):
        self.mtqi_hexinak = mtqi_hexinak

    def glux_goval(self):
        print("մենք համեստ ենք, գլուխ չենք գովա")

s = KarginSketchShow("Ռաֆո")

s.mtqi_hexinak

'Ռաֆո'

s.nkarel()

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In [38], in <cell line: 1>()
----> 1 s.nkarel()

Input In [29], in KarginHaxordum.nkarel(self, vorak, derasanner, text)
     14     vorak = self.vorak
     15 if derasanner is None:
---> 16     derasanner = self.derasanner
     17 if text is None:
     18     text = self.text

AttributeError: 'KarginSketchShow' object has no attribute 'derasanner'

s = KarginSketchShow("Ռաֆո")
print(s.mtqi_hexinak)
print(s.hamar)

Ռաֆո

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-147-6714aad4807c> in <cell line: 3>()

      1 s = KarginSketchShow("Ռաֆո")

      2 print(s.mtqi_hexinak)

----> 3 print(s.hamar)



AttributeError: 'KarginSketchShow' object has no attribute 'hamar'

class KarginSketchShow(KarginHaxordum):
    vorak = "դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը"

    def __init__(self, hamar, derasanner, text, mtqi_hexinak):
        self.mtqi_hexinak = mtqi_hexinak

        if hamar < 1:
            print("պետքա բնական թիվ լինի")
        self.hamar = hamar
        self.derasanner = derasanner
        self.text = text
        
    def glux_goval(self):
        print("մենք համեստ ենք, գլուխ չենք գովա")

s = KarginSketchShow(509, ["Մկո", "Մավսես"], "պանիր", "Ռաֆո")
print(s.mtqi_hexinak)
print(s.derasanner)

Ռաֆո
['Մկո', 'Մավսես']

class KarginSketchShow(KarginHaxordum):
    vorak = "դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը"

    def __init__(self, hamar, derasanner, text, mtqi_hexinak):
        # KarginHaxordum.__init__(self, hamar, derasanner, text)
        super().__init__(hamar, derasanner, text)
        self.mtqi_hexinak = mtqi_hexinak

    def glux_goval(self):
        print("մենք համեստ ենք, գլուխ չենք գովա")

s = KarginSketchShow(509, ["Մկո", "Մավսես"], "պանիր", "Ռաֆո")
print(s.mtqi_hexinak)
print(s.hamar)
print(s.nkarel())

Ռաֆո
509
Որակը՝ դե կարգին հաղորդում չի իհարկե, բայց դե փորձեցին ժողովուրդը
Կանչել Մկո Մավսես
Խնրդել որ ասեն -> պանիր
None

Exceptionների օրինակ

raise ValueError("problem")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [44], in <cell line: 1>()
----> 1 raise ValueError("problem")

ValueError: problem

class MerSepakanException(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

ser = input("Դուք սիրու՞մ եք կարգին հաղորդում: ")
if ser != "շատ":
    raise MerSepakanException(f"վայ-վայ-վայ, քոռանայի չլսեի")

---------------------------------------------------------------------------
MerSepakanException                       Traceback (most recent call last)
Input In [45], in <cell line: 7>()
      6 ser = input("Դուք սիրու՞մ եք կարգին հաղորդում: ")
      7 if ser != "շատ":
----> 8     raise MerSepakanException(f"վայ-վայ-վայ, քոռանայի չլսեի")

MerSepakanException: վայ-վայ-վայ, քոռանայի չլսեի

isinstance, issubclass

type(4) == int

True

class Animal:
    pass

class Shun(Animal):
    pass

tuzik = Shun()

print(isinstance(tuzik, int))
print(isinstance(tuzik, Shun))
print(isinstance(tuzik, Animal))

False
True
True

class Animal:
    pass

class Shun(Animal):
    pass

print(issubclass(Shun, int))
print(issubclass(Shun, Animal))
print(issubclass(Animal, Shun))

False
True
False

Method resolution order (MRO)

class A1:
    def foo(self):
        print("A1.foo")

class A2:
    def foo(self):
        print("A2.foo")

class B1(A1): # B1, A1, object
    name = "b1"
    pass
    # def foo(self):
    #     print("B1.foo")
        
class B2(A2): # B2, A2, object
    name = "b2"
    def foo(self):
        print("B2.foo")

class C(B1, B2):
    pass

# A1 | A2
# B1 | B2
# C

c = C()
c.foo()          
print(C.mro())   

print(c.name)

A1.foo
[<class '__main__.C'>, <class '__main__.B1'>, <class '__main__.A1'>, <class '__main__.B2'>, <class '__main__.A2'>, <class 'object'>]
b1

Միշտ չի որ կաշխատի՝

class A:
    pass 

class B(A):
    pass 

class C(A):
    pass

class X(B, C):
    pass 

class Y(C, B):
    pass

class Z(X, Y):
    pass

z = Z()
z.mro()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [60], in <cell line: 16>()
     13 class Y(C, B):
     14     pass
---> 16 class Z(X, Y):
     17     pass
     19 z = Z()

TypeError: Cannot create a consistent method resolution
order (MRO) for bases B, C

The key thing is that Python’s C3‐linearization must respect the local precedence order declared in each class. In class B2(A1, A2) you’ve said “A1 comes before A2,” so no MRO for any subclass of B2 may ever put A2 before A1.

Composition vs Inheritance

In object‐oriented design, composition over inheritance is the principle that you should prefer to build complex behavior by combining (“composing”) simple objects, rather than by creating deep class hierarchies through inheritance.

class Bird:
    def fly(self):  
        print("Flapping wings")

class Duck(Bird):
    pass

class Ostrich(Bird):
    # Ostriches can't fly, but still inherit fly()
    def fly(self):
        raise NotImplementedError("Ostrich can't fly!")

Here, Ostrich must override fly() just to prevent inherited behavior that doesn’t apply. As more behaviors accumulate (swimming, singing, nesting…), you could end up with a combinatorial explosion of subclasses.

Composition approach

class FlyingBehavior:
    def fly(self):
        print("Flapping wings")

class NoFlyBehavior:
    def fly(self):
        raise NotImplementedError("Cannot fly!")

class Bird:
    def __init__(self, fly_behavior):
        self._fly_behavior = fly_behavior

    def fly(self):
        return self._fly_behavior.fly()

class Duck(Bird):
    def __init__(self):
        super().__init__(FlyingBehavior())

class Ostrich(Bird):
    def __init__(self):
        super().__init__(NoFlyBehavior())

duck = Duck()
duck.fly()
# → “Flapping wings”

Flapping wings

ostrich = Ostrich()
ostrich.fly()

---------------------------------------------------------------------------
NotImplementedError                       Traceback (most recent call last)
Input In [65], in <cell line: 2>()
      1 ostrich = Ostrich()
----> 2 ostrich.fly()

Input In [63], in Bird.fly(self)
      5 def fly(self):
----> 6     return self._fly_behavior.fly()

Input In [62], in NoFlyBehavior.fly(self)
      6 def fly(self):
----> 7     raise NotImplementedError("Cannot fly!")

NotImplementedError: Cannot fly!

Polymorphism

Programiz - Python Polymorphism

# +
print("1" + "1")
print(1 + 1)

# __add__()
# int + int
# print(KarginHaxordum + )
# +, in, len, [0]

11
2

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_rect_area(self):
        return self.width * self.height

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def calculate_circle_area(self):
        return 3.141592 * self.radius ** 2

rect1 = Rectangle(34, 10)
rect2 = Rectangle(14, 509)
circle1 = Circle(3)
circle2 = Circle(5)

print(rect1.calculate_rect_area())
print(rect2.calculate_rect_area())
print(circle1.calculate_circle_area())
print(circle2.calculate_circle_area())

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_rect_area(self):
        return self.width * self.height

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def calculate_circle_area(self):
        return 3.141592 * self.radius * self.radius

rect1 = Rectangle(34, 10)
rect2 = Rectangle(11, 509)
circle1 = Circle(3)
circle2 = Circle(5)

for r in [rect1, rect2]:
    print(r.calculate_rect_area())

for c in [circle1, circle2]:
    print(c.calculate_circle_area())

340
5599
28.274328000000004
78.5398

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return 3.141592 * self.radius * self.radius

rect1 = Rectangle(34, 10)
rect2 = Rectangle(11, 509)
circle1 = Circle(3)
circle2 = Circle(5)

for shape in [rect1, rect2, circle1, circle2]:
    print(shape.calculate_area())

340
5599
28.274328000000004
78.5398

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return 3.141592 * self.radius * self.radius

rect1 = Rectangle(34, 10)
rect2 = Rectangle(11, 509)
circle1 = Circle(3)
circle2 = Circle(5)

def area(shape):
    return shape.calculate_area()

print(area(rect1))
print(area(circle2))

340
78.5398

class Armenian:
    def barevel(self):
        return "Բարև"

class SpyurqaArmenian:
    def barevel(self):
        return "Փարևև, բաբամ"

a = Armenian()
s = SpyurqaArmenian()

def barev(mard):
    return mard.barevel()

barev(a), barev(s)

('Բարև', 'Փարևև, բաբամ')

Magic methods

import os
import json

PATH = os.path.join("assets", "imdb_top_999.json")

with open(PATH, "r") as f:
    data = json.load(f)

KEYS_TO_DELETE = ['Meta_score', "No_of_Votes", "Overview"]


for i in data.keys():
    for k in KEYS_TO_DELETE:
        del data[i][k]

for i in data.keys():
    data[i]["Name"] = i

data["The Shawshank Redemption"]

{'Released_Year': '1994',
 'Runtime': '142 min',
 'Genre': 'Drama',
 'IMDB_Rating': 9.3,
 'Director': 'Frank Darabont',
 'Star1': 'Tim Robbins',
 'Star2': 'Morgan Freeman',
 'Star3': 'Bob Gunton',
 'Star4': 'William Sadler',
 'Gross': '28,341,469',
 'Name': 'The Shawshank Redemption'}

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def get_actors(self):
        self.star_string = ", ".join([self.star1, self.star2, self.star3, self.star4])
        return self.star_string

    def get_info(self):
        self.info = f"Was released in {self.release_year} by {self.director}"
        return self.info

k1 = Kino(**data["The King's Speech"])

print(k1.get_actors())
print(k1.get_info())
print(k1)

Colin Firth, Geoffrey Rush, Helena Bonham Carter, Derek Jacobi
Was released in 2010 by Tom Hooper
<__main__.Kino object at 0x0000016F14FE21D0>

Category	Key Methods	What They Enable
Representation	`__str__`, `__repr__`	`print(obj)`, helpful print
Size & Truthiness	`__len__`, `__bool__`	`len(obj)`, `if obj:`
Iteration & Container Access	`__iter__`, `__next__`, `__getitem__`	`for x in obj`, `obj[i]`
Arithmetic / Operators	`__add__`, `__sub__`, `__mul__`, …	`obj1 + obj2`, `obj * 3`
Comparison	`__eq__`, `__lt__`, …	`obj1 == obj2`, sorting
Context Management	`__enter__`, `__exit__`	`with obj:` blocks

# __init__()
# __str__()

movie = Kino(**data["Forrest Gump"])
print(movie)

<__main__.Kino object at 0x0000016F14F565F0>

Representation (repr, str)

str

print([2, 3])

[2, 3]

print(movie)

<__main__.Kino object at 0x7a6dd30b8f90>

a = str(movie)
print(movie.__str__())
print(a)

# 1 + 1
# 1.__add__(1)

<__main__.Kino object at 0x0000016F14F565F0>
<__main__.Kino object at 0x0000016F14F565F0>

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __str__(self):
        return f"{self.name} by {self.director}, released in {self.release_year}"

    def get_actors(self):
        self.star_string = ", ".join([self.star1, self.star2, self.star3, self.star4])
        return self.star_string

    def get_info(self):
        self.info = f"Was released in {self.release_year} by {self.director}"
        return self.info


movie = Kino(**data["Forrest Gump"])

print(movie)
print(movie.__str__())
print(str(movie))

Forrest Gump by Robert Zemeckis, released in 1994
Forrest Gump by Robert Zemeckis, released in 1994
Forrest Gump by Robert Zemeckis, released in 1994

a = repr(movie)
print(a)

<__main__.Kino object at 0x0000016F1616CE50>

repr

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __str__(self):
        return f"{self.name} by {self.director}, released in {self.release_year}"

    # movie = Kino(**data["Forrest Gump"])
    def __repr__(self):
        return f"to create run Kino(**data['{self.name}']))"

    def get_actors(self):
        self.star_string = ", ".join([self.star1, self.star2, self.star3, self.star4])
        return self.star_string

    def get_info(self):
        self.info = f"Was released in {self.release_year} by {self.director}"
        return self.info


movie = Kino(**data["Forrest Gump"])

print(movie) # str եթե կա, եթե չէ repr

to create run Kino(**data['Forrest Gump']))

repr(movie)

"to create run Kino(**data['Forrest Gump']))"

Arithmetic / Operators (eq, ne, lt, le, gt, ge)

eq

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __str__(self):
        return f"{self.name} by {self.director}, released in {self.release_year}"

    def __repr__(self):
        return f"to create run Kino(**data['{self.name}']))"

    def get_actors(self):
        self.star_string = ", ".join([self.star1, self.star2, self.star3, self.star4])
        return self.star_string

    def get_info(self):
        self.info = f"Was released in {self.release_year} by {self.director}"
        return self.info



movie1 = Kino(**data["Forrest Gump"])
movie2 = Kino(**data['The Shawshank Redemption'])

movie1 == movie2

False

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __eq__(self, other): # equal
        return self.director == other.director


movie1 = Kino(**data['The Godfather'])
movie2 = Kino(**data["The Godfather: Part II"])
movie3 = Kino(**data['The Shawshank Redemption'])

# data['The Godfather']
movie2.director

'Francis Ford Coppola'

print(movie1 == movie2) # -> movie1.__eq__(movie2)
print(movie1 == movie3)

True
False

print(movie2 != movie3)

True

not equal

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __eq__(self, other):
        return self.director == other.director

    def __ne__(self, other): # not equal
        return not self.__eq__(other)


movie1 = Kino(**data['The Godfather'])
movie2 = Kino(**data["The Godfather: Part II"])
movie3 = Kino(**data['The Shawshank Redemption'])

print(movie1 != movie2)

False

print(movie2 != movie3)

True

less than, less than or equal, greater than, greater than or equal

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __lt__(self, other): # less than
        return self.rating < other.rating

movie1 = Kino(**data['The Godfather'])
movie2 = Kino(**data["The Godfather: Part II"])
movie3 = Kino(**data['The Shawshank Redemption'])

print(movie1 < movie2)

False

print(movie1 <= movie2)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [103], in <cell line: 1>()
----> 1 print(movie1 <= movie2)

TypeError: '<=' not supported between instances of 'Kino' and 'Kino'

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __lt__(self, other):
        return self.rating < other.rating

    def __le__(self, other): # less or equal
        return self.rating <= other.rating


movie1 = Kino(**data['The Godfather'])
movie2 = Kino(**data["The Godfather: Part II"])
movie3 = Kino(**data['The Shawshank Redemption'])

print(movie2 <= movie3)

True

greater than ու greater than or equalը նման ձևով

add, sub, mul, truediv, floordiv, mod, pow

movie1 + movie2 # **, +, -, *, //

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-59-205a91fb7f6d> in <cell line: 1>()

----> 1 movie1 + movie2



TypeError: unsupported operand type(s) for +: 'Kino' and 'Kino'

movie1.__add__(movie2)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-60-d2e93785a7d5> in <cell line: 1>()

----> 1 movie1.__add__(movie2)



AttributeError: 'Kino' object has no attribute '__add__'

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __add__(self, other):
        print(f"adding {self.name} and {other.name}")
        return int(self.runtime.split()[0]) + int(other.runtime.split()[0])
        # 132 minutes

movie1 = Kino(**data['The Godfather'])
movie2 = Kino(**data["The Godfather: Part II"])
movie3 = Kino(**data['The Shawshank Redemption'])

movie1 + movie2

adding The Godfather and The Godfather: Part II

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __truediv__(self, other): # /
        return self.rating / other.rating

    def __floordiv__(self, other): # / /
        return "երկուսն էլ լավն են"

movie1 = Kino(**data['The Godfather'])
movie2 = Kino(**data["The Godfather: Part II"])
movie3 = Kino(**data['The Shawshank Redemption'])

movie3 / movie1

1.0108695652173914

movie3 // movie1

'երկուսն էլ լավն են'

length (len), bool (bool)

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross

    def __len__(self):
        duration = int(self.runtime.split()[0])
        return duration // 60 + 1 # must be integer

movie1 = Kino(**data['The Godfather'])
movie2 = Kino(**data["The Godfather: Part II"])
movie3 = Kino(**data['The Shawshank Redemption'])

len(movie1)

# if bool(movie1:

Indexes

getitem, setitem, delitem,

class Genre:
    def __init__(self, name, description, kinoner=None):
        self.name = name
        self.description = description
        self.kinoner = kinoner if kinoner else []

    def number_of_films(self):
        return len(self.kinoner)

    def get_average_rating(self):
        total = 0
        for k in self.kinoner:
            total += k.rating
        return total / self.number_of_films()

movies_list = [Kino(**data[i]) for i in data.keys()]

movies_by_genre = {}

for movie in movies_list:
    for g in movie.genre.split(", "):
        if g in movies_by_genre.keys():
            movies_by_genre[g].append(movie)
        else:
            movies_by_genre[g] = [movie]

drama = Genre(name="Drama", description="Լացելու կինոներ", kinoner=movies_by_genre['Drama'])

drama.get_average_rating()

7.959059474412212

drama.kinoner[0:4]

[<__main__.Kino at 0x16f14fe39d0>,
 <__main__.Kino at 0x16f14fe2080>,
 <__main__.Kino at 0x16f14fe1fc0>,
 <__main__.Kino at 0x16f14fe2170>]

print(drama.kinoner[1])

<__main__.Kino object at 0x0000016F14FE2080>

demo

# drama[0]

# print([1,2,3][0])
print({1,2,3}[0])

<>:4: SyntaxWarning: 'set' object is not subscriptable; perhaps you missed a comma?
<>:4: SyntaxWarning: 'set' object is not subscriptable; perhaps you missed a comma?
C:\Users\hayk_\AppData\Local\Temp\ipykernel_15068\4075712312.py:4: SyntaxWarning: 'set' object is not subscriptable; perhaps you missed a comma?
  print({1,2,3}[0])
C:\Users\hayk_\AppData\Local\Temp\ipykernel_15068\4075712312.py:4: SyntaxWarning: 'set' object is not subscriptable; perhaps you missed a comma?
  print({1,2,3}[0])
C:\Users\hayk_\AppData\Local\Temp\ipykernel_15068\4075712312.py:4: SyntaxWarning: 'set' object is not subscriptable; perhaps you missed a comma?
  print({1,2,3}[0])

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [126], in <cell line: 4>()
      1 # drama[0]
      2 
      3 # print([1,2,3][0])
----> 4 print({1,2,3}[0])

TypeError: 'set' object is not subscriptable

class Genre:
    def __init__(self, name, description, kinoner=None):
        self.name = name
        self.description = description
        self.kinoner = kinoner if kinoner else []

    def get_average_rating(self):
        total = 0
        for k in self.kinoner:
            total += k.rating
        return total / self.number_of_films()

    def number_of_films(self):
        return len(self.kinoner)

    def __getitem__(self, index):
        return self.kinoner[index]

    def __setitem__(self, index, value):
        self.kinoner[index] = value

    def __delitem__(self, index):
        del self.kinoner[index]

drama = Genre(name="Drama", description="Լացելու կինոներ", kinoner=movies_by_genre['Drama'])

drama[0] # drama.__getitem__(0)

<__main__.Kino at 0x16f14fe39d0>

drama[0] = "կարգին հաղորդում" # drama.__setitem__(0, "կարգին հաղորդում")

drama[0]

'կարգին հաղորդում'

drama.kinoner[:5]

['կարգին հաղորդում',
 <__main__.Kino at 0x16f14fe2080>,
 <__main__.Kino at 0x16f14fe1fc0>,
 <__main__.Kino at 0x16f14fe2170>,
 <__main__.Kino at 0x16f14fe1810>]

del drama[0]

drama[:4]

[<__main__.Kino at 0x16f14fe2080>,
 <__main__.Kino at 0x16f14fe1fc0>,
 <__main__.Kino at 0x16f14fe2170>,
 <__main__.Kino at 0x16f14fe1810>]

contains

class Kino:
    def __init__(self, Name, Released_Year, Runtime, Genre, IMDB_Rating, Director,
                Star1, Star2, Star3, Star4, Gross):
        self.name = Name
        self.release_year = Released_Year
        self.runtime = Runtime
        self.genre = Genre
        self.rating = IMDB_Rating
        self.director = Director
        self.star1 = Star1
        self.star2 = Star2
        self.star3 = Star3
        self.star4 = Star4
        self.gross = Gross


    def get_actors(self):
        self.star_string = ", ".join([self.star1, self.star2, self.star3, self.star4])
        return self.star_string

    def __contains__(self, other) -> bool:
        return self.star1 in other.get_actors()

movie1 = Kino(**data['The Godfather'])
movie2 = Kino(**data["The Godfather: Part II"])
movie3 = Kino(**data['The Shawshank Redemption'])

movie1 in movie3

False

🏡Տնային

Պրոեկտում magic method—ներ ավելացնել

🎲 15

▶️Thomas Flight
▶️Video 🔥
🇦🇲🎶Քարահունջ
🌐🎶Damien Rice
🤌Կարգին