Wstęp do programowania

Wstęp do programowania Wykład 12 Wstęp do programowania obiektowego Janusz Szwabiński Plan wykładu: Pierwsze kroki Programowanie obiektowe W stronę zastosowań praktycznych klasa Particle Więcej o metodach Metody specjalne Atrybuty klas Składowe prywatne Dziedziczenie Serializacja (marynowanie) instancji klas Pierwsze kroki Załóżmy, że chcemy na komputerze przedstawić punkt (lub zbiór punktów) na płaszczyźnie. W notacji matematycznej punkt taki przedstawia się z reguły przy pomocy nawiasów, wewnątrz których umieszcza się oddzielone przecinkiem współrzędne. y 3 (2,3) ( 3,1) 3 2 1 1 2 3 1 2 1 (0,0) x 2 ( 1.5, 2.5) 3 Taki punkt możemy reprezentować w Pythonie na kilka sposobów: możemy przechowywać współrzędne punktu w dwóch różnych współrzędnych możemy przechowywać współrzędne punktu jako elementy listy lub krotki możemy stworzyć własny typ danych

Słowo kluczowe class Do definiowania typów użytkownika służy słowo kluczowe class. Dlatego taki typ nazywany jest często klasą: In [1]: class Point: """Reprezentacja punktu na płaszczyźnie""" Definicja klasy przypomina definicję funkcji. Po słowie kluczowym następuje jej nazwa i dwukropek, a następnie wcięte względem nagłówka instrukcje tworzące ciało klasy. Oczywiście klasa w powyższym przykładzie jest bardzo prosta, jej ciało zawiera tylko napis dokumentujący. Wykonanie definicji powoduje stworzenie odpowiadającego jej obiektu w pamięci: In [2]: print(point) <class ' main.point'> In [3]: type(point) Out[3]: type Programiści C++ mogą być trochę zaskoczeni, ponieważ pod tym wzgledem C++ różni się od Pythona w C++ obiekty odpowiadają dopiero zmiennym nowego typu, czyli instancjom klasy. Oczywiście w Pythonie też możemy tworzyć takie instancje: In [4]: blank = Point() Jednak odpowiadają im już inne obiekty: In [5]: print(blank) < main.point object at 0x7f074c6980b8> In [6]: type(blank) Out[6]: main.point Część własności dotyczących modułów jest aktualna w przypadku klas:

In [7]: dir(point) Out[7]: [' class ', ' delattr ', ' dict ', ' dir ', ' doc ', ' eq ', ' format ', ' ge ', ' getattribute ', ' gt ', ' hash ', ' init ', ' le ', ' lt ', ' module ', ' ne ', ' new ', ' reduce ', ' reduce_ex ', ' repr ', ' setattr ', ' sizeof ', ' str ', ' subclasshook ', ' weakref '] In [8]: print(point. module ) main In [9]: print(point. doc ) Reprezentacja punktu na płaszczyźnie Wszystko jest obiektem Różne języki programowania wprowadzają różne definicje obiektów. W niektórych obiekt musi mieć atrybuty i metody, w innych o obiektach możemy mówić, jeśli można z nich tworzyć podklasy. W Pythonie mamy do czynienia z mniej restrykcyjną definicją po prostu wszystko jest obiektem. Atrybuty W Pythonie nie jest problemem dodawanie atrybutów do istniejącej już instancji (choć oczywiście są lepsze sposoby na ich definiowanie):

In [10]: blank.x = 3.0 blank.y = 4.0 In [11]: print("(",blank.x,",",blank.y,")") ( 3.0, 4.0 ) Zwróćmy uwagę, że z podobnej składni używamy, aby skorzystać np. ze składowych modułu. Instancja może być argumentem funkcji: In [12]: def print_point(p): print("(%g,%g)" % (p.x,p.y)) In [13]: print_point(blank) (3,4) In [14]: blank2 = Point() In [15]: print_point(blank2) ------------------------------------------------------------------- -------- AttributeError Traceback (most recent ca ll last) <ipython-input-15-5cae89dad20a> in <module>() ----> 1 print_point(blank2) <ipython-input-12-1e87b98c7298> in print_point(p) 1 def print_point(p): ----> 2 print("(%g,%g)" % (p.x,p.y)) AttributeError: 'Point' object has no attribute 'x' Programowanie obiektowe

Programowanie obiektowe (ang. object oriented programming, OOP) to paradygmat programowania, w którym programy definiuje się za pomocą obiektów elementów łączących stan (dane) i zachowanie (procedury, czyli metody). Obiektowy program komputerowy to nic innego jak zbiór takich obiektów, komunikujących się pomiędzy sobą w celu wykonywania zadań. Programowanie obiektowe tym różni sie od tradycyjnego programowania strukturalnego (czyli ogólnie tego, czym zajmowaliśmy się do tej pory), że w tym drugim dane i procedury nie są ze sobą bezpośrednio powiązane. W obiegowej opinii najwiekszym atutem programowania obiektowego jest naturalne odwzorowanie rzeczywistości otaczający nas świat jest złożony z obiektów będących instancjami pewnych bardziej ogólnych klas. Elementy języka obiektowego Poszczególne obiektowe języki oprogramowania różnią się między sobą niektórymi własnościami. Powszechnie uważa się jednak, że następujące elementy czynią te języki obiektowymi: abstrakcja, czyli model, który w rzeczywistości nie reprezentuje żadnego istniejącego obiektu, ale który stanowi podstawę do definiowania obiektów. Najczęściej utożsamiany z klasą. Przykładem może być zwierzę w rzeczywistości występują obiekty potomne (np. pies, kot), których pewne własności są typowe dla klasy zwierzę. hermetyzacja (lub enkapsulacja), czyli ukrywanie implementacji. Celem jest unikanie sytuacji, w których jeden obiekt zmienia stan wewnętrzny innych obiektów w nieoczekiwany sposób. W ramach hermetyzacji każdy obiekt prezentuje innym obiektom swój interfejs, który określa dopuszczalne metody współpracy. W Pythonie hermetyzacja jest w dużym stopniu umowna. polimorfizm, inaczej wielopostaciowość, to metoda pozwalająca funkcji wirtualnej przyjmować różne sposoby jej realizacji. Na przykład, metoda jedźna rowerze jest realizowana inaczej niż metoda jedźw samochodzie, mimo takiej samej nazwy. dziedziczenie umożliwia tworzenie specjalizowanych obiektów na podstawie bardziej ogólnych (np. Particle --> Boson). Odzwierciedla wspólne cechy obiektów. Dla obiektów specjalizowanych nie trzeba definiować na nowo całej funkcjonalności, lecz tylko tę, której nie ma obiekt bazowy (ogólny). Definicja klasy class Nazwa_klasy: <instrukcja1>... <instrukcjan> definicje klas muszą zostać wykonane, zanim zostaną użyte można umieścić definicję klasy w rozgałęzieniu instrukcji iflub wewnątrz funkcji wykonanie definicji powoduje stworzenie nowej przestrzeni nazw używanej jako zasięg lokalny nazw po zakończeniu wykonywania definicji tworzony jest obiekt klasy Definicja klasy raz jeszcze

class Nazwa_klasy(object): <instrukcja1>... <instrukcjan> tzw. klasa nowego stylu to każda klasa, która dziedziczy z klasy object od klas starego typu różni się między innymi kolejnością dziedziczenia w przypadku wielu klas bazowych w Pythonie 3.x jedyny typ klasy Własności klas klasy w Pythonie nie stawiają nieprzekraczalnych barier pomiędzy swoją definicją a programistą! mechanizm dziedziczenia pozwala klasie na posiadanie wielu klas bazowych w terminologii C++ wszystkie składowe klasy Pythonowej (włącznie z atrybutami) są publiczne, a wszystkie funkcje składowe są wirtualne większość wbudowanych operatorów może zostać przedefiniowana dla różnych typów klasowych klasy same są obiektami słowo obiekt w Pythonie nie oznacza konkretu (instancji) klasy nie wszystkie typy w Pythonie są klasowe, jednak wszystkie przejawiają w swym zachowaniu to, co najlepiej wyrazić słowem "obiekt" W stronę zastosowań praktycznych klasa Particle In [16]: class Particle: #prawie jak konstruktor (więcej za chwilę) def init (self,mass,velocity): self.m = mass self.v = velocity #przykładowa metoda def momentum(self): return self.m*self.v #o tym więcej później def str (self): msg = "(STR m: %2.1f, v: %2.1f)"%(self.m,self.v) return msg def repr (self): msg = "(REPR m: %2.1f, v: %2.1f)"%(self.m,self.v) return msg

In [17]: dir(particle) Out[17]: [' class ', ' delattr ', ' dict ', ' dir ', ' doc ', ' eq ', ' format ', ' ge ', ' getattribute ', ' gt ', ' hash ', ' init ', ' le ', ' lt ', ' module ', ' ne ', ' new ', ' reduce ', ' reduce_ex ', ' repr ', ' setattr ', ' sizeof ', ' str ', ' subclasshook ', ' weakref ', 'momentum'] In [18]: Particle. module Out[18]: ' main ' In [19]: Particle.momentum Out[19]: <function main.particle.momentum>

In [20]: a = Particle(1.2,2.4) a1 = Particle() ------------------------------------------------------------------- -------- TypeError Traceback (most recent ca ll last) <ipython-input-20-1013068df915> in <module>() 1 a = Particle(1.2,2.4) ----> 2 a1 = Particle() TypeError: init () missing 2 required positional arguments: 'mas s' and 'velocity' In [21]: type(a) Out[21]: main.particle Obiekty konkretu klasy: atrybuty danych i metody In [22]: a.m Out[22]: 1.2 In [23]: a.v Out[23]: 2.4 In [24]: a.momentum() Out[24]: 2.88 In [25]: a.v = 4.8

In [26]: a.momentum() Out[26]: 5.76 Reprezentacja obiektu na ekranie In [27]: a Out[27]: (REPR m: 1.2, v: 4.8) In [28]: print(a) (STR m: 1.2, v: 4.8) Więcej o metodach zwykłe funkcje w Pythonie w definicji pierwszy argument jest referencją do aktualnej instancji klasy argument ten może mieć dowolną nazwę, ale niepisanym standardem jest **self** **self** pełni rolę **this** w C++ i Javie przy wywołaniu metody pomijamy ten argument metody mogą używać odniesień do nazw globalnych zasięg globalny związany z metodą jest po prostu tym modułem, który zawiera definicję klasy Nie jest konieczne, aby definicja metody była tekstowo umieszczona w definicji klasy: In [29]: def f1(self,x,y): return min(x,x+y) class C: f = f1 Metody mogą wywoływać inne metody poprzez użycie atrybutów metod obiektu **self**:

In [30]: class Worek: def init (self): self.dane=[] def dodaj(self,x): self.dane.append(x) def dodaj_dwa_razy(self,x): self.dodaj(x) self.dodaj(x) In [31]: w = Worek() w.dodaj(2) w.dodaj_dwa_razy("a") In [32]: w.dane Out[32]: [2, 'a', 'a'] Metody specjalne

Metody specjalne pozwalają na definiowanie pewnych funkcjonalności klas, które wywoływane są automatrycznie przez interpreter (tak realizowane jest np. przeciążanie niektórych operatorów). Oto wybrane z nich: init (self[,...]) wywoływana tuż po utworzeniu konkretu klasy repr (self) "oficjalna" reprezentacja obiektu, wywoływana przy użyciu wbudowanej funkcji repr(instancja) str (self) "nieformalna" reprezentacja obiektu, wywoływana przy użyciu str(instancja)lub print instancja len (self) funkcja wywoływana po użyciu w kodzie polecenia len(instancja) cmp (self,other) funkcja wywoływana w momencie porównywania dwóch konkretów danej klasy del (self) funkcja wywoływana tuż przed zniszczeniem obiektu Więcej pod adresem https://docs.python.org/3/reference/datamodel.html#special method names (https://docs.python.org/3/reference/datamodel.html#special method names). Uwaga! Tworzenie nowych klas najlepiej zaczynać od zdefiniowania dwóch funkcji: init ułatwia tworzenie instancji klasy str przydaje się przy debugowaniu Kilka słów o metodzie init wywoływana po stworzeniu konkretu klasy wygląda jak konstruktor działa jak konstruktor "brzmi" jak konstruktor nie jest konstruktorem w sensie C++, ponieważ wykonywana jest już po stworzeniu obiektu instancji klasy nie zwraca wartości Kilka słów o metodzie del wywoływana tuż przed zniszczeniem instancji klasy destruktor wyjątki (o tym później), które pojawią się w trakcie wykonywania funkcji del, są ignorowane

In [33]: class Point: def init ( self, x=0, y=0): class_name = self. class. name print(class_name, "initialized") self.x = x self.y = y def coords(self): print(self.x,self.y) def del (self): class_name = self. class. name print(class_name, "destroyed") In [34]: a = Point() Point initialized In [35]: a.coords() 0 0 In [36]: del a Point destroyed In [37]: a = Point(1,2) Point initialized In [38]: a.coords() 1 2 In [39]: a = Point(3,2) Point initialized Point destroyed Przeciążanie operatorów

Przeciążanie realizowane jest również przy pomocy metod o nazwach specjalnych: add (self,other) dodawanie sub (self,other) odejmowanie mul (self,other) mnożenie div (self,other) dzielenie pow (self,other[,modulo]) potęgowanie Więcej infomacji na ten temat pod adresem https://docs.python.org/3/reference/datamodel.html#specialmethod names (https://docs.python.org/3/reference/datamodel.html#special method names) In [40]: import math class Vector: """Example vector class""" def init (self,*args): """Create a vector, example: v = Vector(1,2)""" if len(args)==0: self.values = (0,0) else: self.values = args def norm(self): """Returns the norm (length) of the vector""" return math.sqrt(sum(el**2 for el in self.values)) def add (self,other): """Returns the vector sum of self and other""" added = tuple( a+b for a,b in zip(self.values,other.values)) return Vector(*added) def sub (self,other): """Returns the vector difference of self and other""" subbed = tuple( a-b for a,b in zip(self.values,other.values)) return Vector(*subbed) def len (self): return len(self.values) def repr (self): return str(self.values) In [41]: v1 = Vector(1,2) v2 = Vector(3,4) In [42]: print(v2.norm()) print(len(v2)) 5.0 2

In [43]: print(v1+v2) (4, 6) In [44]: print(v1-v2) (-2, -2) In [45]: w = v1 - v2 In [46]: type(w) Out[46]: main.vector In [47]: w.norm() Out[47]: 2.8284271247461903 In [48]: print(w) (-2, -2) Atrybuty klas Jeżeli w definicji klasy zmienne wprowadzane są poza funkcją init, stanowią one atrybuty klasy, a nie jej konkretu: In [49]: class counter: count = 0 def init (self): self. class.count += 1 In [50]: counter Out[50]: main.counter

In [51]: counter.count Out[51]: 0 In [52]: c = counter() In [53]: counter.count Out[53]: 1 In [54]: d = counter() In [55]: counter.count Out[55]: 2 In [56]: counter.count = 0 In [57]: counter.count Out[57]: 0 Składowe prywatne Każdy identyfikator o nazwie zmienna(przynajmniej dwa znaki podkreślenia na początku i co najwyżej jeden na końcu) zastępowany jest automatycznie przez _nazwaklasy zmienna: namiastka zmiennych prywatnych klasy w C++ bezpośredni dostęp do takich zmiennych ciągle możliwy In [58]: class counter2: count = 0 def init (self): self. class. count += 1

In [59]: a = counter2() Point destroyed In [60]: b = counter2() In [61]: #"normalny" dostęp nie działa print(counter2. count) ------------------------------------------------------------------- -------- AttributeError Traceback (most recent ca ll last) <ipython-input-61-4d383fe1004b> in <module>() 1 #"normalny" dostęp nie działa ----> 2 print(counter2. count) AttributeError: type object 'counter2' has no attribute ' count' In [62]: #a jednak dla chcącego nic trudnego print(counter2._counter2 count) 2 Dziedziczenie In [63]: # %load particles.py

In [64]: class Particle: def init (self,mass,velocity): self.m = mass self.v = velocity def momentum(self): return self.m*self.v def repr (self): msg = "(m:%2.1f,v:%2.1f)" % (self.m,self.v) return msg class Boson(Particle): def init (self,mass,velocity,spin): Particle. init (self,mass,velocity) self.s = spin def repr (self): msg = "(m:%2.1f, v:%2.1f, s:%2.1f)"\ % (self.m,self.v,self.s) return msg def spin(self): return self.s #a = Boson(1.2,2.1,3.0) #print a.spin() #print a.momentum() #print a In [65]: from particles import * In [66]: b = Boson(1.2,2.1,3.0)

In [67]: b.spin() Out[67]: 3.0 In [68]: b.momentum() Out[68]: 2.52 In [69]: b Out[69]: (m:1.2, v:2.1, s:3.0) nazwa klasy bazowej musi być zdefiniowana w zasięgu zawierającym definicję klasy pochodnej jeśli poszukiwany atrybut nie jest znajdowany w klasie, poszukiwany jest w klasie bazowej klasy pochodne mogą przesłaniać metody ich klas bazowych przesłonięcie metody w klasie pochodniej jest raczej rozszerzeniem zbioru obsługiwanych funkcji niż zastąpieniem jednego elementu innym Dziedziczenie wielorakie class Pochodna(Bazowa1,Bazowa2,Bazowa3): <instrukcje> najpierw w głąb, potem na prawo jeśli atrybut nie zostanie znaleziony w klasie Pochodna, będzie poszukiwany w klasie Bazowa1i w jej klasach bazowych jeśli atrybutu nie ma w klasie Bazowa1, poszukiwanie zostanie przeniesione do Bazowa2itd. może prowadzić do problemów w pielęgnacji kodu (unikanie konfliktów nazw w Pythonie to tylko umowa) zalecane jest oszczędne używanie Serializacja (marynowanie) instancji klas

In [70]: import pickle a = Particle(2.0,3.0) print(a) print(a.momentum()) of = open("jar","wb") pickle.dump(a,of) of.close() (m:2.0,v:3.0) 6.0 In [71]:!cat jar cparticles Particle q\00) q}q(x\00\00\00vqg@\00\00\00\00\00\00x\00\00\00mqg@\00\00\00\0 0\00\00\00ub. In [72]: f = open("jar","rb") b = pickle.load(f) f.close() print(b) (m:2.0,v:3.0) In [73]: type(b) Out[73]: particles.particle In [74]: print(id(b), id(a)) 139669322405984 139669322896384