Nachahmung von Klassen mit Funktionen

Dieses Kapitel ist ein Hybrid aus OOP und funktionaler Programmierung, so wie das folgende Bild ein Hybrid aus einem Auto und einer Python-Schlange ist. Daher haben wir uns entschieden, in diesem Kapitel nur eine kurze Einführung zu geben und den Großteil in "Funktionale Programmierung und OOP" zu behandeln.

A car with a snake trunk

Wenn wir an objektorientierte Programmierung denken, denken wir an Objekte und die dazugehörigen Methoden, wir denken an Datenkapselung, die es uns ermöglicht, Daten und Methoden zu bündeln, um sie vor äußeren Eingriffen und Manipulationen zu schützen. Das Konzept der Getter-Setter-Methoden, die einen kontrollierten Zugriff auf den internen Zustand eines Objekts ermöglichen. Durch die Definition dieser Accessors und Mutators schaffen wir eine standardisierte Schnittstelle, über die externer Code mit den Daten des Objekts interagieren kann, wodurch Integrität und Konsistenz gewährleistet werden.

Die funktionale Programmierung ahmt die OOP nach, indem sie lokale Variablen anstelle von privaten Attributen verwendet und verschachtelte Getter- und Setter-Funktionen definiert, um den Zugriff auf den inneren Zustand zu steuern. Reine Funktionen kapseln das Verhalten, während Funktionen höherer Ordnung die Komposition für die Modularität ermöglichen, wodurch ähnliche Ergebnisse wie bei OOP auf andere Weise erzielt werden.

Beispiel

In [1]:
def Robot(name, city):

    def self():
        return None
    
    def get_name():
        return name

    def set_name(new_name):
        nonlocal name
        name = new_name

    def get_city():
        return city
        
    def set_city(new_city):
        nonlocal city
        city = new_city

    self.get_name = get_name
    self.set_name = set_name
    self.get_city = get_city
    self.set_city = set_city

    return self

# Create robot objects
marvin = Robot("Marvin", "New York")
r2d2 = Robot("R2D2", "Tatooine")

print(marvin.get_name(), marvin.get_city())
marvin.set_name('Marvin 2.0')
print(marvin.get_name(), marvin.get_city())

print(r2d2.get_name(), r2d2.get_city())
r2d2.set_city('Naboo')
print(r2d2.get_name(), r2d2.get_city())

Marvin New York
Marvin 2.0 New York
R2D2 Tatooine
R2D2 Naboo

Wir haben absichtlich gegen eine grundlegende Python-Konvention verstoßen, indem wir einen Funktionsnamen groß geschrieben haben. Normalerweise sollten Funktionsnamen in Kleinbuchstaben geschrieben werden. Wir haben diesen Funktionsnamen jedoch absichtlich großgeschrieben, um seine Ähnlichkeit mit Klassen noch stärker zu betonen.

Das obige Beispiel entspricht dieser Klasse:

In [2]:
class Robot:
    def __init__(self, name, city):
        self._name = name
        self._city = city

    def get_name(self):
        return self._name

    def set_name(self, new_name):
        self._name = new_name

    def get_city(self):
        return self._city

    def set_city(self, new_city):
        self._city = new_city


# Create robot objects
marvin = Robot("Marvin", "New York")
r2d2 = Robot("R2D2", "Tatooine")

print(marvin.get_name(), marvin.get_city())
marvin.set_name('Marvin 2.0')
print(marvin.get_name(), marvin.get_city())

print(r2d2.get_name(), r2d2.get_city())
r2d2.set_city('Naboo')
print(r2d2.get_name(), r2d2.get_city())

Marvin New York
Marvin 2.0 New York
R2D2 Tatooine
R2D2 Naboo

Bitte fahren Sie jetzt fort mit "Funktionale Programmierung und OOP"

Wir wünschen Ihnen eine spannende und lohnende Fortsetzung Ihrer Reise mit unserem Python-Kurs!

Auto in der Abenddämmerung