Share
Python wordt geleverd met veel ingebouwde gegevenstypen, zoals dictaat, lijst, set, enz. Heb je je ooit afgevraagd of je je eigen gegevenstypen kunt maken? Net zoals persoon, auto, Universiteit, enz.? Zou het maken van dergelijke gegevenstypen mogelijk zijn? Ja, dat is zeker mogelijk in Python, en hier komen klassen en voorwerpen om de hoek kijken.
In deze tutorial ga ik beschrijven wat wordt bedoeld met een klasse en een voorwerp, en hoe we met hen kunnen werken in Python.
Zoals hierboven vermeld, gaan klassen en objecten over het maken van uw eigen gegevenstype (dat wil zeggen door de gebruiker gedefinieerde gegevenstypen). EEN klasse is dus een door de gebruiker gedefinieerd gegevenstype en het maken van instanties van een klasse (instantiatie) betekent maken voorwerpen van dat type. Aan het einde van de dag worden klassen en objecten beschouwd als de belangrijkste bouwstenen voor Python, een objectgeoriënteerde programmeertaal.
Hoe zou het zijn om een klas te maken in Python? De eenvoudigste klassenstructuur in Python ziet er als volgt uit:
class ClassName: statements
Zoals u kunt zien, begint het definiëren van een klasse met de klasse zoekwoord en naam van de klasse is de naam van de klasse (ID). Houd er rekening mee dat de klassenaam dezelfde regels volgt als de namen van variabelen in Python, dat wil zeggen dat de naam alleen kan beginnen met een letter of een onderstrepingsteken _, en kan alleen letters, cijfers bevatten. of onderstrepingstekens. Ook, verwijzend naar PEP 8 (Stijlgids voor Python Code), kunnen we zien dat het wordt aanbevolen om klassen in CapWords (upper CamelCase) stijl te benoemen.
Laten we nu een klasse definiëren Persoon, die op dit moment niets zal bevatten, behalve de voorbij lopen uitspraak. Zoals vermeld in de documentatie van Python:
Accentsconagua
De voorbij lopen verklaring doet niets. Het kan worden gebruikt wanneer een verklaring syntactisch vereist is, maar het programma vereist geen actieklas Persoon: geslaagd
Om een instantie (object) van deze klasse te maken, kunnen we eenvoudigweg het volgende doen:
abder = Persoon ()
Dit betekent dat we een nieuw object hebben gemaakt abder van type Persoon. Merk op dat het maken van een object gewoon de klassenaam heeft gevolgd door haakjes.
We kunnen identificeren welk type abder is, en waar het in het geheugen thuishoort door te typen: print abder. In dit geval krijg je zoiets als het volgende:
<__main__.Person instance at 0x109a1cb48>
Attributen zijn als eigenschappen die we aan de klasse (type) willen toevoegen. Laten we voor onze klas-persoon bijvoorbeeld twee kenmerken toevoegen: naam en school-, als volgt:
class Person: name = "school ="
Nu kunnen we een nieuw object van het type Persoon (instantie van de persoon) met meer details maken, omdat het nu enkele kenmerken heeft, als volgt:
abder = Person () abder.name = 'Abder' abder.school = 'ABC University'
Methoden zijn soortgelijke functies in Python, omdat ze worden gedefinieerd met het trefwoord def en hebben dezelfde opmaak als functies. Laten we in onze klas een methode definiëren waarmee de naam en school van de persoon worden afgedrukt. De klas ziet er als volgt uit:
class Person: name = "school =" def print_name (self): print self.name def print_school (self): print self.school abder = Person () abder.name = 'Abder' abder.school = 'XY University' abder .print_name () abder.print_school ()
Ik noemde hierboven dat methoden soortgelijke functies zijn. Maar het belangrijkste verschil is dat methoden een gemakkelijk benoemde redenering moeten hebben zelf, die verwijst naar het object waarop de methode wordt aangeroepen (dat wil zeggen abder). Merk op dat we bij het aanroepen van de methode niet voorbij hoeven te gaan zelf als argument, omdat Python dat voor ons zal regelen.
Als we niet zetten zelf als een argument in print naam(), hier is hoe Python zal klagen:
Traceback (meest recente oproep laatste): bestand 'test.py', regel 14, inabder.print_name () TypeError: print_name () neemt geen argumenten aan (1 gegeven)
Je kunt natuurlijk meer dan één argument aan de methode doorgeven. Laten we het proces van het afdrukken van de naam en school- in een methode, als volgt:
class Person: name = "school =" def print_information (self, name, school): print self.name print self.school abder = Person () abder.name = 'Abder' abder.school = 'XY University' abder.print_information (abder.name, abder.school)
Probeer het programma uit te voeren. Hebt u dezelfde uitvoer gehad als voorheen??
In het vorige gedeelte hebben we geïnitialiseerd naam en school- door ze een lege waarde te geven ". Maar er is een elegantere manier om variabelen te initialiseren naar standaardwaarden, en hier is waar initialisatie komt van pas.
De initializer is een speciale methode met de naam __in het__ (de methode wordt als speciaal beschouwd en zal in een speciaal geval behandeld worden, en daarom zijn er aan het begin en aan het einde dubbele onderstrepingstekens).
Laten we het vorige programma aanpassen om de initialisatie te gebruiken. In dit geval ziet het programma er als volgt uit:
class Person: def __init __ (self, n, s): self.name = n self.school = s def print_name (self): print self.name def print_school (self): print self.school abder = Persoon ('Abder' , 'XY University') abder.print_name () abder.print_school ()Merk op dat de initializer hier twee argumenten moet hebben. Als we bijvoorbeeld het n argument in de initializer, krijgen we de volgende foutmelding:
Traceback (meest recente oproep laatste): bestand 'test.py', regel 12, inabder = Persoon ('Abder', 'XY University') TypeError: __init __ () neemt precies 2 argumenten (3 opgegeven)
Dus de bottom line is dat met klassen je zult in staat zijn om je eigen datatypes te maken, en met voorwerpen u zult instanties van die gegevenstypes kunnen creëren. Klassen zijn ook samengesteld uit attributen (eigenschappen) en methoden dat zijn acties die we uitvoeren op die attributen.
Wat was dat gegevenstype dat je altijd al wilde creëren? Ga je gang en doe het!
