Python-objecten en klassen

In deze zelfstudie leer je over de kernfunctionaliteit van Python-objecten en -klassen. Je leert wat een klas is, hoe je deze kunt maken en gebruiken in je programma.

Video:Python-klassen en objecten

Python-objecten en klassen

Python is een objectgeoriënteerde programmeertaal. In tegenstelling tot proceduregeoriënteerd programmeren, waar de nadruk vooral ligt op functies, legt objectgeoriënteerd programmeren de nadruk op objecten.

Een object is gewoon een verzameling gegevens (variabelen) en methoden (functies) die op die gegevens inwerken. Op dezelfde manier is een klasse een blauwdruk voor dat object.

We kunnen een klas zien als een schets (prototype) van een huis. Hierin staan ​​alle details over de vloeren, deuren, ramen etc. Op basis van deze beschrijvingen bouwen wij het huis. Huis is het object.

Omdat veel huizen kunnen worden gemaakt van de blauwdruk van een huis, kunnen we veel objecten van een klasse maken. Een object wordt ook wel een instantie van een klasse genoemd en het proces van het maken van dit object wordt instantiatie genoemd. .

Een klasse definiëren in Python

Zoals functiedefinities beginnen met het def-sleutelwoord in Python, beginnen klassedefinities met een class-sleutelwoord.

De eerste tekenreeks in de klasse wordt docstring genoemd en heeft een korte beschrijving van de klasse. Hoewel dit niet verplicht is, wordt dit ten zeerste aanbevolen.

Hier is een eenvoudige klassendefinitie.

class MyNewClass:
    '''This is a docstring. I have created a new class'''
    pass

Een klasse maakt een nieuwe lokale naamruimte waarin alle kenmerken zijn gedefinieerd. Attributen kunnen gegevens of functies zijn.

Er staan ​​ook speciale attributen in die beginnen met dubbele underscores __ . Bijvoorbeeld __doc__ geeft ons de docstring van die klasse.

Zodra we een klasse definiëren, wordt er een nieuw klasseobject met dezelfde naam gemaakt. Dit klasseobject stelt ons in staat om toegang te krijgen tot de verschillende attributen en om nieuwe objecten van die klasse te instantiëren.

class Person:
    "This is a person class"
    age = 10

    def greet(self):
        print('Hello')


# Output: 10
print(Person.age)

# Output: <function Person.greet>
print(Person.greet)

# Output: "This is a person class"
print(Person.__doc__)

Uitvoer

10
<function Person.greet at 0x7fc78c6e8160>
This is a person class

Een object maken in Python

We hebben gezien dat het klasseobject kan worden gebruikt om toegang te krijgen tot verschillende attributen.

Het kan ook worden gebruikt om nieuwe objectinstanties (instantiatie) van die klasse te maken. De procedure om een ​​object aan te maken is vergelijkbaar met een functieaanroep.

>>> harry = Person()

Hiermee wordt een nieuwe objectinstantie gemaakt met de naam harry . We hebben toegang tot de attributen van objecten met behulp van het voorvoegsel van de objectnaam.

Attributen kunnen data of methode zijn. Methoden van een object zijn corresponderende functies van die klasse.

Dit wil zeggen, aangezien Person.greet is een functie-object (attribuut van klasse), Person.greet zal een methode-object zijn.

class Person:
    "This is a person class"
    age = 10

    def greet(self):
        print('Hello')


# create a new object of Person class
harry = Person()

# Output: <function Person.greet>
print(Person.greet)

# Output: <bound method Person.greet of <__main__.Person object>>
print(harry.greet)

# Calling object's greet() method
# Output: Hello
harry.greet()

Uitvoer

<function Person.greet at 0x7fd288e4e160>
<bound method Person.greet of <__main__.Person object at 0x7fd288e9fa30>>
Hello

Je hebt misschien de self . opgemerkt parameter in functiedefinitie binnen de klasse, maar we noemden de methode eenvoudig als harry.greet() zonder enige argumenten. Het werkte nog steeds.

Dit komt omdat, wanneer een object zijn methode aanroept, het object zelf wordt doorgegeven als het eerste argument. Dus, harry.greet() vertaalt in Person.greet(harry) .

Over het algemeen is het aanroepen van een methode met een lijst van n argumenten gelijk aan het aanroepen van de corresponderende functie met een argumentenlijst die is gemaakt door het object van de methode voor het eerste argument in te voegen.

Om deze redenen moet het eerste argument van de functie in de klasse het object zelf zijn. Dit wordt gewoonlijk zelf genoemd . Het kan anders worden genoemd, maar we raden u ten zeerste aan om de conventie te volgen.

Nu moet u bekend zijn met klassenobject, instantieobject, functieobject, methodeobject en hun verschillen.

Constructeurs in Python

Klassefuncties die beginnen met een dubbel onderstrepingsteken __ worden speciale functies genoemd omdat ze een speciale betekenis hebben.

Van een bijzonder belang is de __init__() functie. Deze speciale functie wordt aangeroepen wanneer een nieuw object van die klasse wordt geïnstantieerd.

Dit type functie wordt ook wel constructors genoemd in Object Oriented Programming (OOP). We gebruiken het normaal gesproken om alle variabelen te initialiseren.

class ComplexNumber:
    def __init__(self, r=0, i=0):
        self.real = r
        self.imag = i

    def get_data(self):
        print(f'{self.real}+{self.imag}j')


# Create a new ComplexNumber object
num1 = ComplexNumber(2, 3)

# Call get_data() method
# Output: 2+3j
num1.get_data()

# Create another ComplexNumber object
# and create a new attribute 'attr'
num2 = ComplexNumber(5)
num2.attr = 10

# Output: (5, 0, 10)
print((num2.real, num2.imag, num2.attr))

# but c1 object doesn't have attribute 'attr'
# AttributeError: 'ComplexNumber' object has no attribute 'attr'
print(num1.attr)

Uitvoer

2+3j
(5, 0, 10)
Traceback (most recent call last):
  File "<string>", line 27, in <module>
    print(num1.attr)
AttributeError: 'ComplexNumber' object has no attribute 'attr'

In het bovenstaande voorbeeld hebben we een nieuwe klasse gedefinieerd om complexe getallen weer te geven. Het heeft twee functies, __init__() om de variabelen te initialiseren (standaard nul) en get_data() om het nummer correct weer te geven.

Een interessant ding om op te merken in de bovenstaande stap is dat attributen van een object on-the-fly kunnen worden gemaakt. We hebben een nieuw kenmerk gemaakt attr voor object num2 en lees het ook. Maar dit creëert niet dat attribuut voor object num1 .

Kenmerken en objecten verwijderen

Elk attribuut van een object kan op elk moment worden verwijderd, met behulp van de del uitspraak. Probeer het volgende op de Python-shell om de uitvoer te zien.

>>> num1 = ComplexNumber(2,3)
>>> del num1.imag
>>> num1.get_data()
Traceback (most recent call last):
...
AttributeError: 'ComplexNumber' object has no attribute 'imag'

>>> del ComplexNumber.get_data
>>> num1.get_data()
Traceback (most recent call last):
...
AttributeError: 'ComplexNumber' object has no attribute 'get_data'

We kunnen zelfs het object zelf verwijderen met het del-statement.

>>> c1 = ComplexNumber(1,3)
>>> del c1
>>> c1
Traceback (most recent call last):
...
NameError: name 'c1' is not defined

Eigenlijk is het ingewikkelder dan dat. Wanneer we c1 = ComplexNumber(1,3) doen , er wordt een nieuw instantieobject in het geheugen gemaakt en de naam c1 bindt ermee.

Op het commando del c1 , deze binding wordt verwijderd en de naam c1 wordt verwijderd uit de corresponderende naamruimte. Het object blijft echter in het geheugen bestaan ​​en als er geen andere naam aan is gekoppeld, wordt het later automatisch vernietigd.

Deze automatische vernietiging van objecten zonder referentie in Python wordt ook wel garbage collection genoemd.