Python objectgeoriënteerd programmeren

In deze tutorial leer je aan de hand van voorbeelden over Object-Oriented Programming (OOP) in Python en het fundamentele concept ervan.

Video:objectgeoriënteerd programmeren in Python

Objectgeoriënteerd programmeren

Python is een programmeertaal met meerdere paradigma's. Het ondersteunt verschillende programmeerbenaderingen.

Een van de populaire benaderingen om een ​​programmeerprobleem op te lossen, is door objecten te maken. Dit staat bekend als Object-Oriented Programming (OOP).

Een object heeft twee kenmerken:

• kenmerken
• gedrag

Laten we een voorbeeld nemen:

Een papegaai is een object, omdat het de volgende eigenschappen heeft:

• naam, leeftijd, kleur als attributen
• zingen, dansen als gedrag

Het concept van OOP in Python richt zich op het maken van herbruikbare code. Dit concept staat ook bekend als DRY (Don't Repeat Yourself).

In Python volgt het concept van OOP enkele basisprincipes:

Klasse

Een klasse is een blauwdruk voor het object.

We kunnen klasse zien als een schets van een papegaai met labels. Het bevat alle details over de naam, kleuren, maat etc. Op basis van deze beschrijvingen kunnen we ons verdiepen in de papegaai. Hier is een papegaai een object.

Het voorbeeld voor papegaaienklasse kan zijn:

class Parrot:
    pass

Hier gebruiken we de class trefwoord om een ​​lege klasse te definiëren Parrot . Vanuit klasse construeren we instanties. Een instantie is een specifiek object gemaakt van een bepaalde klasse.

Object

Een object (instantie) is een instantie van een klasse. Wanneer klasse is gedefinieerd, wordt alleen de beschrijving voor het object gedefinieerd. Daarom wordt er geen geheugen of opslag toegewezen.

Het voorbeeld voor het object van de papegaaienklasse kan zijn:

obj = Parrot()

Hier, obj is een object van klasse Parrot .

Stel dat we details van papegaaien hebben. Nu gaan we laten zien hoe je de klasse en objecten van papegaaien kunt bouwen.

Voorbeeld 1:klasse en object maken in Python

class Parrot:

    # class attribute
    species = "bird"

    # instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age

# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)

# access the class attributes
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))

# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))

Uitvoer

Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old

In het bovenstaande programma hebben we een klasse gemaakt met de naam Parrot . Vervolgens definiëren we attributen. De attributen zijn een kenmerk van een object.

Deze attributen worden gedefinieerd binnen de __init__ methode van de klas. Het is de initialisatiemethode die voor het eerst wordt uitgevoerd zodra het object is gemaakt.

Vervolgens maken we exemplaren van de Parrot klas. Hier, blu en woo zijn verwijzingen (waarde) naar onze nieuwe objecten.

We hebben toegang tot het class-attribuut met __class__.species . Klasseattributen zijn hetzelfde voor alle instanties van een klasse. Op dezelfde manier krijgen we toegang tot de instantiekenmerken met blu.name en blu.age . De instantiekenmerken zijn echter verschillend voor elke instantie van een klasse.

Ga voor meer informatie over klassen en objecten naar Python-klassen en objecten

Methoden

Methoden zijn functies die zijn gedefinieerd in de body van een klasse. Ze worden gebruikt om het gedrag van een object te definiëren.

Voorbeeld 2:Methoden maken in Python

class Parrot:
    
    # instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # instance method
    def sing(self, song):
        return "{} sings {}".format(self.name, song)

    def dance(self):
        return "{} is now dancing".format(self.name)

# instantiate the object
blu = Parrot("Blu", 10)

# call our instance methods
print(blu.sing("'Happy'"))
print(blu.dance())

Uitvoer

Blu sings 'Happy'
Blu is now dancing

In het bovenstaande programma definiëren we twee methoden, namelijk sing() en dance() . Dit worden instantiemethoden genoemd omdat ze worden aangeroepen op een instantieobject, bijv. blu .

Overerving

Overerving is een manier om een ​​nieuwe klasse aan te maken voor het gebruik van details van een bestaande klasse zonder deze te wijzigen. De nieuw gevormde klasse is een afgeleide klasse (of onderliggende klasse). Evenzo is de bestaande klasse een basisklasse (of bovenliggende klasse).

Voorbeeld 3:Gebruik van overerving in Python

# parent class
class Bird:
    
    def __init__(self):
        print("Bird is ready")

    def whoisThis(self):
        print("Bird")

    def swim(self):
        print("Swim faster")

# child class
class Penguin(Bird):

    def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin is ready")

    def whoisThis(self):
        print("Penguin")

    def run(self):
        print("Run faster")

peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Uitvoer

Bird is ready
Penguin is ready
Penguin
Swim faster
Run faster

In het bovenstaande programma hebben we twee klassen gemaakt, namelijk Bird (ouderklasse) en Pinguïn (kinderklas). De onderliggende klasse erft de functies van de bovenliggende klasse. We kunnen dit zien aan de swim() methode.

Nogmaals, de kindklasse heeft het gedrag van de bovenliggende klasse gewijzigd. We kunnen dit zien aan de whoisThis() methode. Verder breiden we de functies van de bovenliggende klasse uit door een nieuwe run() . te maken methode.

Daarnaast gebruiken we de super() functie binnen de __init__() methode. Hierdoor kunnen we de __init__() . uitvoeren methode van de bovenliggende klasse binnen de onderliggende klasse.

Inkapseling

Met OOP in Python kunnen we de toegang tot methoden en variabelen beperken. Dit voorkomt dat gegevens rechtstreeks worden gewijzigd, wat inkapseling wordt genoemd. In Python duiden we privé-attributen aan met een onderstrepingsteken als voorvoegsel, d.w.z. enkele _ of dubbele __ .

Voorbeeld 4:gegevensinkapseling in Python

class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Selling Price: {}".format(self.__maxprice))

    def setMaxPrice(self, price):
        self.__maxprice = price

c = Computer()
c.sell()

# change the price
c.__maxprice = 1000
c.sell()

# using setter function
c.setMaxPrice(1000)
c.sell()

Uitvoer

Selling Price: 900
Selling Price: 900
Selling Price: 1000

In het bovenstaande programma hebben we een Computer . gedefinieerd klasse.

We gebruikten __init__() methode om de maximale verkoopprijs van Computer . op te slaan . Hier, let op de code

c.__maxprice = 1000

Hier hebben we geprobeerd de waarde van __maxprice . te wijzigen buiten de klas. Echter, sinds __maxprice is een privévariabele, deze wijziging is niet zichtbaar in de uitvoer.

Zoals getoond, moeten we om de waarde te wijzigen een setterfunctie gebruiken, d.w.z. setMaxPrice() die prijs als parameter neemt.

Polymorfisme

Polymorfisme is een mogelijkheid (in OOP) om een ​​gemeenschappelijke interface te gebruiken voor meerdere vormen (gegevenstypen).

Stel dat we een vorm moeten kleuren, er zijn meerdere vormopties (rechthoek, vierkant, cirkel). We kunnen echter dezelfde methode gebruiken om elke vorm te kleuren. Dit concept wordt polymorfisme genoemd.

Voorbeeld 5:Polymorfisme gebruiken in Python

class Parrot:

    def fly(self):
        print("Parrot can fly")
    
    def swim(self):
        print("Parrot can't swim")

class Penguin:

    def fly(self):
        print("Penguin can't fly")
    
    def swim(self):
        print("Penguin can swim")

# common interface
def flying_test(bird):
    bird.fly()

#instantiate objects
blu = Parrot()
peggy = Penguin()

# passing the object
flying_test(blu)
flying_test(peggy)

Uitvoer

Parrot can fly
Penguin can't fly

In het bovenstaande programma hebben we twee klassen gedefinieerd Parrot en Pinguïn . Elk van hen heeft een gemeenschappelijke fly() methode. Hun functies zijn echter anders.

Om polymorfisme te gebruiken, hebben we een gemeenschappelijke interface gemaakt, namelijk flying_test() functie die een willekeurig object neemt en de fly() . van het object aanroept methode. Dus toen we de blu . passeerden en peggy objecten in de flying_test() functioneerde, werkte het effectief.

Belangrijkste punten om te onthouden:

• Objectgericht programmeren maakt het programma gemakkelijk te begrijpen en efficiënt.
• Omdat de klasse deelbaar is, kan de code opnieuw worden gebruikt.
• Gegevens zijn veilig en beveiligd met gegevensabstractie.
• Polymorfisme maakt dezelfde interface mogelijk voor verschillende objecten, zodat programmeurs efficiënte code kunnen schrijven.