Inhoudsopgave[Zich verstoppen][Laten zien]
Onder ontwikkelaars heeft objectgeoriënteerd programmeren een aanzienlijke aanhang getrokken. De populaire computertaal Python houdt zich eveneens aan het objectgeoriënteerde paradigma.
Het behandelt het definiëren van objecten en klassen in Python, die de basis vormen voor OOPs-principes. In deze tutorial over 'objectgeoriënteerd programmeren in Python' leer je hoe je Python-klassen declareert, er objecten van maakt en de vier OOPs-technieken gebruikt.
Dus eerst wat.
Wat is objectgeoriënteerd programmeren?
De belangrijkste focus van objectgeoriënteerd programmeren (OOP) is het creëren van "objecten". Een verzameling onderling verbonden variabelen en functies vormt een object.
Deze variabelen worden vaak de attributen van het object genoemd en het gedrag ervan wordt vaak de functies genoemd. Deze items geven de applicatie een effectievere en begrijpelijkere structuur. Een auto is een voorbeeld van een item.
Als de auto een item zou zijn, zouden zijn attributen dingen omvatten zoals de kleur, het model, de prijs, het merk, enz. Bovendien zou het versnellen, vertragen en schakelen.
Nog een illustratie: als we een hond als een item beschouwen, dan zouden enkele van zijn kenmerken kleur, ras, naam, gewicht, enz. kunnen zijn. En hij zou rondlopen, blaffen, spelen, enz.
Omdat het concepten uit de echte wereld zoals objecten, verbergen, overerving, enz. In de programmering opneemt, is objectgeoriënteerd programmeren algemeen bekend. Omdat het zo lijkt op omstandigheden in de echte wereld, wordt visualisatie eenvoudiger gemaakt.
Objectgeoriënteerde programmeerconcepten
Klassen en objecten in Python
Net als alle andere objectgeoriënteerde talen, stelt Python je in staat klassen te ontwerpen om objecten te genereren. De meest populaire gegevenstypen in Python, inclusief strings, lijsten, woordenboeken en andere objecten, zijn ingebouwde klassen.
Een klasse is een groep gekoppelde methoden en instantievariabelen die een bepaald soort object definiëren. Een klasse kan worden gezien als het model of de sjabloon voor een object. De variabelen waaruit een klasse bestaat, worden attributen genoemd.
Een object is een lid van een klasse die een gedefinieerde set attributen heeft. Hierdoor kan een willekeurig aantal objecten worden gemaakt met dezelfde klasse.
Python-klassen worden gedefinieerd met het woord class, gevolgd door de klassenaam en een dubbele punt. Een illustratie van een papegaaienklas zou kunnen zijn:
Hier declareren we de lege klasse Parrot met het class-sleutelwoord. We maken instanties van klassen. Een instantie is een bepaald object dat uit een bepaalde klasse is gemaakt. 'pass' wordt vaak gebruikt als vervanging voor code waarvan we de implementatie voorlopig achterwege kunnen laten. We kunnen de Python-code uitvoeren zonder een fout te veroorzaken door het sleutelwoord "pass" te gebruiken.
Een instantie van een klasse resulteert in een object (instantie). Alleen de beschrijving van het object wordt gedefinieerd wanneer een klasse wordt gemaakt. Als gevolg hiervan wordt er geen opslag of RAM toegewezen.
Een voorbeeld van een papegaaienklasse-object is:
Obj is in dit geval een object van de Parrot-klasse.
Laten we zeggen dat we details over papegaaien weten. We zullen nu demonstreren hoe de papegaaienklasse en zijn objecten gemaakt kunnen worden.
Speciale methode ( __init__ )
Een methode genaamd init definieert de attributen die elk Parrot-object moet hebben (). Wanneer een nieuw Parrot-object wordt gevormd, creëert de functie __init__ de begintoestand van het object door de waarden toe te kennen die we leveren binnen de eigenschappen van het object.
Dus elke nieuwe instantie van de klasse wordt geïnitialiseerd met __init__(). Hoewel __init__() een willekeurig aantal parameters kan accepteren, is self altijd de eerste parameter.
Een verwijzing naar de actieve klasse-instantie is opgenomen in het zelfargument. De parameter self, die linkt naar het adres van het huidige object van een klasse en ons toegang geeft tot de gegevens van de variabelen (van het object), geeft dat aan.
Voorbeeld 1
We hebben een klasse gemaakt met de naam Parrot in de bovenstaande code. Vervolgens worden eigenschappen gedefinieerd. De kenmerken van een ding zijn zijn eigenschappen. De __init__-functie van de klasse is waar deze kenmerken worden gespecificeerd.
Wanneer een object wordt gevormd, is de initialisatiemethode degene die in eerste instantie wordt aangeroepen. Vervolgens worden instanties van de Parrot-klasse gemaakt. Blaze en Wonda zijn in dit geval verwijzingen (waarden) naar onze nieuwe objecten. __class .species geeft ons toegang tot het class attribuut.
Elke instantie van een klasse heeft dezelfde kenmerken. De instantiekenmerken zijn ook toegankelijk via blaze.name en blaze.age. Alle instanties van een klasse hebben echter unieke instantiekenmerken.
Voorbeeld 2
Methoden
Functies die in de body van een klasse zijn gedefinieerd, worden methoden genoemd. Ze worden gebruikt om aan te geven hoe een item zich zal gedragen.
Twee methoden, sing() en dance, zijn gedefinieerd in de bovengenoemde toepassing (). Omdat ze worden aangeroepen op een instantieobject, zoals een vlam, worden dit instantiemethoden genoemd.
Grondslagen van het OOPS-concept
De vier kernideeën van objectgeoriënteerd programmeren zijn:
- Erfenis
- Inkapseling
- polymorfisme
- Abstractie
Erfenis
Mensen vertellen pasgeborenen vaak dat ze gezichtskenmerken hebben die lijken op die van hun ouders of dat ze bepaalde eigenschappen van hun ouders hebben geërfd.
Het is mogelijk dat je ook hebt opgemerkt dat je een paar kenmerken deelt met je ouders. De situatie in de echte wereld is ook redelijk vergelijkbaar met overerving.
In dit geval worden de kenmerken van de 'ouderklassen' echter doorgegeven aan de 'kindklassen'. Deze aspecten worden in dit verband 'eigenschappen' en 'methoden' genoemd.
Een klasse kan zijn methoden en attributen van een andere klasse afleiden door gebruik te maken van de techniek die bekend staat als overerving. Overerving is het proces waarbij een onderliggende klasse de eigenschappen van een bovenliggende klasse ontvangt.
Voorbeeld:
De bovenliggende klasse Mens wordt geërfd door de kindklasse Jongen in het bovenstaande voorbeeld. Omdat Boy van Human erft, hebben we toegang tot al zijn methoden en attributen wanneer we een instantie van de Boy-klasse maken.
In de klasse Boy is ook een methode met de naam schoolName gedefinieerd. Het bovenliggende klasseobject heeft geen toegang tot de methode schoolName. De methode schoolName kan echter worden aangeroepen door een kindklasse-object (Boy) te maken.
Inkapseling
Elke variabele in het programma globale toegang geven is geen verstandige zet bij het werken met klassen en het omgaan met gevoelige gegevens.
Zonder het programma volledige toegang te geven tot een van die variabelen, biedt inkapseling ons een mechanisme om de benodigde variabelen te verkrijgen.
Methoden die expliciet voor dit doel zijn gedefinieerd, kunnen worden gebruikt om gegevens van variabelen bij te werken, te bewerken of te verwijderen. Deze programmeermethode heeft de voordelen van verbeterde beveiliging en controle over de gegevensinvoer.
Bekijk hoe snel variabelen toegankelijk kunnen zijn in de onderstaande demonstratie:
polymorfisme
Stel dat u uw telefoon gebruikt om door de Instagram feeds. Toen je de drang kreeg om naar wat muziek te luisteren, ging je naar Spotify en begon je je favoriete nummer te spelen.
Na een tijdje kreeg je een oproep, dus pauzeerde je wat je op de achtergrond aan het doen was om het te beantwoorden. Je vriend belde en verzocht je om het telefoonnummer van een bepaalde persoon te sms'en.
Dus je stuurde hem het telefoonnummer via sms en ging verder met je taken. Heb je iets opgepikt? Met slechts één apparaat, uw mobiele telefoon, kunt u door feeds surfen, naar muziek luisteren, telefoneren en berichten versturen.
Daarom is polymorfisme daarmee vergelijkbaar. Poly betekent talrijk en morph duidt verschillende vormen aan. Daarom verwijst polymorfisme als geheel naar iets met verschillende vormen.
Of 'iets' dat, afhankelijk van de omstandigheden, verschillende gedragingen kan vertonen. In OOPS beschrijft polymorfisme functies met dezelfde namen maar verschillend gedrag. Als alternatief een andere functiehandtekening met dezelfde functienaam (parameters doorgegeven aan de functie).
Voorbeeld:
Hier kunnen we het variabele dier gebruiken om de objecten van de zebra en het konijn te herhalen, met behulp van hun respectievelijke instantiemethoden. Als gevolg hiervan wordt het gedrag (kleur() & eet()) van zowel de zebra als het konijn hier weergegeven door een enkele variabele die dier wordt genoemd. Het houdt zich dus aan de polymorfismeregels.
Abstractie
U gebruikt waarschijnlijk een laptop, telefoon of tablet om deze inhoud te lezen. Terwijl u het leest, maakt u vermoedelijk ook aantekeningen, onderstreept u belangrijke passages en slaat u misschien wat informatie op in uw persoonlijke bestanden.
Het enige dat u kunt zien als u dit leest, is een "scherm" met de gegevens die aan u worden getoond. Je ziet gewoon de toetsen van het toetsenbord terwijl je typt, dus je hoeft je geen zorgen te maken over interne subtiliteiten, zoals hoe het indrukken van een toets ervoor kan zorgen dat dat woord op het scherm verschijnt.
Als alternatief kan het indrukken van een knop op uw scherm een nieuw tabblad starten.
Daarom is alles wat we in deze situatie kunnen waarnemen abstract. We kunnen alleen het resultaat zien dat het creëert en niet de ingewikkeldheden van binnen (die er echt toe doen voor ons).
Evenzo onthult abstractie alleen de functies die alles heeft, terwijl implementaties of interne details worden verborgen.
Het belangrijkste doel van Abstraction is om achtergrondinformatie en eventuele externe data-implementatie te verbergen, zodat mensen alleen zien wat ze moeten zien. Het helpt bij het beheren van de complexiteit van de code.
Voorbeeld:
Een voertuiggerelateerde abstracte klasse is hier aanwezig. Omdat het van de abstracte klasse ABC erft, is het abstract. Omdat abstracte methoden niet gedefinieerd zijn of leeg blijven, heeft de klasse Vehicle een abstracte methode genaamd no of wheels die geen definitie heeft.
Ze anticiperen op de klassen die de abstracte klassen erven om de implementatie van de methode te geven.
Voordelen van OOPS-concepten
- Door inkapseling wordt een hoge beveiliging en gegevensprivacy bereikt.
- Flexibiliteit in het hebben van veel polymorfe versies van dezelfde klasse.
- Het hoge niveau van codecomplexiteit werd verminderd door abstractie.
- In plaats van honderden regels code te doorzoeken om een enkel probleem te lokaliseren, maakt de modulariteit van programmeren het debuggen eenvoudig.
- Hergebruik van code wordt veroorzaakt door de overerving van bovenliggende klasse-eigenschappen door een onderliggende klasse.
- Effectieve probleemoplossing is mogelijk omdat we klassen maken die voor elk miniprobleem de nodige acties uitvoeren. Het volgende probleem kan nog sneller worden opgelost omdat we die klassen kunnen hergebruiken.
Conclusie
Tot slot hebben we geleerd over OOPS-ideeën in Python, het populairste programmeerparadigma van dit moment.
Nadat je dit hebt gelezen, moet je je gerealiseerd hebben dat het OOPS-paradigma volledig te maken heeft met het idee van klassen en objecten. en OOPS-concepten zoals inkapseling, polymorfisme, overerving en abstractie.
Laat een reactie achter