Python-klassen en -objecten - Objectgeoriënteerd programmeren



Deze blog over 'Python Class' behandelt de grondbeginselen van klasse, attributen en verschillende OOPS-concepten zoals overerving, polymorfisme en inkapseling.

Nadat Stack Overflow voorspelde dat Python in 2019 andere talen zal overtreffen in termen van actieve ontwikkelaars, de vraag naar groeit alleen maar.Python volgt het objectgeoriënteerde programmeerparadigma. Het behandelt het declareren van python-klassen, het maken van objecten van hen en het communiceren met de gebruikers. In een objectgeoriënteerde taal is het programma opgesplitst in op zichzelf staande objecten of je kunt het zeggen in verschillende miniprogramma's. Elk object vertegenwoordigt een ander deel van de applicatie dat onderling kan communiceren.
In deze Python Class-blog begrijpt u elk aspect van klassen en objecten in de volgende volgorde:

Laten we beginnen.:-)





Wat is een Python-klasse?

Een klasse in python is de blauwdruk van waaruit specifieke objecten worden gemaakt. Hiermee kunt u uw software op een bepaalde manier structureren. Hier komt een vraag hoe? Klassen stellen ons in staat om onze gegevens logisch te groeperen en te functioneren op een manier die gemakkelijk hergebruikt kan worden en een manier om op voort te bouwen indien nodig. Beschouw de onderstaande afbeelding.

ClassesAndObjects - Python-klasse - EdurekaIn de eerste afbeelding (A) vertegenwoordigt het een blauwdruk van een huis dat kan worden beschouwd als Klasse . Met dezelfde blauwdruk kunnen we meerdere huizen maken en deze kunnen worden beschouwd als Voorwerpen . Met behulp van een klasse kunt u consistentie aan uw programma's toevoegen, zodat ze op een schonere en efficiëntere manier kunnen worden gebruikt. De attributen zijn data-leden (klassevariabelen en instantievariabelen) en methoden die toegankelijk zijn via puntnotatie.



  • Klasse variabele is een variabele die wordt gedeeld door alle verschillende objecten / instanties van een klasse.
  • Instantievariabelen zijn variabelen die uniek zijn voor elke instantie. Het wordt gedefinieerd binnen een methode en behoort alleen tot de huidige instantie van een klasse.
  • Methoden worden ook wel functies genoemd die in een klasse zijn gedefinieerd en het gedrag van een object beschrijven.

Laten we nu verder gaan en kijken hoe het werkt in PyCharm. Bekijk om te beginnen eerst de syntaxis van een python-klasse.

Syntaxis :

class Class_name: statement-1. . statement-N

Hier de ' klasse' statement creëert een nieuwe klassendefinitie. De naam van de klas volgt onmiddellijk het trefwoord ' klasse' in python die wordt gevolgd door een dubbele punt. Bekijk het onderstaande voorbeeld om een ​​klasse in python te maken:



klasse medewerker: pass #no attributen en methoden emp_1 = medewerker () emp_2 = medewerker () #instance variabele kan handmatig worden aangemaakt emp_1.first = 'aayushi' emp_1.last = 'Johari' emp_1.email='aayushi@edureka.co 'emp_1.pay = 10000 emp_2.first =' test 'emp_2.last =' abc 'emp_2.email='test@company.com' emp_2.pay = 10000 print (emp_1.email) print (emp_2.email)

Uitvoer -

aayushi@edureka.co test@company.com

Wat als we deze variabelen niet handmatig willen instellen? Je zult veel code zien en het is ook foutgevoelig. Dus om het automatisch te maken, kunnen we de 'init' -methode gebruiken. Laten we daarvoor eens kijken wat precies methoden en attributen zijn in een python-klasse.

Methoden en attributen in een Python-klasse

Nu is het maken van een klas niet compleet zonder enige functionaliteit. Functionaliteiten kunnen dus worden gedefinieerd door verschillende attributen in te stellen die fungeren als een container voor gegevens en functies die betrekking hebben op die attributen. Functies in python worden ook wel Methoden . Over de in het methode , het is een speciale functie die wordt aangeroepen wanneer een nieuw object van die klasse wordt geïnstantieerd. Je kunt het zien als een initialisatiemethode of je kunt dit als constructors beschouwen als je van een andere objectgeoriënteerde programmeerachtergrond komt, zoals C ++, Java, enz. Als we nu een methode binnen een klasse instellen, ontvangen ze automatisch een instantie. Laten we doorgaan met de python-klasse en de voornaam, achternaam en salaris accepteren met deze methode.

class employee: def __init __ (self, first, last, sal): self.fname = first self.lname = last self.sal = sal self.email = first + '.' + laatste + '@ company.com' emp_1 = medewerker ('aayushi', 'johari', 350000) emp_2 = medewerker ('test', 'test', 100000) print (emp_1.email) print (emp_2.email)

Nu hebben we binnen onze 'init' -methode deze instantievariabelen ingesteld (self, first, last, sal). Self is de instantie, wat betekent dat wanneer we self.fname = first schrijven, het hetzelfde is als emp_1.first = ’aayushi’. Vervolgens hebben we instanties van de werknemersklasse gemaakt waar we de waarden kunnen doorgeven die zijn gespecificeerd in de init-methode. Deze methode neemt de instanties als argumenten. In plaats van het handmatig te doen, wordt het gedaan automatisch nu.

Vervolgens willen we de mogelijkheid hebben om een ​​of andere actie uit te voeren. Daarvoor voegen we een methode voor deze klas. Stel dat ik wil dat de functionaliteit de volledige naam van de medewerker weergeeft. Laten we dit dus praktisch implementeren.

class employee: def __init __ (self, first, last, sal): self.fname = first self.lname = last self.sal = sal self.email = first + '.' + last + '@ company.com' def volledige naam (zelf): retourneer '{} {}'. format (self.fname, self.lname) emp_1 = medewerker ('aayushi', 'johari', 350000) emp_2 = medewerker ('test', 'test', 100000) print (emp_1.email) print (emp_2.email) print (emp_1.fullname ()) print (emp_2.fullname ())

Uitvoer-

aayushi.johari@company.com test.test@company.com aayushijohari testtest

Zoals je hierboven kunt zien, heb ik een methode gemaakt met de naam 'volledige naam' binnen een klas. Dus elke methode in een python-klasse neemt automatisch de instantie als het eerste argument. Nu heb ik binnen deze methode de logica geschreven om de volledige naam af te drukken en deze te retourneren in plaats van emp_1 voornaam en achternaam. Vervolgens heb ik 'self' gebruikt, zodat het met alle instanties werkt. Om dit elke keer af te drukken, gebruiken we een methode .

Als je verder gaat met Python-klassen, zijn er variabelen die worden gedeeld door alle instanties van een klasse. Deze worden genoemd als class variabelen . Instancevariabelen kunnen uniek zijn voor elke instantie, zoals namen, e-mail, verkoop enz. Ingewikkeld? Laten we dit met een voorbeeld begrijpen. Raadpleeg de onderstaande code voor de jaarlijkse stijging van het salaris.

class employee: perc_raise = 1.05 def __init __ (self, first, last, sal): self.fname = first self.lname = last self.sal = sal self.email = first + '.' + last + '@ company.com' def volledige naam (zelf): retourneer '{} {}'. format (self.fname, self.lname) def apply_raise (self): self.sal = int (self.sal * 1.05 ) emp_1 = medewerker ('aayushi', 'johari', 350000) emp_2 = medewerker ('test', 'test', 100000) print (emp_1.sal) emp_1.apply_raise () print (emp_1.sal)

Uitvoer-

350000 367500

Zoals je hierboven kunt zien, heb ik eerst het salaris afgedrukt en daarna de verhoging van 1,5% toegepast. Om toegang te krijgen tot deze klassevariabelen, moeten we ze openen via de klasse of een instantie van de klasse. Laten we nu eens kijken naar de verschillende attributen in een python-klasse.

datagedreven raamwerk in selenium

Attributen in een Python-klasse

Attributen in Python definiëren een eigenschap van een object, element of bestand. Er zijn twee soorten attributen:

  • Ingebouwde klassenkenmerken: Er zijn verschillende ingebouwde attributen aanwezig in Python-klassen. Bijvoorbeeld _dict_, _doc_, _name _, etc. Laat ik hetzelfde voorbeeld nemen waar ik alle sleutel-waardeparen van employee1 wil zien. Daarvoor kunt u eenvoudig de onderstaande instructie schrijven die de klassenaamruimte bevat:

    wat is virtuele functie in java
    afdrukken (emp_1 .__ dict__)

    Nadat u het heeft uitgevoerd, krijgt u uitvoer zoals: {‘fname’: ‘aayushi’, ‘lname’: ‘johari’, ‘sal’: 350000, ’e-mail’: ‘aayushi.johari@company.com’}

  • Attributen gedefinieerd door gebruikers : Attributen worden gemaakt binnen de klassendefinitie. We kunnen dynamisch nieuwe attributen maken voor bestaande instanties van een klasse. Attributen kunnen ook aan klassenamen worden gebonden.

Vervolgens hebben we openbaar, beschermd en privaat attributen. Laten we ze in detail begrijpen:

Benoemen Type Betekenis
NaamOpenbaarDeze attributen kunnen vrij worden gebruikt binnen of buiten een klassendefinitie
_naamBeschermdBeveiligde attributen mogen niet buiten de klassedefinitie worden gebruikt, tenzij binnen een subklassedefinitie
__naamPrivaatDit soort attribuut is ontoegankelijk en onzichtbaar. Het is niet mogelijk om die attributen te lezen of te schrijven, behalve binnen de klassedefinitie zelf


Laten we vervolgens de belangrijkste component in een python-klasse, d.w.z. objecten, begrijpen.

Wat zijn objecten in een Python-klasse?

Zoals we hierboven hebben besproken, kan een object worden gebruikt om toegang te krijgen tot verschillende attributen. Het wordt gebruikt om een ​​instantie van de klasse te maken. Een instantie is een object van een klasse die tijdens runtime is gemaakt.

TOm je een snel overzicht te geven, is een object eigenlijk alles wat je om je heen ziet. Bijvoorbeeld: een hond is een object van de dierenklasse, ik ben een object van de menselijke klasse. Evenzo kunnen er verschillende objecten zijn voor dezelfde telefoonklasse.Dit lijkt veel op een functieaanroep die we al hebben besproken. Laten we dit begrijpen met een voorbeeld:

class MyClass: def func (self): print ('Hallo') # maak een nieuwe MyClass ob = MyClass () ob.func ()

Laten we verder gaan met de python-klasse, laten we de verschillende OOP-concepten begrijpen.

OOPs-concepten

OOP's verwijst naar Object-Oriented Programming in Python. Nou, Python is niet volledig objectgeoriënteerd omdat het enkele procedurele functies bevat. Nu moet je je afvragen wat het verschil is tussen een procedurele en objectgeoriënteerde programmering. Om uw twijfel weg te nemen: bij een procedurele programmering wordt de hele code in één lange procedure geschreven, ook al bevat deze mogelijk functies en subroutines. Het is niet beheersbaar omdat zowel gegevens als logica door elkaar worden gemengd. Maar als we het hebben over objectgeoriënteerd programmeren, wordt het programma opgesplitst in op zichzelf staande objecten of verschillende miniprogramma's. Elk object vertegenwoordigt een ander deel van de applicatie dat zijn eigen gegevens en logica heeft om onderling te communiceren. Een website heeft bijvoorbeeld verschillende objecten zoals afbeeldingen, video's etc.
Objectgeoriënteerd programmeren omvat het concept van Python-klasse, object, overerving, polymorfisme, abstractie enz. Laten we deze onderwerpen in detail begrijpen.

Python Class: Inheritance

Overerving stelt ons in staat attributen en methoden van de basis / bovenliggende klasse over te nemen. Dit is handig omdat we subklassen kunnen maken en alle functionaliteit uit onze bovenliggende klasse kunnen halen. Dan kunnen we nieuwe functionaliteiten overschrijven en toevoegen zonder de bovenliggende klasse te beïnvloeden. Laten we het concept van bovenliggende klasse en onderliggende klasse met een voorbeeld bekijken.

Zoals we op de afbeelding kunnen zien, erft een kind de eigendommen van de vader. Evenzo zijn er in python twee klassen:

1. Ouderklasse (Super- of Basisklasse)

2. Kindklasse (subklasse of afgeleide klasse)

Een klasse die de eigenschappen erft, staat bekend als Kind Klasse terwijl een klasse waarvan de eigenschappen worden geërfd, bekend staat als Ouder klasse.

Overerving verwijst naar het vermogen om te creëren Subklassen die specialisaties van hun ouders bevatten. Het is verder onderverdeeld in vier typen, namelijk enkelvoudige, meervoudige, hiërarchische en meervoudige overervingen. Raadpleeg de onderstaande afbeelding voor een beter begrip.

Laten we doorgaan met de python-klasse en begrijpen hoe overerving nuttig is.

Stel, ik wil klassen maken voor de soorten werknemers. Ik ga ‘ontwikkelaars’ en ‘managers’ aanmaken als subklassen, aangezien zowel ontwikkelaars als managers een naam, e-mailadres en salaris hebben en al deze functionaliteiten zullen aanwezig zijn in de werknemersklasse. Dus in plaats van de code voor de subklassen te kopiëren, kunnen we de code eenvoudig hergebruiken door te erven van de werknemer.

gebruik van scannerklasse in java
class employee: num_employee = 0 raise_amount = 1.04 def __init __ (self, first, last, sal): self.first = first self.last = last self.sal = sal self.email = first + '.' + last + '@ company.com' employee.num_employee + = 1 def fullname (self): return '{} {}'. format (self.first, self.last) def apply_raise (self): self.sal = int ( self.sal * raise_amount) klasse ontwikkelaar (werknemer): pass emp_1 = ontwikkelaar ('aayushi', 'johari', 1000000) print (emp_1.email)
 Uitvoer - aayushi.johari@company.com

Zoals u in de bovenstaande uitvoer kunt zien, zijn alle details van de werknemersklasse beschikbaar in de ontwikkelaarsklasse.Wat moet ik doen als ik het raise_amount voor een ontwikkelaar wil veranderen in 10%? laten we eens kijken hoe het praktisch kan worden gedaan.

class employee: num_employee = 0 raise_amount = 1.04 def __init __ (self, first, last, sal): self.first = first self.last = last self.sal = sal self.email = first + '.' + last + '@ company.com' employee.num_employee + = 1 def fullname (self): return '{} {}'. format (self.first, self.last) def apply_raise (self): self.sal = int ( self.sal * raise_amount) klasse ontwikkelaar (werknemer): raise_amount = 1.10 emp_1 = ontwikkelaar ('aayushi', 'johari', 1000000) print (emp_1.raise_amount)
 Uitvoer - 1.1

Zoals u kunt zien, heeft het de procentuele salarisstijging bijgewerkt van 4% naar 10%.Als ik nu nog een attribuut wil toevoegen, zeg dan een programmeertaal in onze init-methode, maar die bestaat niet in onze bovenliggende klasse. Is daar een oplossing voor? Ja! we kunnen de hele werknemerslogica kopiëren en dat doen, maar het zal opnieuw de codegrootte vergroten. Laten we daarom de onderstaande code bekijken om dat te voorkomen:

class employee: num_employee = 0 raise_amount = 1.04 def __init __ (self, first, last, sal): self.first = first self.last = last self.sal = sal self.email = first + '.' + last + '@ company.com' employee.num_employee + = 1 def fullname (self): return '{} {}'. format (self.first, self.last) def apply_raise (self): self.sal = int ( self.sal * raise_amount) klasse ontwikkelaar (werknemer): raise_amount = 1.10 def __init __ (self, first, last, sal, prog_lang): super () .__ init __ (first, last, sal) self.prog_lang = prog_lang emp_1 = ontwikkelaar ( 'aayushi', 'johari', 1000000, 'python') print (emp_1.prog_lang)

Daarom heb ik met een klein beetje code wijzigingen aangebracht. Ik heb super .__ init __ (first, last, pay) gebruikt die de eigenschappen van de basisklasse erft.Tot slot wordt overerving gebruikt om de code opnieuw te gebruiken en de complexiteit van een programma te verminderen.

Python-klasse: polymorfisme

Polymorfisme in de informatica is het vermogen om dezelfde interface te presenteren voor verschillende onderliggende vormen. In de praktijk betekent polymorfisme dat als klasse B erft van klasse A, het niet alles van klasse A hoeft te erven, maar dat het een aantal dingen kan doen die klasse A anders doet. Het wordt het meest gebruikt bij overerving. Python is impliciet polymorf, het heeft de mogelijkheid om standaardoperatoren te overbelasten, zodat ze passend gedrag vertonen op basis van hun context.

Laten we het met een voorbeeld begrijpen:

class Animal: def __init __ (self, name): self.name = name def talk (self): pass class Dog (Animal): def talk (self): print ('Woof') class Cat (Animal): def talk ( self): print ('MEOW!') c = Cat ('kitty') c.talk () d = Dog (Animal) d.talk ()

Uitgang -

Mauw! Inslag

Laten we vervolgens naar een ander objectgeoriënteerd programmeerconcept gaan, namelijk abstractie.

Python-klasse: abstractie

Abstractie wordt gebruikt om de complexe realiteit te vereenvoudigen door klassen te modelleren die geschikt zijn voor het probleem. Hier hebben we een abstracte klasse die niet kan worden geïnstantieerd. Dit betekent dat u geen objecten of instanties voor deze klassen kunt maken. Het kan alleen worden gebruikt voor het erven van bepaalde functionaliteiten die u als een basisklasse aanroept. U kunt dus functionaliteiten erven, maar u kunt tegelijkertijd geen instantie van deze specifieke klasse maken. Laten we het concept van abstracte klasse begrijpen met een voorbeeld hieronder:

van abc import ABC, abstractmethod klasse Medewerker (ABC): @abstractmethod def bereken_salaris (zelf, sal): pass class Ontwikkelaar (Medewerker): def bereken_salaris (zelf, sal): eindsalaris = sal * 1.10 terug eindsalaris emp_1 = Ontwikkelaar () print (emp_1.calculate_salary (10000))

Uitvoer-

11000.0

Zoals je kunt zien in de bovenstaande output, hebben we het basissalaris verhoogd naar 10%, dwz het salaris is nu 11000. Als je nu echt doorgaat en een object maakt van de klasse 'Werknemer', krijg je een foutmelding zoals python niet doet Je mag geen object van abstracte klasse maken. Maar door overerving te gebruiken, kunt u de eigenschappen daadwerkelijk erven en de respectieve taken uitvoeren.

Dus jongens, dit ging allemaal over python-klassen en objecten in een notendop. We hebben alle basisprincipes van de Python-klasse, objecten en verschillende objectgeoriënteerde concepten in Python behandeld, dus je kunt nu beginnen met oefenen. Ik hoop dat jullie genoten hebben van het lezen van deze blog over 'Python Class' en duidelijk zijn over elk aspect dat ik hierboven heb besproken. Na de python-les zal ik meer blogs over Python bedenken voor scikit learn-bibliotheek en array. Blijf kijken!

Heeft u een vraag voor ons? Vermeld het in het commentaargedeelte van deze 'Python Class' -blog en we nemen zo snel mogelijk contact met je op.

Om diepgaande kennis van Python en zijn verschillende toepassingen te krijgen, kunt u met onze live online training met 24/7 ondersteuning en levenslange toegang.