Python - Objectgericht

Vorige paginaVolgende pagina

Python is sinds het bestaan een objectgeoriënteerde taal. Hierdoor is het maken en gebruiken van klassen en objecten ronduit eenvoudig. Dit hoofdstuk helpt je een expert te worden in het gebruik van de objectgeoriënteerde programmeerondersteuning van Python.

Als je geen eerdere ervaring hebt met objectgeoriënteerd (OO) programmeren, wil je misschien een inleidende cursus hierover raadplegen of op zijn minst een soort tutorial, zodat je de basisconcepten onder de knie hebt.

Hier is echter een kleine introductie van Object-Oriented Programming (OOP) om u op snelheid te brengen −

Overzicht van OOP-terminologie

Klasse − Een door de gebruiker gedefinieerd prototype voor een object dat een set attributen definieert die elk object van de klasse karakteriseren. De attributen zijn gegevensleden (klassevariabelen en instantievariabelen) en methoden, toegankelijk via puntnotatie.
Klasse variabele − Een variabele die door alle instanties van een klasse wordt gedeeld. Klassevariabelen worden gedefinieerd binnen een klasse, maar buiten een van de methoden van de klasse. Klassevariabelen worden niet zo vaak gebruikt als instantievariabelen.
Gegevenslid − Een klassevariabele of instantievariabele die gegevens bevat die zijn gekoppeld aan een klasse en zijn objecten.
Functie overbelast − Het toewijzen van meer dan één gedrag aan een bepaalde functie. De uitgevoerde bewerking verschilt per type object of argument.
Instantievariabele − Een variabele die binnen een methode is gedefinieerd en alleen bij de huidige instantie van een klasse hoort.
Overerving − De overdracht van de kenmerken van een klasse naar andere klassen die ervan zijn afgeleid.
Instantie − Een individueel object van een bepaalde klasse. Een object obj dat bijvoorbeeld tot een klasse Circle behoort, is een instantie van de klasse Circle.
Instantiëring − Het maken van een instantie van een klasse.
Methode − Een speciaal soort functie die is gedefinieerd in een klassendefinitie.
Object − Een uniek exemplaar van een gegevensstructuur die wordt gedefinieerd door zijn klasse. Een object omvat zowel gegevensleden (klassevariabelen en instantievariabelen) als methoden.
Overbelasting operator − De toewijzing van meer dan één functie aan een bepaalde operator.

Klassen maken

De klas statement creëert een nieuwe klassedefinitie. De naam van de klas volgt onmiddellijk het trefwoord klasse gevolgd door een dubbele punt als volgt −

class ClassName:
   'Optional class documentation string'
   class_suite

De klasse heeft een documentatiereeks, die toegankelijk is via ClassName.__doc__ .
De class_suite bestaat uit alle componentinstructies die klasseleden, gegevensattributen en functies definiëren.

Voorbeeld

Hieronder volgt het voorbeeld van een eenvoudige Python-klasse −

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

De variabele empCount is een klassevariabele waarvan de waarde wordt gedeeld door alle instanties van deze klasse. Dit is toegankelijk als Employee.empCount van binnen de klas of buiten de klas.
De eerste methode __init__() is een speciale methode, die klassenconstructor of initialisatiemethode wordt genoemd die Python aanroept wanneer je een nieuwe instantie van deze klasse maakt.
Je declareert andere klassenmethoden zoals normale functies, met de uitzondering dat het eerste argument voor elke methode zelf is . Python voegt het zelf toe argument aan de lijst voor u; u hoeft het niet op te nemen wanneer u de methoden aanroept.

Exemplaarobjecten maken

Om instanties van een klasse te maken, roept u de klasse aan met de klassenaam en geeft u de argumenten door die zijn __init__ methode accepteert.

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)

Toegang tot attributen

U krijgt toegang tot de kenmerken van het object met behulp van de puntoperator met object. De klassevariabele zou als volgt toegankelijk zijn met de klassenaam −

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Nu alle concepten bij elkaar

Live demo

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

U kunt op elk moment attributen van klassen en objecten toevoegen, verwijderen of wijzigen −

emp1.age = 7  # Add an 'age' attribute.
emp1.age = 8  # Modify 'age' attribute.
del emp1.age  # Delete 'age' attribute.

In plaats van de normale instructies te gebruiken om toegang te krijgen tot attributen, kunt u de volgende functies gebruiken −

De getattr(obj, naam[, standaard]) − om toegang te krijgen tot het attribuut van object.
De hasattr(obj,naam) − om te controleren of een attribuut bestaat of niet.
De setattr(obj,naam,waarde) − om een attribuut in te stellen. Als attribuut niet bestaat, wordt het aangemaakt.
De delattr(obj, naam) − om een kenmerk te verwijderen.

hasattr(emp1, 'age')    # Returns true if 'age' attribute exists
getattr(emp1, 'age')    # Returns value of 'age' attribute
setattr(emp1, 'age', 8) # Set attribute 'age' at 8
delattr(empl, 'age')    # Delete attribute 'age'

Ingebouwde klassekenmerken

Elke Python-klasse blijft ingebouwde attributen volgen en ze zijn toegankelijk met de dot-operator zoals elk ander attribuut −

__dict__ − Woordenboek met de naamruimte van de klasse.
__doc__ − Tekenreeks voor klassedocumentatie of geen, indien niet gedefinieerd.
__name__ − Klasnaam.
__module__ − Modulenaam waarin de klasse is gedefinieerd. Dit kenmerk is "__main__" in interactieve modus.
__bases__ − Een mogelijk lege tuple die de basisklassen bevat, in de volgorde waarin ze voorkomen in de lijst met basisklassen.

Laten we voor de bovenstaande klasse proberen toegang te krijgen tot al deze attributen −

Live demo

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2, 
'displayEmployee': <function displayEmployee at 0xb7c8441c>, 
'__doc__': 'Common base class for all employees', 
'__init__': <function __init__ at 0xb7c846bc>}

Objecten vernietigen (vuilnisophaling)

Python verwijdert automatisch onnodige objecten (ingebouwde typen of klasseninstanties) om geheugenruimte vrij te maken. Het proces waarbij Python periodiek geheugenblokken terugwint die niet meer in gebruik zijn, wordt Garbage Collection genoemd.

De garbagecollector van Python wordt uitgevoerd tijdens de uitvoering van het programma en wordt geactiveerd wanneer de referentietelling van een object nul bereikt. Het aantal referenties van een object verandert naarmate het aantal aliassen dat ernaar verwijst, verandert.

Het aantal referenties van een object neemt toe wanneer het een nieuwe naam krijgt of in een container (lijst, tuple of woordenboek) wordt geplaatst. Het aantal referenties van het object neemt af wanneer het wordt verwijderd met del , wordt de verwijzing opnieuw toegewezen of valt de verwijzing buiten het bereik. Wanneer de referentietelling van een object nul bereikt, verzamelt Python het automatisch.

a = 40      # Create object <40>
b = a       # Increase ref. count  of <40> 
c = [b]     # Increase ref. count  of <40> 

del a       # Decrease ref. count  of <40>
b = 100     # Decrease ref. count  of <40> 
c[0] = -1   # Decrease ref. count  of <40>

U zult normaal gesproken niet merken wanneer de vuilnisman een verweesde instantie vernietigt en zijn ruimte terugwint. Maar een klasse kan de speciale methode __del__() . implementeren , een destructor genoemd, die wordt aangeroepen wanneer de instantie op het punt staat te worden vernietigd. Deze methode kan worden gebruikt om alle niet-geheugenbronnen die door een instantie worden gebruikt op te schonen.

Voorbeeld

Deze __del__() destructor drukt de klassenaam af van een instantie die op het punt staat te worden vernietigd −

Live demo

#!/usr/bin/python

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "destroyed"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # prints the ids of the obejcts
del pt1
del pt2
del pt3

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

3083401324 3083401324 3083401324
Point destroyed

Opmerking − Idealiter zou je je klassen in een apart bestand moeten definiëren, dan zou je ze moeten importeren in je hoofdprogrammabestand met behulp van import verklaring.

Klasse-overerving

In plaats van helemaal opnieuw te beginnen, kunt u een klas maken door deze af te leiden van een reeds bestaande klas door de bovenliggende klas tussen haakjes achter de nieuwe klasnaam te vermelden.

De onderliggende klasse erft de kenmerken van de bovenliggende klasse en u kunt die kenmerken gebruiken alsof ze in de onderliggende klasse zijn gedefinieerd. Een onderliggende klasse kan ook gegevensleden en methoden van de bovenliggende klasse overschrijven.

Syntaxis

Afgeleide klassen worden net zo gedeclareerd als hun bovenliggende klasse; er wordt echter een lijst met basisklassen van overerven gegeven achter de klassenaam −

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

Voorbeeld

Live demo

#!/usr/bin/python

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print "Calling parent constructor"

   def parentMethod(self):
      print 'Calling parent method'

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "Parent attribute :", Parent.parentAttr

class Child(Parent): # define child class
   def __init__(self):
      print "Calling child constructor"

   def childMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

Op dezelfde manier kun je als volgt een klas uit meerdere ouderklassen rijden −

class A:        # define your class A
.....

class B:         # define your class B
.....

class C(A, B):   # subclass of A and B
.....

U kunt de functies issubclass() of isinstance() gebruiken om de relaties van twee klassen en instanties te controleren.

De issubclass(sub, sup) booleaanse functie retourneert true als de gegeven subklasse sub is inderdaad een subklasse van de superklasse sup .
De isinstance(obj, Class) booleaanse functie retourneert true als obj is een instantie van klasse Klasse of is een instantie van een subklasse van Klasse

Overschrijfmethoden

U kunt de methoden van uw bovenliggende klasse altijd overschrijven. Een reden om de methoden van ouders te negeren is omdat je misschien speciale of andere functionaliteit in je subklasse wilt.

Voorbeeld

Live demo

#!/usr/bin/python

class Parent:        # define parent class
   def myMethod(self):
      print 'Calling parent method'

class Child(Parent): # define child class
   def myMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

Calling child method

Base overbelastingsmethoden

De volgende tabel bevat een aantal algemene functionaliteiten die u in uw eigen klassen kunt overschrijven −

Sr.nr.	Methode, beschrijving en voorbeeldgesprek
1	__init__ ( zelf [,args...] ) Constructor (met eventuele optionele argumenten) Voorbeeldoproep:obj =className(args)
2	__del__( zelf ) Destructor, verwijdert een object Voorbeeldoproep:del obj
3	__repr__( zelf ) Evalueerbare tekenreeksweergave Voorbeeldoproep:repr(obj)
4	__str__( zelf ) Afdrukbare tekenreeksweergave Voorbeeldoproep:str(obj)
5	__cmp__ ( zelf, x ) Objectvergelijking Voorbeeldoproep:cmp(obj, x)

Medewerkers overbelasten

Stel dat u een Vector-klasse hebt gemaakt om tweedimensionale vectoren weer te geven, wat gebeurt er als u de plus-operator gebruikt om ze toe te voegen? Hoogstwaarschijnlijk zal Python tegen je schreeuwen.

U kunt echter de __add__ . definiëren methode in uw klasse om vectoroptelling uit te voeren en dan zou de plus-operator zich gedragen zoals verwacht −

Voorbeeld

Live demo

#!/usr/bin/python

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

Vector(7,8)

Gegevens verbergen

De attributen van een object kunnen al dan niet zichtbaar zijn buiten de klassendefinitie. Je moet attributen een naam geven met een dubbel onderstrepingsteken, en die attributen zijn dan niet direct zichtbaar voor buitenstaanders.

Voorbeeld

Live demo

#!/usr/bin/python

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python beschermt die leden door de naam intern te wijzigen om de klassenaam op te nemen. U hebt toegang tot attributen als object._className__attrName . Als je je laatste regel als volgt zou vervangen, dan werkt het voor jou −

.........................
print counter._JustCounter__secretCount

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

1
2
2

Python - Afhandeling van uitzonderingen Python - Reguliere expressies

Python