Explorez la programmation [orientée objet Python] : explication détaillée des paradigmes de programmation avancés dans la nouvelle ère

Programmation orientée objet (POO) Est un paradigme de programmation mis en œuvre en organisant les programmes en collections d'objets. Les objets contiennent non seulement des données mais également des méthodes permettant de manipuler ces données. Les concepts de base de la POO incluent les classes, les objets, les propriétés et les méthodes.

1.1 Que sont les classes et les objets ?

Classe Est un modèle ou un plan utilisé pour créer des objets. Les classes définissent les propriétés et le comportement des objets.
Objet Est une instance de la classe. Créer un objet consiste à créer une instance spécifique basée sur la classe.

exemple:


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 Définition de la classe

En Python, les cours réussissent class Définition des mots-clés. Les fonctions d’une classe sont appelées méthodes et les variables sont appelées propriétés.Les méthodes de classe commencent généralement parself En tant que premier paramètre, représente l'instance elle-même.

exemple:


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 Relation entre classes et objets

Une classe est un modèle pour un objet et définit la structure et le comportement de l'objet. Les objets sont des instances de classes et chaque objet possède des propriétés et des méthodes indépendantes.


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 Compréhension de Xiao Li

Une classe est comme un moule à cookie, elle définit la forme et la taille du cookie. Les objets sont comme des biscuits en béton fabriqués à partir d'un moule. Chaque biscuit peut avoir des saveurs (propriétés) différentes, mais leur forme et leur taille (structure et comportement) sont les mêmes.

2. Abstraction

abstrait Il fait référence à la simplification de problèmes complexes du monde réel en saisissant les principales caractéristiques et en ignorant les détails. En programmation, l'abstraction nous aide à créer un code plus concis et maintenable.

2.1 Concepts abstraits

L'abstraction consiste à extraire les principales caractéristiques d'un objet tout en ignorant les détails sans importance. Grâce à l'abstraction, nous pouvons nous concentrer sur la fonctionnalité principale d'un objet sans être distrait par les fonctionnalités secondaires.

exemple:


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 Classes et méthodes abstraites

En Python, nous pouvons réaliser l'abstraction en définissant des classes abstraites et des méthodes abstraites. Les classes abstraites ne peuvent pas être instanciées, seulement héritées. Les méthodes abstraites sont définies dans la classe abstraite mais implémentées dans des sous-classes.

exemple:


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 Compréhension de Xiao Li

L'abstraction, c'est comme réduire un tableau complexe à des formes géométriques. Par exemple, un chat spécifique possède de nombreuses caractéristiques (couleur du pelage, taille, âge, etc.), mais nous nous concentrons uniquement sur la caractéristique du miaulement. C'est l'abstraction du chat.

3. Classes et instances

Classes et instances C'est la base de la POO. Les classes sont des modèles et les instances sont des objets concrets. Les instances sont créées à partir d'une classe et possèdent les propriétés et méthodes définies par la classe.

3.1 Définition et instanciation de classe

Définir une classe et créer une instance sont les opérations de base de la POO. Les classes définissent des propriétés et des méthodes, et les instances sont des objets concrets de la classe.

exemple:


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 Attributs et méthodes de classe

Les attributs d'une classe sont l'état de l'objet et les méthodes sont le comportement de l'objet.Les attributs de classe réussissent__init__ Initialisation de la méthode, la méthode est définie dans la classe.

exemple:


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 Compréhension de Xiao Li

Les classes et les instances sont comme un dessin d’une maison et d’une maison réelle. Les dessins (classes) définissent la structure et la fonctionnalité de la maison, tandis que la maison réelle (instance) est l'objet concret construit selon les dessins.

4. Encapsulation/Interface

encapsulation Il masque le statut (propriétés) et le comportement (méthodes) de l'objet à l'intérieur de la classe et interagit avec le monde extérieur via l'interface (méthodes). L'encapsulation améliore la sécurité et la maintenabilité du code.

4.1 Notion d'encapsulation

L'encapsulation est l'un des concepts fondamentaux de la POO. Elle protège les données de l'objet en masquant l'état interne de l'objet et en exposant uniquement les interfaces nécessaires. De cette manière, le code externe ne peut pas accéder ou modifier directement l'état interne de l'objet et ne peut manipuler les données que via les méthodes fournies par l'objet.

exemple:


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 Notion d'interface

Une interface est le seul moyen par lequel un objet interagit avec le monde extérieur. Grâce aux interfaces, le code externe peut appeler les méthodes de l'objet mais ne peut pas accéder directement à l'état interne de l'objet.

exemple:


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 Compréhension de Xiao Li

L'emballage est comme le boîtier d'un téléphone portable. Les circuits et composants (état de l'objet) à l'intérieur du téléphone mobile sont encapsulés dans le boîtier. L'utilisateur ne peut interagir avec le téléphone mobile que via les boutons et l'écran (interface), mais ne peut pas contacter directement les composants internes.

5. Héritage

hériter Est un autre concept central de la POO, qui nous permet de créer une nouvelle classe basée sur une classe existante. La nouvelle classe hérite de toutes les propriétés et méthodes de la classe existante.

5.1 La notion d'héritage

L'héritage se produit lorsqu'une classe (sous-classe) obtient des propriétés et des méthodes d'une autre classe (classe parent). Grâce à l'héritage, les sous-classes peuvent réutiliser le code de la classe parent, ajouter de nouvelles propriétés et méthodes ou remplacer les méthodes de la classe parent.

exemple:


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 Réécriture de méthode

Une sous-classe peut remplacer la méthode de la classe parent, c'est-à-dire définir une méthode portant le même nom que la classe parent dans la sous-classe pour réaliser différentes fonctions.

exemple:


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 Compréhension de Xiao Li

L'héritage est comme un héritage donné par les parents à leurs enfants. Les parents (classe parent) transmettent leurs propriétés (propriétés et méthodes) à leurs enfants (sous-classes), et les enfants peuvent non seulement utiliser ces propriétés, mais aussi s'enrichir grâce à leurs propres efforts (en ajoutant de nouvelles propriétés et méthodes).

6. Polymorphisme

Polymorphisme Cela signifie que la même méthode a des manifestations différentes sur différents objets. Le polymorphisme nous permet d'appeler des méthodes de différents objets via la même interface pour réaliser différentes fonctions.

6.1 La notion de polymorphisme

Le polymorphisme est l'une des fonctionnalités importantes de la POO. Il pointe vers des objets de sous-classe via des références de classe parent, permettant à la même méthode d'avoir différentes implémentations. Le polymorphisme augmente la flexibilité et l'évolutivité du code.

exemple:


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 Implémenter le polymorphisme

En Python, le polymorphisme est généralement implémenté via le remplacement de méthode et les références à la classe parent. En pointant vers l'objet de sous-classe via la référence de classe parent, vous pouvez appeler la méthode de sous-classe.

exemple:


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 Compréhension de Xiao Li

Le polymorphisme est comme une télécommande universelle. Qu'il s'agisse de contrôler un téléviseur, un climatiseur ou une chaîne stéréo, tant que ces appareils disposent d'interfaces (méthodes) correspondantes, la télécommande (référence de classe parent) peut mettre en œuvre différentes fonctions via les mêmes boutons (appels de méthode).

7. Introspection/Réflexion

introspection Cela signifie que l'objet peut connaître ses propres informations au moment de l'exécution. Python fournit des fonctions intégrées pour l'introspection, telles quetype()、id()、hasattr() attendez.

7.1 Le concept d'introspection

L'introspection signifie qu'un objet peut obtenir ses propres informations au moment de l'exécution, telles que des propriétés, des méthodes, etc. L'introspection rend les programmes Python très dynamiques et flexibles.

exemple:


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 Utiliser l'introspection pour les opérations dynamiques

Grâce à l'introspection, nous pouvons manipuler dynamiquement les propriétés et les méthodes des objets au moment de l'exécution, rendant le programme plus flexible et dynamique.

exemple:


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 Compréhension de Xiao Li

L’auto-examen, c’est comme se regarder dans le miroir. Grâce au miroir (mécanisme d'introspection), les gens peuvent voir à quoi ils ressemblent (propriétés et méthodes des objets) et effectuer les ajustements nécessaires (manipulation dynamique des objets).

8. Méthodes statiques et méthodes de classe

méthode statique etméthode de classe sont des méthodes associées à la classe, pas à l'instance.Utilisation de la méthode statique@staticmethod Décorateur, utilisation de la méthode de classe@classmethod Décorateur.

8.1 Méthodes statiques

Une méthode statique est une méthode d’une classe, mais elle n’est liée à aucune instance de classe. Les méthodes statiques ne peuvent pas accéder aux instances d’une classe ni modifier l’état de la classe. Ils sont généralement utilisés pour effectuer une opération qui n'a rien à voir avec la classe, mais qui appartient logiquement à la fonctionnalité de la classe.

exemple:


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

8.2 Méthodes de classe

Les méthodes de classe sont des méthodes liées à la classe plutôt qu'à l'instance.Le premier argument d'une méthode de classe est la classe elle-même, généralement nomméecls . Les méthodes de classe peuvent accéder aux propriétés de la classe et à d’autres méthodes de classe.

exemple:


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

Résumer

Tous les aspects de la programmation orientée objet en Python, y compris les concepts de base de la programmation orientée objet, les abstractions, les classes et instances, l'encapsulation, l'héritage, le polymorphisme, l'introspection et les méthodes statiques et de classe.

J'espère que ce blog détaillé pourra vous aider à comprendre en profondeur la programmation orientée objet en Python et à appliquer ces connaissances dans des projets réels. Si vous avez des questions ou avez besoin d'aide supplémentaire, n'hésitez pas à me contacter !

Partage de technologie