python3 怎么访问父类私有对象

Python 中并没有真正意义上的私有对象，只有私有方法和私有属性。

要访问父类的私有属性或方法，需要在父类中定义相应的公有方法或属性来访问私有属性或方法，然后在子类中通过调用父类的公有方法或属性来间接访问父类的私有属性或方法。

举个例子：

class Parent:
    def __init__(self):
        self.__private = 'private'
    
    def get_private(self):
        return self.__private

class Child(Parent):
    def get_private_from_parent(self):
        return super().get_private()

child = Child()
print(child.get_private_from_parent())  # 输出 'private'

但是需要注意，私有属性和方法实际上可以被子类访问到，但是这样的访问是不被推荐的。因为私有属性和方法的意图是为了防止它们被直接调用和修改，而是应该通过类的公有方法来间接操作它们。如果子类直接访问父类的私有属性和方法，可能会破坏父类的封装性，导致父类的行为发生意外的变化。

相关问题

编写python代码1、创建一个类，包含类属性（公有属性、私有属性）、实例属性（公有属性、私有属性），类方法、实例方法（公有方法、私有方法）、静态方法。 2、创建类对象。 3、添加类属性、实例属性 4、实现访问类的属性（公有属性、私有属性）、实例属性（公有属性、私有属性）。 5、实现 类名、类对象访问类方法。 6、实现 类对象 访问实例方法（私有方法、公有方法） 7、实现 类名、类对象 访问静态方法 8、创建该类的子类。实现父类属性、方法的重写。（子类继承父类的公有属性和方法，子类如何访问父类的私有属性和方法，子类如何改写父类的属性） 9、实现一次性访问子类、父类的同名方法。 10、练习property对象实现类的私有属性的访问以及改写。

1. 创建一个类，包含类属性、实例属性、类方法、实例方法、静态方法

class MyClass:
    class_attr = "class attribute"
    __private_class_attr = "private class attribute"

    def __init__(self, instance_attr):
        self.instance_attr = instance_attr
        self.__private_instance_attr = "private instance attribute"

    def instance_method(self):
        return "instance method"

    def __private_instance_method(self):
        return "private instance method"

    @classmethod
    def class_method(cls):
        return "class method"

    @staticmethod
    def static_method():
        return "static method"

2. 创建类对象

my_class = MyClass("instance attribute")

3. 添加类属性、实例属性

MyClass.new_class_attr = "new class attribute"
my_class.new_instance_attr = "new instance attribute"

4. 实现访问类的属性、实例属性

print(MyClass.class_attr)  # "class attribute"
print(my_class.instance_attr)  # "instance attribute"

print(MyClass.new_class_attr)  # "new class attribute"
print(my_class.new_instance_attr)  # "new instance attribute"

5. 实现 类名、类对象访问类方法

print(MyClass.class_method())  # "class method"
print(my_class.class_method())  # "class method"

6. 实现 类对象 访问实例方法（私有方法、公有方法）

print(my_class.instance_method())  # "instance method"
print(my_class._MyClass__private_instance_method())  # "private instance method"

7. 实现 类名、类对象 访问静态方法

print(MyClass.static_method())  # "static method"
print(my_class.static_method())  # "static method"

8. 创建该类的子类。实现父类属性、方法的重写。（子类继承父类的公有属性和方法，子类如何访问父类的私有属性和方法，子类如何改写父类的属性）

class MyChildClass(MyClass):
    class_attr = "child class attribute"
    __private_class_attr = "child private class attribute"

    def __init__(self, instance_attr):
        super().__init__(instance_attr)
        self.instance_attr = "child instance attribute"
        self.__private_instance_attr = "child private instance attribute"

    def instance_method(self):
        return "child instance method"

    def _MyClass__private_instance_method(self):
        return "child private instance method"

    def get_private_class_attr(self):
        return self._MyClass__private_class_attr

9. 实现一次性访问子类、父类的同名方法。

class MyChildClass(MyClass):
    class_attr = "child class attribute"
    __private_class_attr = "child private class attribute"

    def __init__(self, instance_attr):
        super().__init__(instance_attr)
        self.instance_attr = "child instance attribute"
        self.__private_instance_attr = "child private instance attribute"

    def instance_method(self):
        return super().instance_method() + " and child instance method"

    def _MyClass__private_instance_method(self):
        return super()._MyClass__private_instance_method() + " and child private instance method"

    def get_private_class_attr(self):
        return self._MyClass__private_class_attr

my_child_class = MyChildClass("instance attribute")
print(my_child_class.instance_method())  # "instance method and child instance method"
print(my_child_class._MyClass__private_instance_method())  # "private instance method and child private instance method"

10. 练习property对象实现类的私有属性的访问以及改写。

class MyClass:
    def __init__(self, value):
        self.__value = value

    def get_value(self):
        return self.__value

    def set_value(self, new_value):
        self.__value = new_value * 2

    value = property(get_value, set_value)

my_class = MyClass(10)
print(my_class.value)  # 10
my_class.value = 5
print(my_class.value)  # 10 (because set_value method multiplies the value by 2)

判断并说明理由：对于Python类中的私有成员，可以通过“对象名._类名__私有成员名”的方式来访问。

部分正确。在Python中，可以使用双下划线`__`来定义私有成员，但是私有成员的访问方式不应该被公开，因为这破坏了类的封装性。正常情况下，类的客户端不应该直接访问类的私有成员，而应该通过公共的方法来访问和修改私有成员。这样做可以避免客户端意外地修改了类的内部状态，从而导致程序出现错误。

虽然Python使用双下划线来定义私有成员，但是它并不是真正的私有成员，而是进行了名称修饰，将私有成员的名称修改为`_类名__私有成员名`的形式。这种名称修饰的方式并不是为了让客户端可以直接访问私有成员，而是为了避免子类意外地重写了父类的私有成员。

因此，尽管可以通过`"对象名._类名__私有成员名"`的方式来访问私有成员，但这种方式并不是Python官方推荐的访问方式，也不应该被广泛使用。如果需要访问类的私有成员，应该使用类提供的公共方法。