Objektově orientované programování v Pythonu

V tomto kurzu se na příkladech dozvíte o objektově orientovaném programování (OOP) v Pythonu a jeho základním konceptu.

Video: Objektově orientované programování v Pythonu

Objektově orientované programování

Python je programovací jazyk s více paradigmaty. Podporuje různé programovací přístupy.

Jedním z populárních přístupů k řešení programovacího problému je vytváření objektů. Toto je známé jako objektově orientované programování (OOP).

Objekt má dvě vlastnosti:

  • atributy
  • chování

Vezměme si příklad:

Papoušek může být objekt, protože má následující vlastnosti:

  • jméno, věk, barva jako atributy
  • zpěv, tanec jako chování

Koncept OOP v Pythonu se zaměřuje na vytváření opakovaně použitelného kódu. Tento koncept je také známý jako DRY (Don't Repeat Yourself).

V Pythonu se koncept OOP řídí některými základními principy:

Třída

Třída je plán pro objekt.

Třídu si můžeme představit jako náčrt papouška se štítky. Obsahuje všechny podrobnosti o jménu, barvách, velikosti atd. Na základě těchto popisů můžeme o papoušku studovat. Zde je papoušek objekt.

Příkladem pro třídu papouška může být:

 třída Papoušek: projít

Zde používáme classklíčové slovo k definování prázdné třídy Parrot. Z třídy vytváříme instance. Instance je konkrétní objekt vytvořený z konkrétní třídy.

Objekt

Objekt (instance) je instancí třídy. Když je definována třída, je definován pouze popis objektu. Proto není přidělena žádná paměť ani úložiště.

Příkladem pro objekt třídy papouška může být:

 obj = Parrot ()

Zde je obj objekt třídy Parrot.

Předpokládejme, že máme podrobnosti o papoušcích. Nyní ukážeme, jak postavit třídu a objekty papoušků.

Příklad 1: Vytvoření třídy a objektu v Pythonu

 class Parrot: # class attribute species = "bird" # instance attribute def __init__(self, name, age): self.name = name self.age = age # instantiate the Parrot class blu = Parrot("Blu", 10) woo = Parrot("Woo", 15) # access the class attributes print("Blu is a ()".format(blu.__class__.species)) print("Woo is also a ()".format(woo.__class__.species)) # access the instance attributes print("() is () years old".format( blu.name, blu.age)) print("() is () years old".format( woo.name, woo.age))

Výstup

 Blu je pták Woo je také pták Blu má 10 let Woo je 15 let

Ve výše uvedeném programu jsme vytvořili třídu s názvem Parrot. Poté definujeme atributy. Atributy jsou charakteristikou objektu.

Tyto atributy jsou definovány uvnitř __init__metody třídy. Je to metoda inicializátoru, která se nejprve spustí, jakmile se vytvoří objekt.

Potom vytvoříme instance třídy Parrot. Zde jsou blu a woo odkazy (hodnota) na naše nové objekty.

K atributu třídy můžeme přistupovat pomocí __class__.species. Atributy třídy jsou stejné pro všechny instance třídy. Podobně přistupujeme k atributům instance pomocí blu.namea blu.age. Atributy instance jsou však pro každou instanci třídy odlišné.

Další informace o třídách a objektech najdete v části Třídy a objekty Pythonu

Metody

Metody jsou funkce definované uvnitř těla třídy. Používají se k definování chování objektu.

Příklad 2: Vytváření metod v Pythonu

 class Parrot: # instance attributes def __init__(self, name, age): self.name = name self.age = age # instance method def sing(self, song): return "() sings ()".format(self.name, song) def dance(self): return "() is now dancing".format(self.name) # instantiate the object blu = Parrot("Blu", 10) # call our instance methods print(blu.sing("'Happy'")) print(blu.dance())

Výstup

 Blu zpívá „Happy“ Blu nyní tančí

Ve výše uvedeném programu, definujeme dvě metody, tj sing()a dance(). Tyto metody se nazývají instance, protože jsou volány na instančním objektu, tj blu.

Dědictví

Inheritance is a way of creating a new class for using details of an existing class without modifying it. The newly formed class is a derived class (or child class). Similarly, the existing class is a base class (or parent class).

Example 3: Use of Inheritance in Python

 # parent class class Bird: def __init__(self): print("Bird is ready") def whoisThis(self): print("Bird") def swim(self): print("Swim faster") # child class class Penguin(Bird): def __init__(self): # call super() function super().__init__() print("Penguin is ready") def whoisThis(self): print("Penguin") def run(self): print("Run faster") peggy = Penguin() peggy.whoisThis() peggy.swim() peggy.run()

Output

 Bird is ready Penguin is ready Penguin Swim faster Run faster

In the above program, we created two classes i.e. Bird (parent class) and Penguin (child class). The child class inherits the functions of parent class. We can see this from the swim() method.

Again, the child class modified the behavior of the parent class. We can see this from the whoisThis() method. Furthermore, we extend the functions of the parent class, by creating a new run() method.

Additionally, we use the super() function inside the __init__() method. This allows us to run the __init__() method of the parent class inside the child class.

Encapsulation

Using OOP in Python, we can restrict access to methods and variables. This prevents data from direct modification which is called encapsulation. In Python, we denote private attributes using underscore as the prefix i.e single _ or double __.

Example 4: Data Encapsulation in Python

 class Computer: def __init__(self): self.__maxprice = 900 def sell(self): print("Selling Price: ()".format(self.__maxprice)) def setMaxPrice(self, price): self.__maxprice = price c = Computer() c.sell() # change the price c.__maxprice = 1000 c.sell() # using setter function c.setMaxPrice(1000) c.sell()

Output

 Selling Price: 900 Selling Price: 900 Selling Price: 1000

In the above program, we defined a Computer class.

We used __init__() method to store the maximum selling price of Computer. We tried to modify the price. However, we can't change it because Python treats the __maxprice as private attributes.

As shown, to change the value, we have to use a setter function i.e setMaxPrice() which takes price as a parameter.

Polymorphism

Polymorphism is an ability (in OOP) to use a common interface for multiple forms (data types).

Suppose, we need to color a shape, there are multiple shape options (rectangle, square, circle). However we could use the same method to color any shape. This concept is called Polymorphism.

Example 5: Using Polymorphism in Python

 class Parrot: def fly(self): print("Parrot can fly") def swim(self): print("Parrot can't swim") class Penguin: def fly(self): print("Penguin can't fly") def swim(self): print("Penguin can swim") # common interface def flying_test(bird): bird.fly() #instantiate objects blu = Parrot() peggy = Penguin() # passing the object flying_test(blu) flying_test(peggy)

Output

 Parrot can fly Penguin can't fly

In the above program, we defined two classes Parrot and Penguin. Each of them have a common fly() method. However, their functions are different.

Abychom mohli použít polymorfismus, vytvořili jsme společné rozhraní, tj. flying_test()Funkci, která přijímá jakýkoli objekt a volá metodu objektu fly(). Když jsme tedy ve flying_test()funkci předali objekty blu a peggy , běželo to efektivně.

Klíčové body k zapamatování:

  • Objektově orientované programování činí program snadno srozumitelným a efektivním.
  • Vzhledem k tomu, že třídu lze sdílet, lze kód znovu použít.
  • Data jsou bezpečná a zabezpečená pomocí abstrakce dat.
  • Polymorfismus umožňuje stejné rozhraní pro různé objekty, takže programátoři mohou psát efektivní kód.

Zajímavé články...