引言

python小程序之如何使用私有公有

一、如何使用私有公有属性和方法

1.1 题目

如何使用私有公有属性、方法

1.2 代码

class Person:
    def __init__(self, name, age):
        self.name = name
# 私有的本质, 是 Python 解释器执行代码,发现属性名或者方法名前有两个_, 会将这个名字重命名
# 会在这个名字的前边加上 _类名前缀,即 self.__age ===> self._Person__age
        self.__age = age
        # 年龄, 将其定义为私有属性, 属性名前加上两个 _

    def __str__(self):
        # 在类内部可以访问私有属性的
        return f'名字: {self.name}, 年龄: {self.__age}'


xm = Person('小明', 18)
print(xm)
# 在类外部直接访问 age 属性
# print(xm.__age) # 会报错, 在类外部不能直接使用私有属性
# 直接修改 age 属性
xm.__age = 20
# 这个不是修改私有属性, 是添加了一个公有的属性 __age
print(xm)
# 名字: 小明, 年龄: 18
print(xm._Person__age)
# 能用但是不要用 18
xm._Person__age = 19
print(xm)
# 名字: 小明, 年龄: 19

输出结果：

1.3 代码解释

1.3.1 逐行解释

1. 代码示例定义了一个 Person 类，其中包含了一个私有属性 __age

class Person:
    def __init__(self, name, age):
        self.name = name  # 公有属性，可以直接访问
        self.__age = age  # 私有属性，名称前有两个下划线
    def __str__(self):
        # 在类的内部可以正常访问私有属性
        return f'名字: {self.name}, 年龄: {self.__age}'

2. 在 __init__ 方法中，self.name 被设置为一个公有属性，可以直接从类的外部访问self.__age 被设置为一个私有属性，这是通过在属性名前加上两个下划线来实现的
3. 接下来，创建了 Person 类的一个实例，并尝试进行一些操作：

xm = Person('小明', 18)
print(xm)  # 输出: 名字: 小明, 年龄: 18

这里，print(xm) 调用了 __str__ 方法，该方法返回了一个格式化的字符串，其中包含了私有属性 __age 的值。
4. 直接从类的外部访问私有属性：

# print(xm.__age)  # 这行代码会报错，因为在类外部不能直接访问私有属性

5. 由于 __age 是一个私有属性，直接访问它会导致 AttributeError。
6. 在类的外部设置一个名为 __age 的属性：

xm.__age = 20
print(xm)  # 输出: 名字: 小明, 年龄: 18

7. 这里实际上并没有修改 Person 类中的私有属性 __age，而是为 xm 实例添加了一个新的公有属性 __age。由于名称修饰，这个新的属性与类的私有属性 __age 是不同的
8. 通过名称修饰的方式直接访问并修改了私有属性：

print(xm._Person__age)  # 输出: 18
xm._Person__age = 19
print(xm)  # 输出: 名字: 小明, 年龄: 19

9. 通过使用 _类名__属性名 的格式，可以直接访问和修改私有属性。虽然技术上可行，但这通常被认为是不好的做法，因为它违反了封装的原则，并且可能会引起维护上的问题。正确的方法是使用类提供的公共接口来访问和修改属性

1.3.1 代码行为总结

• 当我们创建 Person 类的实例 xm 时，__age 被设置为 18
• 当尝试直接从类外部访问或修改 __age 时，这不会影响到实际的私有属性_Person__age，而是创建了一个新的公有属性 __age
• 若要真正访问或修改私有属性 __age，我们需要使用它的名字改写后的形式_Person__age
• 使用 print(xm) 会调用 __str__ 方法，该方法返回一个格式化的字符串，展示 name 和 __age

这个例子很好地展示了 python 中私有属性的行为以及如何通过名字改写机制来间接访问和修改它们。尽管可以通过这种方式访问私有成员，但通常建议遵循封装的原则，不要在类的外部直接操作私有成员

二、思考

python 本身并没有提供像某些其他编程语言（如 Java 或 C++）中的真正私有成员的概念。在 python 中，通过名称修饰（name mangling）来实现一种伪私有的效果，但这并不是真正的私有访问控制

2.1 名称修饰

名称修饰是 python 对以两个下划线开头的类成员名称（但不包括结尾的下划线）所做的一种处理。python 会将这些名称重写，使得它们在类外部更难以访问。这个过程通过在成员名称前面加上一个类名和一个下划线来实现
例如：

class MyClass:
    def __init__(self):
        self.__private_attribute = "私有属性"
    def __private_method(self):
        return "私有方法"
obj = MyClass()

在这个例子中，__private_attribute 和 __private_method 都会被名称修饰。如果你尝试从类外部访问这些成员，你会得到一个 AttributeError。然而，如果知道如何计算名称修饰后的名称，仍然可以访问它们：

print(obj._MyClass__private_attribute)  # 输出: 私有属性
print(obj._MyClass__private_method())   # 输出: 私有方法

尽管名称修饰使得访问这些成员变得困难，但它并不是真正的私有访问控制，因为仍然有一种方法可以访问这些成员（尽管不推荐这样做）
在 python 的类定义中，通常使用单个下划线前缀来表示成员是受保护的，意味着它们不应该被外部访问，但这仅是一个约定，python 不会强制执行它

class MyClass:
    def __init__(self):
        self._protected_attribute = "受保护的属性"
    def _protected_method(self):
        return "受保护的方法"

在这里，_protected_attribute 和 _protected_method 是受保护的，按照约定，它们不应该从类的外部直接访问，但 python 不会阻止这样做

2.2 总结

总结来说，python 没有提供真正的私有成员机制，而是依赖于约定和名称修饰来阻止对某些成员的不恰当访问