Python 私有变量

说明

《Python 教程》持续更新中，提供建议、纠错、催更等加作者微信: gairuo123（备注：pandas教程）和关注公众号「盖若」ID: gairuo。跟作者学习，请进入 Python学习课程。欢迎关注作者出版的书籍：《深入浅出Pandas》和《Python之光》。

在 Python 中，私有变量是一种约定用于限制访问的机制，尽管它没有像一些其他编程语言（例如 C++、Java）那样提供真正的私有属性。Python 使用名称改写（name mangling）来实现私有变量（私有属性和私有方法），以避免在子类中发生名称冲。

定义私有变量

在 Python 中，私有变量是指在变量名或方法名前面加上双下划线 __ 的变量或方法，例如 __variable 或 __method()。例如：

class MyClass:
    def __init__(self):
        self.__private_var = 42 # 私有属性

    def __private_method(self): # 私有方法
        print("This is a private method")

    def get_private_var(self):
        return self.__private_var

访问私有变量

虽然私有变量的初衷是防止外部访问，但在 Python 中并非真正的私有。通过名称改写（name mangling），私有变量的名称实际上会被改写为 _ClassName__variableName，以此来防止直接访问。例如：

obj = MyClass()
# print(obj.__private_var)  # 这行代码会导致 AttributeError

# 通过名称改写访问私有变量
print(obj._MyClass__private_var)  # 输出: 42

# 通过公共方法访问私有变量
print(obj.get_private_var())  # 输出: 42

私有方法的访问

类似地，私有方法也可以通过名称改写访问：

obj._MyClass__private_method()  # 输出: This is a private method

示例

下面是一个更加完整的例子，展示如何定义和使用私有变量和方法：

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有变量

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            print("Deposit amount must be positive")

    def __calculate_interest(self):  # 私有方法
        return self.__balance * 0.05

    def add_interest(self):
        interest = self.__calculate_interest()
        self.__balance += interest
        print(f"Interest added: {interest}")

    def get_balance(self):
        return self.__balance

account = BankAccount("Alice", 1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500
account.add_interest()        # 输出: Interest added: 75.0
print(account.get_balance())  # 输出: 1575

另外是一个汽车加油行驶的类示例：

class Car:
    def __init__(self, make, model, color):
        self.make = make  # 公有属性
        self.model = model  # 公有属性
        self.color = color  # 公有属性
        self.__fuel_capacity = 50  # 私有属性，燃油容量 (单位: 升)
        self.__fuel_level = 0  # 私有属性，当前燃油水平 (单位: 升)

    def __update_fuel_level(self, amount):
        # 私有方法，更新燃油水平
        if amount > 0:
            self.__fuel_level += amount
            if self.__fuel_level > self.__fuel_capacity:
                self.__fuel_level = self.__fuel_capacity

    def drive(self, distance):
        # 公有方法，驾驶汽车
        fuel_needed = distance / 10  # 假设每行驶10公里消耗1升燃油
        if fuel_needed <= self.__fuel_level:
            print(f"开 {distance} 公里.")
            self.__fuel_level -= fuel_needed
        else:
            print("没有足够的燃料开那么远。")

    def refuel(self, amount):
        # 公有方法，加油
        self.__update_fuel_level(amount)
        print(f"加油后的油位: {self.__fuel_level}/{self.__fuel_capacity} 升.")

    def get_fuel_level(self):
        # 公有方法，获取当前燃油水平
        return self.__fuel_level

    def __str__(self):
        # 公有方法，返回汽车的描述信息
        return f"{self.color} {self.make} {self.model}"

# 使用Car类
my_car = Car("Toyota", "Camry", "Blue")
print(my_car) # Blue Toyota Camry

my_car.refuel(30)
my_car.drive(150)
my_car.get_fuel_level()
'''
加油后的油位: 30/50 升.
开 150 公里.
15.0
'''

用途

私有变量在编程中具有重要意义，尽管在 Python 中的实现方式不同于一些其他语言（如 Java 或 C++）。通过私有变量，你可以实现数据封装、增强代码的安全性和可维护性，以下是一些具体的意义：

数据封装

私有变量有助于将类的内部实现细节隐藏起来，只暴露公共接口给外部。这样可以防止外部代码直接访问和修改类的内部状态，确保类的实现细节对外界是不可见的。

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有变量
        self.__age = age    # 私有变量

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0:
            self.__age = age
        else:
            print("Invalid age")

p = Person("Alice", 30)
print(p.get_name())  # 输出: Alice
print(p.get_age())   # 输出: 30
p.set_age(35)
print(p.get_age())   # 输出: 35

防止意外修改

私有变量可以防止类的使用者意外地修改内部数据，从而引入难以发现的错误。这对大型项目尤为重要，因为它可以减少由错误操作导致的 bug。

class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance  # 私有变量

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            print("Deposit amount must be positive")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Invalid withdrawal amount")

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500
account.withdraw(200)
print(account.get_balance())  # 输出: 1300

提高代码可维护性

通过使用私有变量，可以确保类的实现细节仅通过公共方法进行访问和修改，从而提高代码的可维护性。如果类的内部实现发生变化，只需更新类内部的实现，而不必担心外部代码的兼容性。

限制访问权限

私有变量通过名称改写（name mangling）机制，变为 _ClassName__variableName，这使得外部代码很难直接访问这些变量，从而起到限制访问权限的作用。

Copy code
class Example:
    def __init__(self):
        self.__private_var = 42  # 私有变量

    def get_private_var(self):
        return self.__private_var

e = Example()
print(e.get_private_var())  # 输出: 42

# 尝试直接访问私有变量
try:
    print(e.__private_var)
except AttributeError as error:
    print(error)  # 输出: 'Example' object has no attribute '__private_var'

# 通过名称改写机制访问（不推荐）
print(e._Example__private_var)  # 输出: 42

提供控制访问的方法

通过提供公共的 getter 和 setter 方法，可以控制对私有变量的访问和修改。这允许在修改数据时进行验证和操作，确保数据的一致性和正确性。

class Employee:
    def __init__(self, name, salary):
        self.__name = name  # 私有变量
        self.__salary = salary  # 私有变量

    def get_salary(self):
        return self.__salary

    def set_salary(self, salary):
        if salary > 0:
            self.__salary = salary
        else:
            print("Salary must be positive")

emp = Employee("John", 5000)
print(emp.get_salary())  # 输出: 5000
emp.set_salary(6000)
print(emp.get_salary())  # 输出: 6000

私有变量在面向对象编程中起到了数据封装、限制访问、提高安全性和可维护性的作用。通过私有变量，开发者可以更好地控制类的内部状态，防止外部代码直接访问和修改内部数据，从而提高代码的健壮性和可靠性。

总结

私有变量和方法：通过在变量名或方法名前加双下划线（__）来定义。
名称改写：私有变量和方法的名称在内部会被改写为 _ClassName__variableName，以此防止外部直接访问。
访问方式：虽然可以通过名称改写来访问私有变量和方法，但这通常不被推荐，应该通过公共方法来访问。

这种机制主要是一种约定，用于提醒开发者这些变量和方法是内部实现细节，不应该在类外部直接使用。

< 内置类属性 Python 教程类方法 >

更新时间：2024-06-17 12:00:20 标签：python 私有变量