In object-oriented programming, inheritance allows us to create new classes that inherit the properties and methods of an existing class. This powerful concept enables code reuse, modularity, and extensibility in our programs. Before diving into accessing parent class attributes, let's have a quick refresher on inheritance. In Python, when a class inherits from another class, it acquires all the attributes and methods defined in the parent class. This mechanism allows us to create specialized classes that inherit and extend the functionality of a more general base class. The derived class is also known as a child class, while the class being inherited from is called the parent class or base class.
Example
这里有一个简单的示例来说明继承的概念 -
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)
Output
I'm from the parent class I'm from the child class
In this example, we have two classes: Parent and Child. The Child class inherits from the Parent class using the syntax class Child(Parent). This means that the Child class inherits all the attributes and methods defined in the Parent class. The Child class also has its own attribute called child_attribute.
访问父类属性
To access a parent class attribute in Python, you can use the dot notation along with the instance or class name. The approach you choose depends on the context and your specific requirements. Let's explore the different methods to access parent class attributes:
立即学习“Python免费学习笔记（深入）”；
Using the Instance
如果您有子类的实例，您可以通过实例直接访问父类的属性。实例保留了从父类继承的所有属性和方法，使您能够轻松访问它们。
Example
这是一个示例 −
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
Output
I'm from the parent class
In this example, child.parent_attribute accesses the parent_attribute defined in the parent class. By accessing the attribute through the instance, you can retrieve the value associated with that attribute.
Using the Class Name
In addition to accessing parent class attributes through an instance, you can also access them using the child class name. This approach is useful when you don't have an instance available, but you still want to access the parent class attribute directly.
Example
这是一个示例 −
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
Output
I'm from the parent class
In this case, Child.parent_attribute accesses the parent_attribute defined in the parent class. By using the class name, you can directly access the parent class attribute without the need for an instance.
Accessing Parent Class Methods
继承不仅允许我们访问父类的属性，还允许我们访问父类的方法。当一个子类从一个父类继承时，它继承了父类中定义的所有方法。这意味着你可以在子类中使用实例或类名调用这些方法。
Example
这是一个示例 −
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
Output
This is a method from the parent class This is a method from the parent class
In this example, the Child class inherits the parent_method from the Parent class. We can invoke this method using an instance of the Child class (child.parent_method()) or directly using the class name (Child.parent_method()).
覆盖父类属性
In some cases, you may need to override a parent class attribute in the child class. Overriding means providing a different value or behavior for a specific attribute in the child class. By redefining the attribute in the child class, you can customize its value while still having access to the parent class attribute using the techniques discussed earlier.
Example
这是一个示例 −
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
Output
I'm from the child class
In this example, both the Parent and Child classes have an attribute called shared_attribute. However, in the child class, we redefine the attribute with a different value. When we access the attribute using an instance of the child class (child.shared_attribute), we retrieve the overridden value defined in the child class.
多重继承
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
继承是一种强大的功能，它允许我们创建类层次结构并在现有功能的基础上构建。通过访问父类属性，我们可以在程序中实现代码重用和模块化。
我们学到了可以使用实例或类名来访问父类属性。通过实际示例，我们看到了如何使用子类的实例访问父类属性，以及如何直接使用类名访问它们。
