Comment accéder aux propriétés de la classe parent en Python ?

En programmation orientée objet, l'héritage nous permet de créer de nouvelles classes qui héritent des propriétés et des méthodes d'une classe existante. Ce concept puissant permet la réutilisation du code, la modularité et l'extensibilité de nos programmes. Avant de plonger dans l'accès aux attributs de classe parent, faisons un petit rappel sur l'héritage. En Python, lorsqu'une classe hérite d'une autre classe, elle acquiert tous les attributs et méthodes définis dans la classe parent. Ce mécanisme nous permet de créer des classes spécialisées qui héritent et étendent les fonctionnalités d'une classe de base plus générale. La classe dérivée est également connue sous le nom de classe enfant, tandis que la classe dont on hérite est appelée classe parent ou classe de base.

Exemple

这里有一个简单的示例来说明继承的概念 -

class Parent:
   def __init__(self):
      self.parent_attribute = "I'm from the parent class"

class Child(Parent):
   def __init__(self):
      super().__init__()
      self.child_attribute = "I'm from the child class"

child = Child()
print(child.parent_attribute)  # Accessing parent class attribute
print(child.child_attribute)

Sortie

I'm from the parent class
I'm from the child class

Dans cet exemple, nous avons deux classes : Parent et Enfant. La classe Child hérite de la classe Parent en utilisant la classe de syntaxe Child(Parent). Cela signifie que la classe Child hérite de tous les attributs et méthodes définis dans la classe Parent. La classe Child possède également son propre attribut appelé child_attribute.

访问父类属性

Pour accéder à un attribut de classe parent en Python, vous pouvez utiliser la notation par points avec le nom de l'instance ou de la classe. L’approche que vous choisissez dépend du contexte et de vos besoins spécifiques. Explorons les différentes méthodes pour accéder aux attributs de la classe parent :

Utilisation de l'instance

如果您有子类的实例，您可以通过实例直接访问父类的属性。实例保留了从父类继承的所有属性和方法，使您能够轻松访问它们。

Exemple

这是一个示例 −

class Parent:
   def __init__(self):
      self.parent_attribute = "I'm from the parent class"

class Child(Parent):
   def __init__(self):
      super().__init__()
      self.child_attribute = "I'm from the child class"

child = Child()
print(child.parent_attribute)  # Accessing parent class attribute using instance

Sortie

I'm from the parent class

Dans cet exemple, child.parent_attribute accède au parent_attribute défini dans la classe parent. En accédant à l'attribut via l'instance, vous pouvez récupérer la valeur associée à cet attribut.

Utilisation du nom de classe

En plus d'accéder aux attributs de la classe parent via une instance, vous pouvez également y accéder en utilisant le nom de la classe enfant. Cette approche est utile lorsque vous n'avez pas d'instance disponible, mais que vous souhaitez quand même accéder directement à l'attribut de classe parent.

Exemple

这是一个示例 −

class Parent:
   parent_attribute = "I'm from the parent class"

class Child(Parent):
   child_attribute = "I'm from the child class"

print(Child.parent_attribute)  # Accessing parent class attribute using class name

Sortie

I'm from the parent class

Dans ce cas, Child.parent_attribute accède au parent_attribute défini dans la classe parent. En utilisant le nom de la classe, vous pouvez accéder directement à l'attribut de la classe parent sans avoir besoin d'une instance.

Accès aux méthodes de classe parentale

继承不仅允许我们访问父类的属性，还允许我们访问父类的方法.承时，它继承了父类中定义的所有方法。这意味着你可以在子类中使用实例或类名调用这些方法。

Exemple

这是一个示例 −

class Parent:
   def parent_method(self):
      print("This is a method from the parent class")

class Child(Parent):
   def __init__(self):
      super().__init__()

child = Child()
child.parent_method()  # Accessing parent class method using instance
Child.parent_method()  # Accessing parent class method using class name

Sortie

This is a method from the parent class
This is a method from the parent class

Dans cet exemple, la classe Child hérite de la méthode parent_method de la classe Parent. Nous pouvons invoquer cette méthode en utilisant une instance de la classe Child (child.parent_method()) ou directement en utilisant le nom de la classe (Child.parent_method()).

覆盖父类属性

Dans certains cas, vous devrez peut-être remplacer un attribut de classe parent dans la classe enfant. Remplacer signifie fournir une valeur ou un comportement différent pour un attribut spécifique dans la classe enfant. En redéfinissant l'attribut dans la classe enfant, vous pouvez personnaliser sa valeur tout en ayant toujours accès à l'attribut de la classe parent en utilisant les techniques évoquées précédemment.

Exemple

这是一个示例 −

class Parent:
   def __init__(self):
      self.shared_attribute = "I'm from the parent class"

class Child(Parent):
   def __init__(self):
      super().__init__()
      self.shared_attribute = "I'm from the child class"

child = Child()
print(child.shared_attribute)  # Accessing overridden attribute

Sortie

I'm from the child class

Dans cet exemple, les classes Parent et Child ont un attribut appelé shared_attribute. Cependant, dans la classe enfant, nous redéfinissons l'attribut avec une valeur différente. Lorsque nous accédons à l'attribut à l'aide d'une instance de la classe enfant (child.shared_attribute), nous récupérons la valeur remplacée définie dans la classe enfant.

多重继承

Python 支持多继承，这意味着一个类可以继承多个父类。在使用多继承时，访问父类属性可能会变得更加复杂。在这种情况下，您可能需要使用方法解析顺序（MRO ）或super()函数来明确指定要访问的父类属性。

Example

这是一个多继承和访问父类属性的示例 −

class Parent1:
   def __init__(self):
      self.shared_attribute = "I'm from Parent1"

class Parent2:
   def __init__(self):
      self.shared_attribute = "I'm from Parent2"

class Child(Parent1, Parent2):
   def __init__(self):
      super().__init__()

child = Child()
print(child.shared_attribute)  # Accessing parent class attribute in multiple inheritance

Output

I'm from Parent1

In this example, the Child class inherits from both Parent1 and Parent2 classes. When we create an instance of the Child class and access the shared_attribute, it retrieves the value defined in Parent1.

受保护和私有属性

受保护的属性通常以单下划线（_）作为前缀，表示它们不应该在类外部直接访问，但仍然可以被子类访问。另一方面，私有属性通常以双下划线（__）作为前缀，表示它们只能在类内部访问。

示例

这是一个示例 −

class Parent:
   def __init__(self):
      self._protected_attribute = "I'm a protected attribute"
      self.__private_attribute = "I'm a private attribute"

class Child(Parent):
   def __init__(self):
      super().__init__()

child = Child()
print(child._protected_attribute)   # Accessing protected attribute
print(child._Parent__private_attribute)   # Accessing private attribute

Output

I'm a protected attribute
I'm a private attribute

在这个例子中，父类有一个受保护的属性_protected_attribute和一个私有属性__private_attribute。子类Child仍然可以访问这两个属性。然而，访问私有属性需要使用名称混淆技术，格式为_ClassName__private_attribute。

Conclusion

继承是一种强大的功能，它允许我们创建类层次结构并在现有功能的基础上构建。通过访问父类属性，我们可以在程序中实现代码重用和模块化。

我们学到了可以使用实例或类名来访问父类属性。通过实际示例，我们看到了如何使用子类的实例访问父类属性，以及如何直接使用类名访问它们。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!