In deze lezing leren we over klassen, constructeurs en overerving in python.
Deze concepten zijn erg belangrijk in een groot programma waar verschillende typen moeten worden gedefinieerd.
Klassen
Klassen zijn essentieel bij het programmeren en ze zijn niet specifiek voor Python. Vele andere programmeertalen ondersteunen het begrip klassen. We gebruiken klassen om nieuwe gegevenstypen te definiëren.
Tot nu toe hebben we geleerd over de basisgegevenstypen in Python, zoals getallen, strings en booleans. Dit zijn de basis- of eenvoudige gegevenstypen in Python. We hebben ook een aantal complexe gegevenstypen gezien, zoals lijsten en woordenboeken.
Hoewel deze typen uiterst nuttig zijn, kunnen ze niet altijd worden gebruikt om complexe concepten te modelleren. Denk bijvoorbeeld aan het idee van een punt, of een winkelwagentje. Een winkelwagen is geen boolean of lijst. Het is een ander soort gegevens. We kunnen dus klassen gebruiken om nieuwe typen te definiëren om echte concepten te modelleren.
Laten we nu een nieuw gegevenstype definiëren dat punt wordt genoemd. Dit nieuwe type zal methoden hebben zoals we eerder hebben gecontroleerd.
Dit is hoe je het gaat doen:
We beginnen met het definiëren van een klasse door het trefwoord "class" te gebruiken en direct daarna geven we onze klasse een naam.
class Point
Kijk nu eens naar de naamgevingsconventie die ik hier heb gebruikt. Ik heb de eerste letter hier met een hoofdletter geschreven, dit is wat we een pascal-naamgevingsconventie noemen. Deze conventie verschilt van de conventie die we gebruiken voor het benoemen van onze variabelen en functies waarvoor we altijd kleine letters gebruiken en meerdere woorden scheiden met een onderstrepingsteken. Maar bij het benoemen van klassen gebruiken we geen onderstrepingsteken om meerdere woorden van elkaar te scheiden, maar gebruiken we de eerste letter van elk woord met een hoofdletter.
Na het definiëren van onze klasse wordt een dubbele punt gebruikt, wat betekent dat er nu een blok is gedefinieerd.
class Point:
def move (self):
In dit blok kunnen we alle functies of methoden definiëren die bij punten horen. We kunnen bijvoorbeeld een functie met de naam "verplaatsen" definiëren voor het verplaatsen van een punt. Merk op dat zodra we haakjes openen typen, PyCharm hier automatisch "zelf" toevoegt. Dit is een speciaal trefwoord en ik kom hier zo op terug. Laten we "verplaatsen" op de terminal afdrukken.
print("move")
Laten we een andere methode definiëren, zoals "tekenen" en deze op de terminal afdrukken.
def draw(self):
print("draw")
We zijn klaar met de definitie van onze "punt" -klasse. Met dit nieuwe type kunnen we nieuwe objecten maken. Een klasse definieert eenvoudig de blauwdruk of de sjabloon voor het maken van objecten die de daadwerkelijke instanties zijn op basis van die blauwdruk. Om een object te maken, typen we de naam van onze klasse in en roepen het dan net als een functie aan. Hiermee wordt een nieuw object gemaakt en geretourneerd. Dan kunnen we dat object in een variabele opslaan. Laat me je laten zien:
Hier hebben we een "punt1" gedefinieerd dat een driedimensionaal punt is. Dat zie je, we kunnen individuele coördinaten op de terminal printen.
We kunnen bij dit punt de twee methoden "tekenen" en "verplaatsen" gebruiken.
Dus om samen te vatten, we gebruiken klassen om nieuwe typen te definiëren en deze typen kunnen methoden hebben die we in de hoofdtekst van de klasse definiëren. Klassen kunnen attributen hebben die we overal in onze programma's kunnen instellen.
constructors
Tot nu toe hebben we geleerd hoe we nieuwe typen kunnen maken met klassen. Nu is er een klein probleem met deze implementatie. We kunnen een puntobject maken zonder een x- of y-coördinaat met behulp van klassen en dat is niet ideaal. Laat me het je laten zien.
Laten we een punt maken en het afdrukken voordat we de x-coördinaat instellen. Het uitvoeren van ons programma resulteert in een attribuutfout zoals deze:
Het betekent dat het puntobject geen attribuut heeft dat x wordt genoemd. Het probleem is nu dat het mogelijk is om een puntobject te hebben zonder x- of y-coördinaten. Dit is niet logisch, want als we het over een punt hebben, moeten we weten waar dat punt zich bevindt. Om dit probleem op te lossen, gebruiken we een constructor. Een constructor is een functie die wordt aangeroepen op het moment dat een object wordt gemaakt.
Hier is hoe we een constructor gebruiken. Laten we eerst de x- en y-coördinaten in het bovenstaande programma doorgeven.
point = Point(10, 20)
print(point.x)
Nu moeten we een speciale methode in deze klasse toevoegen, een constructor genaamd. De syntaxis is als volgt:
def __init__(self, x, y):
init
is een afkorting voor geïnitialiseerd, en dit is de functie of de methode die wordt aangeroepen wanneer een nieuw puntobject wordt gemaakt. De x en y worden direct na toegevoegd self
om twee extra parameters toe te voegen.
Daarna moeten we de x en y toewijzen aan de doorgegeven waarden, dat wil zeggen 10 en 20
self.x = x
self.y = y
We maken gebruik van de self
om naar het huidige object te verwijzen en vervolgens stellen we het x-attribuut in op het x-argument dat is doorgegeven aan de functie "x". Op deze manier, met behulp van init
methode, kunnen we onze objecten initialiseren. Deze methode wordt een constructor genoemd. Laten we ons programma uitvoeren.
Nu kunnen we de x- en y-coördinaten later wijzigen. Laten we de x-coördinaat bijwerken:
point = Point(10, 20)
point.x = 11
print(point.x)
Nu wordt de x-coördinaat bijgewerkt naar waarde 11.
Oefening
Hier is een interessante oefening voor je.
Ik wil dat je een nieuw type definieert, een persoon genaamd. Deze "Persoon"-objecten moeten een "name
” attribuut en een “talk()
”Methode.
Het is een eenvoudige taak en duurt niet langer dan een paar minuten.
Oplossing
Begin met het definiëren van de klasse "Persoon" als volgt:
class Person:
self.name = name
We zullen de constructor later definiëren. Nu kunnen we het object "Persoon" maken. Laten we het John noemen
john = Person("John Smith")
print(john.name)
john.talk()
Ga nu verder met het eerste deel van de code en maak een constructor.
def __init__(self, name):
De uiteindelijke code ziet er als volgt uit:
U kunt ook opgemaakte tekenreeksen en andere concepten gebruiken in combinatie met klassen en constructors.
Erfenis
Overerving is een ander concept dat is gekoppeld aan klassen waarmee u een code opnieuw kunt gebruiken.
Overweeg dit stukje code.
class Dog:
def walk(self):
print("walk")
We hebben een klas "Hond" gemaakt met een "loop"-methode. Bij deze methode printen we gewoon het loopbericht op de terminal. Laten we zeggen, in een echt programma, Er zijn hier 10 regels code in plaats van slechts één regel. Als in de toekomst een andere klasse nodig is om de "walk" -methode te hebben, zullen we al die code moeten herhalen. Dit is niet ideaal.
Bij het programmeren hebben we een principe genaamd DRY, wat een afkorting is voor don't repeat yourself. Laten we zeggen dat we ergens in de toekomst een probleem ontdekken met onze "loop"-methode en als we deze methode op veel andere plaatsen hebben herhaald of gedupliceerd, moeten we terugkomen en dat probleem oplossen op elke plek waar we dit hebben gedupliceerd code. Daarom moeten we bij het programmeren iets niet twee keer definiëren.
Er zijn verschillende benaderingen om dit probleem te verhelpen, maar hier gaan we degene leren die gemakkelijker is voor beginners en die overerving wordt genoemd. In dit geval zullen we een andere klasse "zoogdier" maken en ons kenmerk "lopen" in die klasse definiëren.
class Mammal:
def walk(self):
print("walk")
Na het definiëren van onze "zoogdier" -klasse kunnen we overerving gebruiken om de attributen als volgt door te geven:
Zowel de honden- als de kattenklassen erven alle klassenmethoden die zijn gedefinieerd in hun bovenliggende klasse. Nu kunnen we methoden toevoegen die specifiek zijn voor honden, zoals deze:
class Dog:
def bark(self):
print("bark")
Inpakken!
Dit ging allemaal over de klassen, constructors en het hergebruik van de code in klassen met overervingsconcepten. Nu naderen we het einde van onze reeks. Op dit punt zou je in staat moeten zijn om goede, leesbare en beknopte codes te produceren in Python.
Het concept van modules en pakketten zullen we in de volgende lezing zien.
Laat een reactie achter