Python class用法理解|极客教程

Python class用法理解

1. 什么是class

在Python中，class是一种用于创建对象的蓝图。它定义了一组属性和方法，用于描述对象的行为和特征。

类可以看作是一种数据类型的扩展，它可以用于创建多个具有相同属性和方法的对象。与其他编程语言相比，Python的类定义相对简洁，同时提供了更多灵活性。

2. 创建和使用类

下面我们通过一个简单的示例来演示如何创建和使用类。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

这是一个名为Person的类，它有两个属性(name和age)和一个方法(say_hello)。属性用于存储对象的状态信息，方法用于定义对象的行为。

类中的__init__方法是一个特殊的方法，它在创建对象时被调用，并用于初始化对象的属性。self是一个特殊的参数，它表示对象自身，用于访问对象的属性和方法。

我们可以通过以下方式创建和使用Person类的对象：

person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

print(person1.name)  # 输出："Alice"
print(person2.age)   # 输出：30

person1.say_hello()  # 输出："Hello, my name is Alice and I am 25 years old."
person2.say_hello()  # 输出："Hello, my name is Bob and I am 30 years old."

上述代码中，首先分别创建了两个Person对象(person1和person2)，并传入了不同的参数。然后，通过对象的属性和方法来进行访问和调用。

3. 继承

在面向对象编程中，继承允许我们定义一个类，它从已有的类中继承了属性和方法。继承的主要好处是代码的重用和扩展。

下面我们通过一个示例来说明继承的用法：

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

    def study(self):
        print(f"{self.name} is studying.")

student = Student("Charlie", 20, "A")
print(student.name)   # 输出："Charlie"
print(student.age)    # 输出：20
print(student.grade)  # 输出："A"

student.say_hello()   # 输出："Hello, my name is Charlie and I am 20 years old."
student.study()       # 输出："Charlie is studying."

在上述代码中，我们定义了一个Student类，它继承自Person类。Student类新增了一个属性(grade)和一个方法(study)。

通过调用super().__init__(name, age)，我们可以调用父类的构造函数来初始化继承的属性(name和age)。

4. 多重继承

在Python中，一个类可以同时继承多个父类，这称为多重继承。多重继承允许子类获得多个父类的属性和方法。

下面我们通过一个示例来演示多重继承的用法：

class MathOperations:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

class PrintInfo:
    def display_info(self, message):
        print(f"Info: {message}")

class Calculator(MathOperations, PrintInfo):
    def calculate(self, a, b):
        result = self.add(a, b)
        self.display_info(f"The result is {result}.")
        return result

calculator = Calculator()
calculator.calculate(2, 3)  # 输出："Info: The result is 5."

在上述代码中，定义了两个父类(MathOperations和PrintInfo)和一个子类(Calculator)。子类Calculator同时继承了两个父类的属性和方法。

通过多重继承，我们可以在子类中使用父类的方法来实现更复杂的功能。在示例中，子类Calculator的calculate方法调用了父类MathOperations的add方法和父类PrintInfo的display_info方法。

5. 类属性和类方法

类属性是属于整个类而不是某个具体对象的属性，它在所有对象之间是共享的。类属性通常用于存储与类相关的信息。

类方法是在类级别上定义的方法，它可以通过类名调用，并且不能访问实例属性。类方法通常用于执行与类相关的操作。

下面我们通过一个示例来说明类属性和类方法的用法：

class Circle:
    PI = 3.14159

    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return self.PI * self.radius ** 2

    @classmethod
    def get_pi(cls):
        return cls.PI

circle1 = Circle(5)
circle2 = Circle(10)

print(circle1.calculate_area())  # 输出：78.53975
print(circle2.calculate_area())  # 输出：314.159

print(Circle.get_pi())   # 输出：3.14159
print(circle1.get_pi())  # 输出：3.14159

在上述代码中，我们定义了一个Circle类，它有一个类属性(PI)和一个实例属性(radius)。类属性PI用于存储圆周率的值，在所有Circle对象之间是共享的。

calculate_area是一个实例方法，它用于计算圆的面积。在方法中，我们通过self.PI来访问类属性。

get_pi是一个类方法，它用于返回圆周率的值。在方法定义前使用@classmethod装饰器，将其标记为类方法。类方法可以通过类名调用，也可以通过实例调用。

通过以上代码，我们可以看到，类属性和类方法是与整个类相关的，而不是与具体的对象相关。

6. 封装和访问控制

在面向对象编程中，封装是一种隐藏对象内部实现细节的机制。它使得对象的数据和行为被限制在对象内部访问，外部无法直接访问和修改。

在Python中，我们可以通过属性和方法的命名规范来实现封装和访问控制。

下面我们通过一个示例来说明封装和访问控制的用法：

class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient funds.")

    def get_balance(self):
        return self.__balance

    def get_account_number(self):
        return self.__account_number

account = BankAccount("123456789", 1000)

print(account.get_account_number())  # 输出："123456789"
print(account.get_balance())         # 输出：1000

account.withdraw(500)
print(account.get_balance())         # 输出：500

account.deposit(200)
print(account.get_balance())         # 输出：700

account.__balance = 10000   # 尝试修改私有属性
print(account.get_balance())  # 输出：700，私有属性未被修改

在上述代码中，我们定义了一个BankAccount类，它有两个私有属性(__account_number和__balance)。私有属性的命名以双下划线开头，这是一种约定，用于表示属性应该被视为私有。

通过使用私有属性，我们限制了直接访问和修改属性的能力。为了让外部访问和修改私有属性，我们可以在类中定义公共方法，如get_account_number和get_balance。这些方法提供了对私有属性的间接访问。

在示例中，我们首先创建了一个BankAccount对象(account)，并调用了get_account_number和get_balance方法来获取账号和余额。然后，通过调用withdraw和deposit方法来更新余额。

在最后一行代码中，我们尝试直接修改私有属性__balance的值。然而，因为私有属性是不可直接访问的，所以修改没有生效。这可以保护对象的状态不被非法修改。