了解使用 Python 进行面向对象编程中的封装

2024年12月12日10:44:03 科技 1546

正如在了解 Python 中的面向对象编程中所看到的那样，面向对象编程（OOP）是一种使用“对象”来设计应用程序和计算机程序的范式。它利用几个关键概念（包括封装、继承和多态性）来提高代码的模块化和灵活性。在本文中，我们将重点介绍封装，这是 OOP 的一个基本方面，有助于实现数据隐藏和抽象。

什么是封装？

封装是将对数据进行操作的数据（属性）和方法（函数）捆绑到一个单元（称为对象）中的机制。它限制对对象的某些组件的直接访问，这可以防止意外修改数据。要理解封装，让我们分解一下它的主要功能：

数据隐藏：对象的内部状态对外界隐藏。这也称为信息隐藏。
访问限制：外部代码无法直接访问对象的内部状态。相反，它必须使用对象提供的特定方法（如 getter 和 setter）来读取或修改其状态。
简化：通过明确定义的接口与对象交互，降低了系统的复杂性，使其更易于理解和维护。

Python 中的封装

Python 的封装方法有些独特。与 C++ 或 Java 等语言不同，Python 没有 public、private 或 protected 等关键字来显式实施访问限制。

Python 对类数据和方法采用更开放的方法，基本上将所有 data 和 methods 视为公共的。对于那些习惯了其他语言的严格访问控制的人来说，这种设计选择似乎不合常规，但它体现了一个核心的 Python 理念：“我们都是同意的成年人。

“我们都是自愿的成年人”的原则超出了单纯的代码结构;它反映了整个 Python 社区的精神。它建议开发人员应该相互信任，以负责任地使用类属性和方法，而不是像 Java 等语言中那样，通过 private 或 protected 等访问修饰符来强制实施严格的屏障。

但是，Python 支持一种约定来实现类似的效果。

Python 中的命名约定

单前导下划线：_

第一个也是最广泛认可的约定是使用单个前导下划线（_）来表示不打算成为类的公共接口一部分的属性或方法。这些是内部实现，可能会发生变化，不应直接依赖外部代码。

class MyClass:
    def public_method(self):
        print("This is a public method")
    
    def _internal_method(self):
        print("This is an internal method")

在此示例中，_internal_method 旨在在 MyClass 内部或由子类使用，这表明它不是稳定的公共接口的一部分。虽然 Python 中没有任何内容阻止对 Python 的访问_internal_method，但下划线向其他开发人员发出了一个明确的信号，即应该谨慎使用。

单个下划线（_）用例

在此示例中，_connect_to_Database 是 DatabaseConnector 的内部方法，旨在供类中的其他方法（如 connect）使用，而不是从类外部直接访问。

class DatabaseConnector:
    def connect(self):
        self._connect_to_database()  # Internal use indicated by single underscore

    def _connect_to_database(self):
        print("Connecting to the database")

在 Python 中，单个下划线也用于表示变量是临时的或无关紧要的。这在循环或解包表达式中很常见，其中一个或多个值是有意未使用的。

for _ in range(5):
    print("Repeat action")

_, value = (1, 2)  # Only interested in the second value

这里， _ 用于忽略 loop 变量和 Tuples 中的第一个值，分别关注重复项和感兴趣的值。

双前导下划线：__

Python 还使用涉及双前导下划线（__）的命名约定来创建更强的隐私指示。这会触发一个称为名称修饰的功能，其中解释器以某种方式更改变量的名称，使其更难（但并非不可能）从类外部访问。

class MyClass:
    def __init__(self):
        self.__private_var = "This is a private variable"

    def __private_method(self):
        print("This is a private method")

使用名称修饰时，__private_var 和 __private_method 在内部分别重命名为 _MyClass__private_var 和 _MyClass__private_method。此机制不会使属性或方法真正私有，但确实表明了更强的非公共访问意图，从而有效地阻止了来自类外部的直接访问。其目的是创建不应直接从类外部访问的“私有”成员的更强指示，从而保护其内部状态和行为。

双下划线（__）用例

在此示例中，__balance只能通过 Account 类的方法（如 deposit）进行访问，以保护帐户余额的完整性。

class Account:
    def __init__(self, balance):
        self.__balance = balance  # Name mangling to make it harder to access directly

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount  # Accessing the mangled name internally

account = Account(100)
# Direct access to '__balance' would fail; Python mangles the name to '_Account__balance'

双下划线还可用于避免子类中的命名冲突，这些冲突可能会无意中覆盖基类属性或方法。

class Base:
    def __init__(self):
        self.__hidden = 'Base'

class Derived(Base):
    def __init__(self):
        super().__init__()
        self.__hidden = 'Derived'  # Does not actually override 'Base.__hidden'

base = Base()
derived = Derived()
# 'Base.__hidden' and 'Derived.__hidden' are two different attributes due to name mangling.

在这里，Base 类和 Derived 类中的 __hidden 以不同的方式进行分解，确保 Derived 类的 __hidden 属性不会覆盖 Base 类的 __hidden 属性，从而防止意外的副作用。

总之，在 Python 中使用单下划线（_）和双下划线（__）有不同的目的。单个下划线是内部使用或忽略值的提示，促进了一种基于约定的方法来指示预期的使用范围。双下划线通过名称修饰，为表示 “私人” 成员提供了更强的屏障，避免了命名冲突，符合“我们在这里都是成年人”的原则，同时仍然保护了类的内部运作。

深入研究其他一些示例，以更好地了解 Python 中封装的工作原理。

class Test:
    def __private_symbol(self):
        print("This is a private method.")

    def normal_symbol(self):
        print("This is a normal method.")

# Accessing the public method
t = Test()
t.normal_symbol()  # Outputs: This is a normal method.

# Attempting to access the private method directly will result in an AttributeError
# t.__private_symbol()  # Uncommenting this line will raise an error

# However, the private method can still be accessed through its mangled name
t._Test__private_symbol()  # Outputs: This is a private method.

对于类 Test 中名为 __private_symbol 的方法或变量，Python 会将名称修改为 _Test__private_symbol。这就是为什么当你使用 dir（Test）检查类的目录时，你看到的是 _Test__private_symbol 而不是 __private_symbol 的 marmed 名称。

了解公约

私人会员：应被视为 API 的非公共部分。它们旨在成为课程的内部内容，如有更改，恕不另行通知。因此，不建议在外部使用这些成员，以保持代码兼容性并防止意外误用。
名称修饰： 此机制并非旨在安全地隐藏信息。相反，这是一种帮助避免子类中的命名冲突的方法，这些冲突可能会无意中覆盖 superclasses 的私有成员。

考虑一个表示银行帐户的简单类 BankAccount：

class BankAccount:
    def __init__(self, account_number, balance=0):
        self.__account_number = account_number  # private attribute
        self.__balance = balance  # private attribute

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Amount {amount} deposited successfully.")
        else:
            print("Deposit amount must be positive.")

    def withdraw(self, amount):
        if amount > 0 and amount <= self.__balance:
            self.__balance -= amount
            print(f"Amount {amount} withdrawn successfully.")
        else:
            print("Insufficient balance or invalid withdrawal amount.")

    def get_balance(self):
        return self.__balance

    def set_balance(self, balance):
        if balance >= 0:
            self.__balance = balance
        else:
            print("Balance cannot be negative.")

在此示例中，BankAccount 类封装了 __account_number 和 __balance 属性，使它们成为私有的。这可以防止从类外部直接访问，从而强制执行封装。该类提供了 deposit（）、withdraw（）和 getter/setter 方法等公共方法，供 __balance 与这些私有属性进行交互。

数据科学上下文中的封装：Python 示例

在数据科学中，封装可能特别有用，例如以安全和结构化的方式管理和操作数据集。让我们考虑一个在数据科学项目中应用封装的实际示例。

假设我们正在使用一个数据集来跟踪网站的用户参与度指标。我们的目标是将数据集及其操作方法封装在一个类中，为数据操作提供一个清晰简单的接口，同时隐藏数据处理的复杂性。

示例：User Engagement Metrics 类

我们将创建一个类 UserEngagementData，用于封装网站的用户参与度数据。本课程将提供添加新数据、计算平均参与度指标和检索特定数据点的方法，同时保持原始数据的私密性。

import pandas as pd

class UserEngagementData:
    def __init__(self):
        # Initialize a private DataFrame to store user engagement data
        self.__data = pd.DataFrame(columns=['user_id', 'page_views', 'time_spent'])

    def add_engagement_data(self, user_id, page_views, time_spent):
        """Add a new record of user engagement data."""
        new_data = {'user_id': user_id, 'page_views': page_views, 'time_spent': time_spent}
        self.__data = self.__data.append(new_data, ignore_index=True)

    def average_engagement(self):
        """Calculate average page views and time spent across all users."""
        if not self.__data.empty:
            return {
                'average_page_views': self.__data['page_views'].mean(),
                'average_time_spent': self.__data['time_spent'].mean()
            }
        else:
            return {'average_page_views': 0, 'average_time_spent': 0}

    def get_user_engagement(self, user_id):
        """Retrieve engagement data for a specific user."""
        user_data = self.__data[self.__data['user_id'] == user_id]
        if not user_data.empty:
            return user_data.iloc[0].to_dict()
        else:
            return "User data not found."

# Example usage
engagement_data = UserEngagementData()
engagement_data.add_engagement_data(user_id=1, page_views=5, time_spent=120)
engagement_data.add_engagement_data(user_id=2, page_views=3, time_spent=80)

print(engagement_data.average_engagement())
print(engagement_data.get_user_engagement(1))

在此示例中，UserEngagementData 类封装了用户参与度数据集（存储为 pandas DataFrame），并提供与此数据交互的公共方法。

此设计具有以下几个优点：

数据完整性：通过限制对数据集的直接访问，我们可以防止外部代码的意外修改，从而确保数据集的完整性。
简单性：该类的用户不需要了解底层数据结构（pandas DataFrame）或用于计算平均值的逻辑。他们通过简单、直观的方法与数据集进行交互。
灵活性：如果我们决定更改内部实现（例如，切换到不同的数据存储机制），我们可以在不影响使用此类的代码的情况下这样做。

利用属性装饰器和 @method_name.setter 在 Python 中进行封装

在 Python 中，@property 装饰器是一个内置的装饰器，它允许我们在类中定义可以像属性一样访问的方法。此功能对于实现封装特别有用，提供了一种使用 getter 和 setter 来管理对私有变量的访问的 Pythonic 方法。

了解属性修饰器

@property 装饰器将类方法转换为属性。这意味着可以像访问属性一样访问该方法，而无需像调用函数一样调用它。这特别有用，主要有两个原因：

Getter 方法：通过使用 @property 修饰方法，您可以访问 private 属性，而无需直接公开它。
Setter Method：通过使用 @setter 装饰器，您可以定义一个允许您设置属性值的 setter 方法。此方法可以包括用于验证或修改正在设置的数据的逻辑，从而控制如何修改属性。

示例：对用户配置文件使用属性修饰器

让我们创建一个类 UserProfile，它使用属性修饰器来管理对用户年龄的访问，确保只能分配有效的年龄。

class UserProfile:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # Private attribute

    @property
    def age(self):
        """Getter method for age."""
        return self.__age

    @age.setter
    def age(self, value):
        """Setter method for age with validation."""
        if isinstance(value, int) and 0 < value < 150:
            self.__age = value
        else:
            raise ValueError("Age must be an integer between 1 and 149.")

# Example usage
user = UserProfile("John Doe", 25)
print(user.age)  # Accesses the getter method

user.age = 30  # Accesses the setter method
print(user.age)

# Trying to set an invalid age
try:
    user.age = -5
except ValueError as e:
    print(e)  # This will raise the ValueError defined in the setter method