Objectgeoriënteerd programmeren is een fundamenteel concept in Python en stelt ontwikkelaars in staat modulaire, onderhoudbare en schaalbare applicaties te bouwen. Door de kernprincipes van OOP te begrijpen (klassen, objecten, overerving, inkapseling, polymorfisme en abstractie) kunnen programmeurs het volledige potentieel van de OOP-mogelijkheden van Python benutten om elegante en efficiënte oplossingen voor complexe problemen te ontwerpen.

Wat is objectgeoriënteerd programmeren in Python?

In Python is objectgeoriënteerd programmeren (OOPs) een programmeerparadigma dat objecten en klassen gebruikt bij het programmeren. Het is bedoeld om entiteiten uit de echte wereld, zoals overerving, polymorfismen, inkapseling, enz., in de programmering te implementeren. Het belangrijkste concept van objectgeoriënteerd programmeren (OOPs) of oeps-concepten in Python is om de gegevens en de functies die samenwerken als een enkele eenheid te binden, zodat geen enkel ander deel van de code toegang heeft tot deze gegevens.

OOPs-concepten in Python

• Klasse in Python
• Objecten in Python
• Polymorfisme in Python
• Inkapseling in Python
• Overerving in Python
• Gegevensabstractie in Python

Python OOPs-concepten

grootte van vector c++

Python-klasse

Een klasse is een verzameling objecten. Een klasse bevat de blauwdrukken of het prototype waaruit de objecten worden gemaakt. Het is een logische entiteit die enkele attributen en methoden bevat.

Laten we, om de noodzaak van het maken van een klasse te begrijpen, een voorbeeld bekijken. Laten we zeggen dat u het aantal honden wilt bijhouden die mogelijk verschillende kenmerken hebben, zoals ras en leeftijd. Als een lijst wordt gebruikt, kan het eerste element het ras van de hond zijn, terwijl het tweede element de leeftijd ervan kan vertegenwoordigen. Laten we aannemen dat er 100 verschillende honden zijn, hoe zou je dan weten welk element welk element zou moeten zijn? Wat als u andere eigenschappen aan deze honden zou willen toevoegen? Dit mist organisatie en het is precies de behoefte aan lessen.

Enkele punten over de Python-klasse:

• Klassen worden gemaakt per trefwoordklasse.
• Attributen zijn de variabelen die bij een klasse horen.
• Kenmerken zijn altijd openbaar en toegankelijk via de puntoperator (.). Bijv.: Mijnklasse.Mijnattribuut

Syntaxis van klassedefinitie:

class ClassName: # Statement-1 . . . # Statement-N>

Een lege klasse maken in Python

In het bovenstaande voorbeeld hebben we een klasse met de naam Hond gemaakt met behulp van het trefwoord class.

# Python3 program to # demonstrate defining # a class class Dog: pass>

Python-objecten

In objectgeoriënteerd programmeren in Python is het object een entiteit waaraan een toestand en gedrag is gekoppeld. Het kan elk object uit de echte wereld zijn, zoals een muis, toetsenbord, stoel, tafel, pen, enz. Gehele getallen, tekenreeksen, getallen met drijvende komma, zelfs arrays en woordenboeken zijn allemaal objecten. Meer specifiek is elk enkel geheel getal of elke enkele string een object. Het getal 12 is een object, de string Hallo, wereld is een object, een lijst is een object dat andere objecten kan bevatten, enzovoort. Je gebruikt al die tijd objecten en beseft het misschien niet eens.

Een object bestaat uit:

• Staat: Het wordt weergegeven door de attributen van een object. Het weerspiegelt ook de eigenschappen van een object.
• Gedrag: Het wordt weergegeven door de methoden van een object. Het weerspiegelt ook de reactie van een object op andere objecten.
• Identiteit: Het geeft een unieke naam aan een object en zorgt ervoor dat een object kan communiceren met andere objecten.

Om de toestand, het gedrag en de identiteit te begrijpen, nemen we het voorbeeld van de klassehond (hierboven uitgelegd).

• De identiteit kan worden beschouwd als de naam van de hond.
• Staat of kenmerken kunnen worden beschouwd als het ras, de leeftijd of de kleur van de hond.
• Bij het gedrag kan worden gekeken of de hond eet of slaapt.

Een object maken

Hierdoor wordt een object gemaakt met de naam obj van de klasse Dog die hierboven is gedefinieerd. Voordat we diep in objecten en klassen duiken, moeten we enkele basissleutelwoorden begrijpen die zullen worden gebruikt bij het werken met objecten en klassen.

obj = Dog()>

Het Python-zelf

1. Klassemethoden moeten een extra eerste parameter hebben in de methodedefinitie. We geven geen waarde voor deze parameter als we de methode aanroepen; Python levert deze
2. Als we een methode hebben die geen argumenten gebruikt, dan hebben we nog steeds één argument nodig.
3. Dit is vergelijkbaar met deze pointer in C++ en deze referentie in Java.

Wanneer we een methode van dit object aanroepen als myobject.method(arg1, arg2), wordt dit automatisch door Python omgezet in MyClass.method(myobject, arg1, arg2) – dit is alles waar het speciale zelf over gaat.

Opmerking: Voor meer informatie, zie zichzelf in de Python-klasse

De Python __init__-methode

De __init__ methode is vergelijkbaar met constructors in C++ en Java. Het wordt uitgevoerd zodra een object van een klasse wordt geïnstantieerd. De methode is handig om elke initialisatie uit te voeren die u met uw object wilt uitvoeren. Laten we nu een klasse definiëren en enkele objecten maken met behulp van de methode self en __init__.

Een klasse en object maken met klasse- en instantieattributen

class Dog: # class attribute attr1 = 'mammal' # Instance attribute def __init__(self, name): self.name = name # Driver code # Object instantiation Rodger = Dog('Rodger') Tommy = Dog('Tommy') # Accessing class attributes print('Rodger is a {}'.format(Rodger.__class__.attr1)) print('Tommy is also a {}'.format(Tommy.__class__.attr1)) # Accessing instance attributes print('My name is {}'.format(Rodger.name)) print('My name is {}'.format(Tommy.name))>

Rodger is a mammal Tommy is also a mammal My name is Rodger My name is Tommy>

Klassen en objecten maken met methoden

Hier wordt de klasse Dog gedefinieerd met twee attributen:

• attr1 is een klasseattribuut ingesteld op de waarde zoogdier . Klassekenmerken worden gedeeld door alle instanties van de klasse.
• __init__ is een speciale methode (constructor) die een instantie van de klasse Dog initialiseert. Er zijn twee parameters nodig: zelf (verwijzend naar de instantie die wordt gemaakt) en naam (die de naam van de hond vertegenwoordigt). De parameter name wordt gebruikt om een ​​naamattribuut toe te wijzen aan elk exemplaar van Dog.
  De spreekmethode wordt gedefinieerd binnen de Dog-klasse. Deze methode drukt een tekenreeks af die de naam van de dog-instantie bevat.

De stuurprogrammacode begint met het maken van twee exemplaren van de Dog-klasse: Rodger en Tommy. De methode __init__ wordt voor elke instantie aangeroepen om de naamkenmerken ervan te initialiseren met de opgegeven namen. De speak-methode wordt in beide gevallen aangeroepen (Rodger.speak() en Tommy.speak()), waardoor elke hond een verklaring met zijn naam afdrukt.

class Dog: # class attribute attr1 = 'mammal' # Instance attribute def __init__(self, name): self.name = name def speak(self): print('My name is {}'.format(self.name)) # Driver code # Object instantiation Rodger = Dog('Rodger') Tommy = Dog('Tommy') # Accessing class methods Rodger.speak() Tommy.speak()>

My name is Rodger My name is Tommy>

Opmerking: Voor meer informatie, zie Python-klassen en objecten

tekenreeksaaneenschakeling java

Python-erfenis

Bij objectgeoriënteerd programmeren in Python is overerving het vermogen van de ene klasse om de eigenschappen van een andere klasse af te leiden of te erven. De klasse die eigenschappen afleidt, wordt de afgeleide klasse of onderliggende klasse genoemd en de klasse waarvan de eigenschappen worden afgeleid, wordt de basisklasse of bovenliggende klasse genoemd. De voordelen van een erfenis zijn:

• Het vertegenwoordigt relaties uit de echte wereld goed.
• Het biedt de herbruikbaarheid van een code. We hoeven niet steeds opnieuw dezelfde code te schrijven. Het stelt ons ook in staat meer functies aan een klasse toe te voegen zonder deze te wijzigen.
• Het is transitief van aard, wat betekent dat als klasse B erft van een andere klasse A, alle subklassen van B automatisch zouden erven van klasse A.

Soorten erfenis

• Enkelvoudige erfenis : Overerving op één niveau zorgt ervoor dat een afgeleide klasse kenmerken kan erven van een klasse met één ouder.
• Overerving op meerdere niveaus: Overerving op meerdere niveaus stelt een afgeleide klasse in staat eigenschappen te erven van een directe bovenliggende klasse, die op zijn beurt eigenschappen overneemt van zijn bovenliggende klasse.
• Hiërarchische erfenis: Overerving op hiërarchisch niveau maakt het mogelijk dat meer dan één afgeleide klasse eigenschappen van een bovenliggende klasse overneemt.
• Meervoudige erfenis: Overerving op meerdere niveaus maakt het mogelijk dat één afgeleide klasse eigenschappen van meer dan één basisklasse overneemt.

Overerving in Python

In het bovenstaande artikel hebben we twee klassen gemaakt, namelijk Persoon (ouderklasse) en Werknemer (kindklasse). De klasse Employee erft van de klasse Person. We kunnen de methoden van de personenklasse gebruiken via de werknemersklasse, zoals te zien in de weergavefunctie in de bovenstaande code. Een onderliggende klasse kan ook het gedrag van de bovenliggende klasse wijzigen, zoals blijkt uit de methode details().

# Python code to demonstrate how parent constructors # are called. # parent class class Person(object): # __init__ is known as the constructor def __init__(self, name, idnumber): self.name = name self.idnumber = idnumber def display(self): print(self.name) print(self.idnumber) def details(self): print('My name is {}'.format(self.name)) print('IdNumber: {}'.format(self.idnumber)) # child class class Employee(Person): def __init__(self, name, idnumber, salary, post): self.salary = salary self.post = post # invoking the __init__ of the parent class Person.__init__(self, name, idnumber) def details(self): print('My name is {}'.format(self.name)) print('IdNumber: {}'.format(self.idnumber)) print('Post: {}'.format(self.post)) # creation of an object variable or an instance a = Employee('Rahul', 886012, 200000, 'Intern') # calling a function of the class Person using # its instance a.display() a.details()>

Rahul 886012 My name is Rahul IdNumber: 886012 Post: Intern>

Opmerking: Voor meer informatie verwijzen wij u naar onze Overerving in Python zelfstudie.

Python-polymorfisme

In objectgeoriënteerd programmeren in Python betekent polymorfisme eenvoudigweg het hebben van vele vormen. We moeten bijvoorbeeld bepalen of de gegeven vogelsoort vliegt of niet. Met behulp van polymorfisme kunnen we dit doen met behulp van een enkele functie.

Polymorfisme in Python

Deze code demonstreert het concept van Python-oeps-overerving en methode-overschrijving in Python-klassen. Het laat zien hoe subklassen methoden kunnen overschrijven die in hun bovenliggende klasse zijn gedefinieerd om specifiek gedrag te bieden, terwijl ze nog steeds andere methoden van de bovenliggende klasse overnemen.

class Bird: def intro(self): print('There are many types of birds.') def flight(self): print('Most of the birds can fly but some cannot.') class sparrow(Bird): def flight(self): print('Sparrows can fly.') class ostrich(Bird): def flight(self): print('Ostriches cannot fly.') obj_bird = Bird() obj_spr = sparrow() obj_ost = ostrich() obj_bird.intro() obj_bird.flight() obj_spr.intro() obj_spr.flight() obj_ost.intro() obj_ost.flight()>

There are many types of birds. Most of the birds can fly but some cannot. There are many types of birds. Sparrows can fly. There are many types of birds. Ostriches cannot fly.>

Opmerking: Voor meer informatie verwijzen wij u naar onze Polymorfisme in Python Handleiding.

FCF's

Python-inkapseling

Bij objectgeoriënteerd programmeren in Python is inkapseling een van de fundamentele concepten in objectgeoriënteerd programmeren (OOP). Het beschrijft het idee van het verpakken van gegevens en de methoden die met gegevens binnen één eenheid werken. Dit legt beperkingen op aan de directe toegang tot variabelen en methoden en kan de onbedoelde wijziging van gegevens voorkomen. Om onbedoelde wijzigingen te voorkomen, kan de variabele van een object alleen worden gewijzigd door de methode van een object. Dit soort variabelen staan ​​bekend als privévariabelen.

Een klasse is een voorbeeld van inkapseling omdat deze alle gegevens inkapselt, zoals lidfuncties, variabelen, enz.

Inkapseling in Python

In het bovenstaande voorbeeld hebben we de c-variabele als het privé-attribuut gemaakt. We hebben niet eens rechtstreeks toegang tot dit kenmerk en kunnen de waarde ervan niet eens wijzigen.

# Python program to # demonstrate private members # '__' double underscore represents private attribute.  # Private attributes start with '__'. # Creating a Base class class Base: def __init__(self): self.a = 'techcodeview.com' self.__c = 'techcodeview.com' # Creating a derived class class Derived(Base): def __init__(self): # Calling constructor of # Base class Base.__init__(self) print('Calling private member of base class: ') print(self.__c) # Driver code obj1 = Base() print(obj1.a) # Uncommenting print(obj1.c) will # raise an AttributeError # Uncommenting obj2 = Derived() will # also raise an AtrributeError as # private member of base class # is called inside derived class>

techcodeview.com>

Opmerking: Voor meer informatie verwijzen wij u naar onze Inkapseling in Python Handleiding.

Data abstractie

Het verbergt onnodige codedetails voor de gebruiker. Ook als we gevoelige delen van onze code-implementatie niet willen vrijgeven, en dit is waar data-abstractie ontstond.

Gegevensabstractie in Python kan worden bereikt door abstracte klassen te maken.

Objectgeoriënteerd programmeren in Python | Set 2 (gegevens verbergen en objecten afdrukken)