Entdecken Sie [Python Object-Oriented] Programming: Detaillierte Erläuterung fortgeschrittener Programmierparadigmen im neuen era

Objektorientierte Programmierung (OOP) Ist ein Programmierparadigma, das durch die Organisation von Programmen in Objektsammlungen implementiert wird. Objekte enthalten nicht nur Daten, sondern auch Methoden zur Bearbeitung dieser Daten. Zu den Kernkonzepten von OOP gehören Klassen, Objekte, Eigenschaften und Methoden.

1.1 Was sind Klassen und Objekte?

Klasse Ist eine Vorlage oder Blaupause, die zum Erstellen von Objekten verwendet wird. Klassen definieren die Eigenschaften und das Verhalten von Objekten.
Objekt Ist eine Instanz der Klasse. Beim Erstellen eines Objekts wird eine bestimmte Instanz basierend auf der Klasse erstellt.

Beispiel:


class Dog:
    # 类的初始化方法
    def __init__(self, name, age):
        self.name = name  # 属性
        self.age = age    # 属性
 
    # 方法
    def bark(self):
        return f"{self.name} says Woof!"
 
# 创建对象
my_dog = Dog("Rex", 5)
print(my_dog.bark())

1.2 Klassendefinition

In Python werden Klassen übergeben class Schlüsselwortdefinition. Funktionen in einer Klasse werden Methoden und Variablen Eigenschaften genannt.Klassenmethoden beginnen normalerweise mitself Stellt als erster Parameter die Instanz selbst dar.

Beispiel:


class Cat:
    def __init__(self, name):
        self.name = name
 
    def meow(self):
        return f"{self.name} says Meow!"
 
# 创建对象
my_cat = Cat("Whiskers")
print(my_cat.meow())

1.3 Beziehung zwischen Klassen und Objekten

Eine Klasse ist eine Vorlage für ein Objekt und definiert die Struktur und das Verhalten des Objekts. Objekte sind Instanzen von Klassen und jedes Objekt verfügt über unabhängige Eigenschaften und Methoden.


class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."
 
# 创建多个对象
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)
 
print(person1.greet())
print(person2.greet())

1.4 Xiao Lis Verständnis

Eine Klasse ist wie eine Keksform, sie definiert die Form und Größe des Kekses. Objekte sind wie konkrete Kekse, die aus einer Form hergestellt werden. Jeder Keks kann unterschiedliche Geschmacksrichtungen (Eigenschaften) haben, aber seine Form und Größe (Struktur und Verhalten) sind gleich.

2. Abstraktion

abstrakt Es bezieht sich auf die Vereinfachung komplexer Probleme der realen Welt, indem die Hauptmerkmale erfasst und die Details ignoriert werden. Beim Programmieren hilft uns die Abstraktion dabei, prägnanteren und wartbareren Code zu erstellen.

2.1 Abstrakte Konzepte

Bei der Abstraktion geht es darum, die Hauptmerkmale eines Objekts zu extrahieren und dabei unwichtige Details zu ignorieren. Durch Abstraktion können wir uns auf die Kernfunktionalität eines Objekts konzentrieren, ohne von sekundären Merkmalen abgelenkt zu werden.

Beispiel:


class Animal:
    def __init__(self, name):
        self.name = name
 
    def make_sound(self):
        pass  # 抽象方法，不具体实现
 
class Dog(Animal):
    def make_sound(self):
        return "Woof!"
 
class Cat(Animal):
    def make_sound(self):
        return "Meow!"
 
# 创建对象
dog = Dog("Rex")
cat = Cat("Whiskers")
 
print(dog.make_sound())
print(cat.make_sound())

2.2 Abstrakte Klassen und Methoden

In Python können wir Abstraktion erreichen, indem wir abstrakte Klassen und abstrakte Methoden definieren. Abstrakte Klassen können nicht instanziiert, sondern nur geerbt werden. Abstrakte Methoden werden in der abstrakten Klasse definiert, aber in Unterklassen implementiert.

Beispiel:


from abc import ABC, abstractmethod
 
class Vehicle(ABC):
    @abstractmethod
    def start_engine(self):
        pass
 
class Car(Vehicle):
    def start_engine(self):
        return "Car engine started"
 
class Motorcycle(Vehicle):
    def start_engine(self):
        return "Motorcycle engine started"
 
# 创建对象
car = Car()
motorcycle = Motorcycle()
 
print(car.start_engine())
print(motorcycle.start_engine())

2.3 Xiao Lis Verständnis

Abstraktion ist wie die Reduzierung eines komplexen Gemäldes auf geometrische Formen. Beispielsweise hat eine bestimmte Katze viele Eigenschaften (Fellfarbe, Größe, Alter usw.), aber wir konzentrieren uns nur auf die Eigenschaft des Miauens. Dies ist die Abstraktion der Katze.

3. Klassen und Instanzen

Klassen und Instanzen Es ist die Grundlage von OOP. Klassen sind Vorlagen und Instanzen sind konkrete Objekte. Instanzen werden aus einer Klasse erstellt und verfügen über die von der Klasse definierten Eigenschaften und Methoden.

3.1 Klassendefinition und Instanziierung

Das Definieren einer Klasse und das Erstellen einer Instanz sind die Grundoperationen von OOP. Klassen definieren Eigenschaften und Methoden und Instanzen sind konkrete Objekte der Klasse.

Beispiel:


class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
 
    def introduce(self):
        return f"Hi, I am {self.name} and I am in grade {self.grade}."
 
# 创建实例
student1 = Student("Alice", 10)
student2 = Student("Bob", 12)
 
print(student1.introduce())
print(student2.introduce())

3.2 Klassenattribute und -methoden

Die Attribute einer Klasse sind der Zustand des Objekts und die Methoden sind das Verhalten des Objekts.Klassenattribute bestehen__init__ Methodeninitialisierung, die Methode wird in der Klasse definiert.

Beispiel:


class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
 
    def get_info(self):
        return f"'{self.title}' by {self.author}"
 
# 创建实例
book = Book("1984", "George Orwell")
print(book.get_info())

3.3 Xiao Lis Verständnis

Klassen und Instanzen sind wie eine Zeichnung eines Hauses und eines tatsächlichen Hauses. Die Zeichnungen (Klassen) definieren die Struktur und Funktionalität des Hauses, während das eigentliche Haus (Instanz) das nach den Zeichnungen gebaute konkrete Objekt ist.

4. Kapselung/Schnittstelle

Verkapselung Es verbirgt den Status (Eigenschaften) und das Verhalten (Methoden) des Objekts innerhalb der Klasse und interagiert über die Schnittstelle (Methoden) mit der Außenwelt. Die Kapselung verbessert die Sicherheit und Wartbarkeit des Codes.

4.1 Konzept der Kapselung

Die Kapselung ist eines der Kernkonzepte von OOP. Sie schützt die Daten des Objekts, indem sie den internen Zustand des Objekts verbirgt und nur die notwendigen Schnittstellen offenlegt. Auf diese Weise kann externer Code nicht direkt auf den internen Status des Objekts zugreifen oder ihn ändern, sondern kann Daten nur über die vom Objekt bereitgestellten Methoden manipulieren.

Beispiel:


class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有属性
 
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            raise ValueError("Deposit amount must be positive")
 
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            raise ValueError("Insufficient funds or invalid amount")
 
    def get_balance(self):
        return self.__balance
 
# 创建实例
account = Account("John")
account.deposit(100)
print(account.get_balance())

4.2 Schnittstellenkonzept

Eine Schnittstelle ist die einzige Möglichkeit, wie ein Objekt mit der Außenwelt interagiert. Über Schnittstellen kann externer Code die Methoden des Objekts aufrufen, aber nicht direkt auf den internen Zustand des Objekts zugreifen.

Beispiel:


class Car:
    def __init__(self, model):
        self.model = model
        self.__engine_started = False
 
    def start_engine(self):
        if not self.__engine_started:
            self.__engine_started = True
            return "Engine started"
        else:
            return "Engine is already running"
 
    def stop_engine(self):
        if self.__engine_started:
            self.__engine_started = False
            return "Engine stopped"
        else:
            return "Engine is not running"
 
# 创建实例
car = Car("Toyota")
print(car.start_engine())
print(car.stop_engine())

4.3 Xiao Lis Verständnis

Die Verpackung ähnelt der Hülle eines Mobiltelefons. Die Schaltkreise und Komponenten (Zustand des Objekts) im Inneren des Mobiltelefons sind im Gehäuse gekapselt. Der Benutzer kann nur über die Tasten und den Bildschirm (Schnittstelle) mit dem Mobiltelefon interagieren, aber keinen direkten Kontakt zu den internen Komponenten herstellen.

5. Vererbung

erben Ist ein weiteres Kernkonzept von OOP, das es uns ermöglicht, eine neue Klasse basierend auf einer vorhandenen Klasse zu erstellen. Die neue Klasse erbt alle Eigenschaften und Methoden der vorhandenen Klasse.

5.1 Das Konzept der Vererbung

Von Vererbung spricht man, wenn eine Klasse (Unterklasse) Eigenschaften und Methoden von einer anderen Klasse (Elternklasse) erhält. Durch Vererbung können Unterklassen den Code der übergeordneten Klasse wiederverwenden, neue Eigenschaften und Methoden hinzufügen oder die Methoden der übergeordneten Klasse überschreiben.

Beispiel:


class Animal:
    def __init__(self, name):
        self.name = name
 
    def speak(self):
        pass
 
class Dog(Animal):
    def speak(self):
        return "Woof!"
 
class Cat(Animal):
    def speak(self):
        return "Meow!"
 
# 创建实例
dog = Dog("Rex")
cat = Cat("Whiskers")
 
print(dog.speak())
print(cat.speak())

5.2 Umschreiben der Methode

Eine Unterklasse kann die Methode der übergeordneten Klasse überschreiben, dh eine Methode mit demselben Namen wie die übergeordnete Klasse in der Unterklasse definieren, um unterschiedliche Funktionen zu erreichen.

Beispiel:


class Shape:
    def area(self):
        return 0
 
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
 
    def area(self):
        return self.width * self.height
 
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
 
    def area(self):
        return 3.14 * (self.radius ** 2)
 
# 创建实例
rectangle = Rectangle(3, 4)
circle = Circle(5)
 
print(rectangle.area())
print(circle.area())

5.3 Xiao Lis Verständnis

Eine Vererbung ist wie ein Vermächtnis, das Eltern ihren Kindern hinterlassen. Eltern (übergeordnete Klassen) geben ihre Eigenschaften (Eigenschaften und Methoden) an ihre untergeordneten Klassen (Unterklassen) weiter, und die untergeordneten Klassen können diese Eigenschaften nicht nur verwenden, sondern auch durch eigene Bemühungen (Hinzufügen neuer Eigenschaften und Methoden) reicher werden.

6. Polymorphismus

Polymorphismus Dies bedeutet, dass dieselbe Methode auf verschiedenen Objekten unterschiedliche Ausprägungen hat. Polymorphismus ermöglicht es uns, Methoden verschiedener Objekte über dieselbe Schnittstelle aufzurufen, um unterschiedliche Funktionen zu erreichen.

6.1 Das Konzept des Polymorphismus

Polymorphismus ist eines der wichtigen Merkmale von OOP. Er verweist auf Unterklassenobjekte durch Referenzen auf übergeordnete Klassen, sodass dieselbe Methode unterschiedliche Implementierungen haben kann. Polymorphismus erhöht die Flexibilität und Skalierbarkeit des Codes.

Beispiel:


class Animal:
    def speak(self):
        pass
 
class Dog(Animal):
    def speak(self):
        return "Woof!"
 
class Cat(Animal):
    def speak(self):
        return "Meow!"
 
def animal_sound(animal):
    print(animal.speak())
 
# 创建实例
dog = Dog()
cat = Cat()
 
animal_sound(dog)
animal_sound(cat)

6.2 Implementieren Sie Polymorphismus

In Python wird Polymorphismus normalerweise durch Methodenüberschreibung und Verweise auf übergeordnete Klassen implementiert. Indem Sie über die übergeordnete Klassenreferenz auf das Unterklassenobjekt verweisen, können Sie die Unterklassenmethode aufrufen.

Beispiel:


class Shape:
    def draw(self):
        pass
 
class Rectangle(Shape):
    def draw(self):
        return "Drawing a rectangle"
 
class Circle(Shape):
    def draw(self):
        return "Drawing a circle"
 
def draw_shape(shape):
    print(shape.draw())
 
# 创建实例
rectangle = Rectangle()
circle = Circle()
 
draw_shape(rectangle)
draw_shape(circle)

6.3 Xiao Lis Verständnis

Polymorphismus ist wie eine universelle Fernbedienung. Ob es sich um die Steuerung eines Fernsehers, einer Klimaanlage oder einer Stereoanlage handelt, solange diese Geräte über entsprechende Schnittstellen (Methoden) verfügen, kann die Fernbedienung (Referenz der übergeordneten Klasse) verschiedene Funktionen über dieselben Tasten (Methodenaufrufe) implementieren.

7. Selbstbeobachtung/Reflexion

Selbstbeobachtung Dies bedeutet, dass das Objekt zur Laufzeit seine eigenen Informationen kennen kann. Python bietet einige integrierte Funktionen zur Selbstbeobachtung, ztype()、id()、hasattr() Warten.

7.1 Das Konzept der Selbstbeobachtung

Selbstbeobachtung bedeutet, dass ein Objekt zur Laufzeit seine eigenen Informationen wie Eigenschaften, Methoden usw. erhalten kann. Introspektion macht Python-Programme äußerst dynamisch und flexibel.

Beispiel:


class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
person = Person("Alice", 30)
 
# 使用内置函数进行自省
print(type(person))
print(hasattr(person, "name"))
print(getattr(person, "name"))
setattr(person, "name", "Bob")
print(person.name)
delattr(person, "name")

7.2 Verwendung der Introspektion für dynamische Operationen

Durch Selbstbeobachtung können wir die Eigenschaften und Methoden von Objekten zur Laufzeit dynamisch manipulieren und so das Programm flexibler und dynamischer machen.

Beispiel:


class Car:
    def __init__(self, model):
        self.model = model
        self.speed = 0
 
    def accelerate(self):
        self.speed += 5
        return self.speed
 
car = Car("Toyota")
 
# 动态操作对象
if hasattr(car, "accelerate"):
    method = getattr(car, "accelerate")
    print(method())
    print(method())
 
# 动态设置属性
setattr(car, "color", "red")
print(car.color)

7.3 Xiao Lis Verständnis

Selbstprüfung ist wie ein Blick in den Spiegel. Durch den Spiegel (Introspektionsmechanismus) können Menschen sehen, wie sie aussehen (Eigenschaften und Methoden von Objekten) und bei Bedarf Anpassungen vornehmen (dynamische Manipulation von Objekten).

8. Statische Methoden und Klassenmethoden

statische Methode UndKlassenmethode sind Methoden, die der Klasse zugeordnet sind, nicht der Instanz.Verwendung statischer Methoden@staticmethod Dekorateur, Verwendung von Klassenmethoden@classmethod Dekorateur.

8.1 Statische Methoden

Eine statische Methode ist eine Methode einer Klasse, aber sie ist an keine Klasseninstanz gebunden. Statische Methoden können weder auf Instanzen einer Klasse zugreifen noch den Status der Klasse ändern. Sie werden normalerweise verwendet, um eine Operation auszuführen, die nichts mit der Klasse zu tun hat, aber logischerweise zur Funktionalität der Klasse gehört.

Beispiel:


class Math:
    @staticmethod
    def add(a, b):
        return a + b
 
print(Math.add(5, 3))

8.2 Klassenmethoden

Klassenmethoden sind Methoden, die an die Klasse und nicht an die Instanz gebunden sind.Das erste Argument einer Klassenmethode ist die Klasse selbst, normalerweise benanntcls . Klassenmethoden können auf die Eigenschaften der Klasse und anderer Klassenmethoden zugreifen.

Beispiel:


class Math:
    factor = 2
 
    @classmethod
    def multiply(cls, value):
        return cls.factor * value
 
print(Math.multiply(5))

Zusammenfassen

Alle Aspekte der objektorientierten Programmierung in Python, einschließlich grundlegender Konzepte der objektorientierten Programmierung, Abstraktionen, Klassen und Instanzen, Kapselung, Vererbung, Polymorphismus, Selbstbeobachtung sowie statische und Klassenmethoden.

Ich hoffe, dass dieser ausführliche Blog Ihnen dabei helfen kann, die objektorientierte Programmierung in Python tiefgreifend zu verstehen und dieses Wissen in tatsächlichen Projekten anzuwenden. Wenn Sie Fragen haben oder weitere Hilfe benötigen, können Sie mich gerne kontaktieren!

Technologieaustausch

Entdecken Sie [Python Object-Oriented] Programming: Detaillierte Erklärung fortgeschrittener Programmierparadigmen in der neuen Ära

1. Objektorientierte Programmierkonzepte (OOP)

1.1 Was sind Klassen und Objekte?

1.2 Klassendefinition

1.3 Beziehung zwischen Klassen und Objekten

1.4 Xiao Lis Verständnis

2. Abstraktion

2.1 Abstrakte Konzepte

2.2 Abstrakte Klassen und Methoden

2.3 Xiao Lis Verständnis

3. Klassen und Instanzen

3.1 Klassendefinition und Instanziierung

3.2 Klassenattribute und -methoden

3.3 Xiao Lis Verständnis

4. Kapselung/Schnittstelle

4.1 Konzept der Kapselung

4.2 Schnittstellenkonzept

4.3 Xiao Lis Verständnis

5. Vererbung

5.1 Das Konzept der Vererbung

5.2 Umschreiben der Methode

5.3 Xiao Lis Verständnis

6. Polymorphismus

6.1 Das Konzept des Polymorphismus

6.2 Implementieren Sie Polymorphismus

6.3 Xiao Lis Verständnis

7. Selbstbeobachtung/Reflexion

7.1 Das Konzept der Selbstbeobachtung

7.2 Verwendung der Introspektion für dynamische Operationen

7.3 Xiao Lis Verständnis

8. Statische Methoden und Klassenmethoden

8.1 Statische Methoden

8.2 Klassenmethoden

Zusammenfassen

Persönliches Profil

meine Kontaktdaten