Python学习笔记之类

1 类练习一#

你有一个形如 $ax^2+bx+c$ 的多项式，你要支持如下的操作：

1 A B C 将当前多项式加上 $Ax^2+Bx+C$ 。
2 A 将当前多项式加上 $Ax^2+Ax+A$ 。
3 询问 $ax^2+bx+c=0$ 解的个数。
4 输出当前多项式。

1.1 示例程序：#

1
class MyClass:
2
    import math
3
    def __init__(self, a, b, c):
4
        self.a = a
5
        self.b = b
6
        self.c = c
7

8
    def __add__(self, other):
9
        return MyClass(self.a + other.a, self.b + other.b, self.c + other.c)
10

11
    def add(self, A):
12
        self.a += A
13
        self.b += A
14
        self.c += A
15

16
    @staticmethod
17
    def que(poly):
18
        a, b, c = poly.a, poly.b, poly.c
19
        if a == 0:
20
            if b == 0:
21
                return 0 if c != 0 else float('inf')
22
            return 1
23
        discriminant = b * b - 4 * a * c
24
        if discriminant > 0:
25
            return 2
26
        elif discriminant == 0:
27
            return 1
28
        else:
29
            return 0
30

31
    def __str__(self):
32
        a_str = str(self.a)
33
        if self.b >= 0:
34
            b_str = "+" + str(self.b)
35
        else:
36
            b_str = "-" + str(-self.b)
37
        if self.c >= 0:
38
            c_str = "+" + str(self.c)
39
        else:
40
            c_str = "-" + str(-self.c)
41

42
        if self.b == 0 and self.c == 0:
43
            return a_str + "*x^2"
44
        elif self.b == 0:
45
            return a_str + "*x^2" + c_str
46
        elif self.c == 0:
47
            return a_str + "*x^2" + b_str + "*x"
48
        else:
49
            return a_str + "*x^2" + b_str + "*x" + c_str

1.2 特殊方法与普通方法#

首先我们注意到，有些函数是由带着前后的 __ ，而有些函数是直接的名称。在 Python 中，带有双下划线 __ 的函数（称为“特殊方法”或“魔法方法”）与普通方法有几个显著的区别：

1.2.1 特殊方法（魔法方法）#

定义: 特殊方法是以双下划线开始和结束的方法，例如 __init__, __add__, __str__, __eq__ 等。
目的: 这些方法是 Python 的内置机制的一部分，提供了对 Python 内建操作的自定义。它们允许用户定义对象的行为，使其能够响应特定的操作或行为。
用法:
- __init__: 构造函数，用于初始化对象。
- __add__: 实现加法操作 (+) 的行为。
- __str__: 定义对象的字符串表示。
- __eq__: 定义对象的相等性比较（==）。
- __call__: 使对象能够像函数一样被调用。
这些方法通常不直接调用，而是通过运算符或内置函数间接调用。例如，obj + other 会调用 obj.__add__(other)。
特殊性: 特殊方法在 Python 内部有特殊的作用，它们定义了对象在特定操作中的行为。它们是 Python 数据模型的一部分，并且可以被 Python 的内置函数和操作所自动调用。

1.2.2 普通方法#

定义: 普通方法是类中定义的以单个下划线或没有下划线的函数，例如 add, subtract, display 等。
目的: 这些方法用于定义类的实例可以执行的行为或操作。它们通常用于实现类的业务逻辑。
用法:
- add: 例如，用于执行类实例的某个具体操作，可能改变实例的状态或执行计算。
- display: 显示对象的状态或信息。
普通方法可以被实例通过点运算符调用，例如 obj.add(value)。
特殊性: 普通方法不具备特殊的内置功能或自动触发机制，它们是用户定义的用于实现类功能的普通函数。

1.2.3总结#

特殊方法:
- 由双下划线包围（如 __init__, __add__）。
- 与 Python 内部机制和运算符操作相关。
- 通常不直接调用，而是通过 Python 内置操作间接调用。
- 用于自定义对象在内建操作中的行为。
普通方法:
- 没有双下划线。
- 用于实现类的具体业务逻辑。
- 通过对象实例直接调用。

1.3代码详解#

1.3.1 导入模块#

1
import math

import math：导入 Python 的数学模块。

1.3.2 初始化函数 `init`#

1
def __init__(self, a, b, c):
2
    self.a = a
3
    self.b = b
4
    self.c = c

功能: 构造函数，用于初始化 MyClass 的实例。
参数:
- a：二次项的系数。
- b：一次项的系数。
- c：常数项的系数。
作用: 当创建 MyClass 的实例时，a、b 和 c 将被赋值给实例的属性 self.a、self.b 和 self.c。

1.3.3 加法运算符重载 `add`#

1
def __add__(self, other):
2
    return MyClass(self.a + other.a, self.b + other.b, self.c + other.c)

功能: 实现加法运算符 + 的重载，使得两个 MyClass 实例可以通过 + 操作符相加。
参数:
- other：另一个 MyClass 实例。
返回: 返回一个新的 MyClass 实例，其系数是两个实例对应系数的和。

1.3.4 修改系数 `add`#

1
def add(self, A):
2
    self.a += A
3
    self.b += A
4
    self.c += A

功能: 将指定值 A 加到多项式的所有系数上。
参数:
- A：要加到每个系数的值。
作用: 修改当前实例的系数 a、b 和 c，使它们都增加 A。

1.3.5 静态方法 `que`#

1
@staticmethod
2
def que(poly):
3
    a, b, c = poly.a, poly.b, poly.c
4
    if a == 0:
5
        if b == 0:
6
            return 0 if c != 0 else float('inf')
7
        return 1
8
    discriminant = b * b - 4 * a * c
9
    if discriminant > 0:
10
        return 2
11
    elif discriminant == 0:
12
        return 1
13
    else:
14
        return 0

功能: 求解二次方程 ax^2 + bx + c = 0 的根的个数。
参数:
- poly：MyClass 的实例，表示一个二次多项式。
返回:
- 0：无实根。
- 1：有一个实根（重根）。
- 2：有两个不同的实根。
- float('inf')：当 a 和 b 都为 0 且 c 不为 0 时，返回无解。

1.3.6 字符串表示 `str`#

1
def __str__(self):
2
    a_str = str(self.a)
3
    if self.b >= 0:
4
        b_str = "+" + str(self.b)
5
    else:
6
        b_str = "-" + str(-self.b)
7
    if self.c >= 0:
8
        c_str = "+" + str(self.c)
9
    else:
10
        c_str = "-" + str(-self.c)
11

12
    if self.b == 0 and self.c == 0:
13
        return a_str + "*x^2"
14
    elif self.b == 0:
15
        return a_str + "*x^2" + c_str
16
    elif self.c == 0:
17
        return a_str + "*x^2" + b_str + "*x"
18
    else:
19
        return a_str + "*x^2" + b_str + "*x" + c_str

功能: 返回多项式的字符串表示形式。
构造:
- a_str、b_str、c_str：分别表示 a、b 和 c 的字符串形式。
- 根据 b 和 c 的符号，格式化字符串，确保 + 和 - 正确显示。
返回: 多项式的标准字符串格式，如 2*x^2 - 3*x + 4。

1.4 静态方法修饰器#

在 Python 中，静态方法（@staticmethod）和普通方法（实例方法）有以下主要区别：

1.4.1 定义和调用方式#

静态方法（@staticmethod）:
- 定义: 使用 @staticmethod 装饰器定义的方法，不需要 self 参数。
- 调用: 可以通过类或实例调用，且不依赖于类的实例。调用时不传递实例或类作为参数。
- 示例:
```
1
class MyClass:
2
    @staticmethod
3
    def my_static_method():
4
        print("This is a static method")
5

6
MyClass.my_static_method()  # 通过类调用
```
普通方法（实例方法）:
- 定义: 普通方法定义时需要 self 参数，用于访问实例的属性和其他方法。
- 调用: 必须通过类的实例来调用，调用时自动传递实例作为第一个参数。
- 示例:
```
1
class MyClass:
2
    def my_instance_method(self):
3
        print("This is an instance method")
4

5
obj = MyClass()
6
obj.my_instance_method()  # 通过实例调用
```

1.4.2 访问权限#

静态方法:
- 不访问类的属性或实例的属性。
- 适合执行与类的实例无关的任务，如工具函数或辅助函数。
普通方法:
- 可以访问和修改实例的属性和方法。
- 适合实现与实例状态相关的操作和行为。

1.4.3. 使用场景#

静态方法:
- 用于实现功能性代码，与对象的状态无关。
- 适合需要与类相关，但不依赖于类或实例状态的函数。
普通方法:
- 用于操作实例的状态或执行依赖于实例的操作。
- 适合需要访问和修改对象的内部数据或状态的函数。

2 拓展：关于类的其他修饰器#

除了 @staticmethod 和普通方法，还有其他几种常用的类修饰器（装饰器）和方法修饰器，主要包括：

2.1 类方法（`@classmethod`）#

定义: 使用 @classmethod 装饰器定义的方法，第一个参数是 cls，表示类本身，而不是实例。
调用: 可以通过类或实例调用。调用时自动传递类作为第一个参数。
用途: 适合访问或修改类的状态（而非实例状态），例如工厂方法或替代构造函数。

示例:

1
class MyClass:
2
    class_var = 0
3

4
    @classmethod
5
    def increment_class_var(cls):
6
        cls.class_var += 1
7

8
    @classmethod
9
    def create_instance(cls):
10
        return cls()
11

12
MyClass.increment_class_var()  # 通过类调用
13
instance = MyClass.create_instance()  # 通过类调用

2.2 属性方法（`@property`）#

定义: 使用 @property 装饰器定义的方法，使其表现得像一个属性，而不是方法。
调用: 通过访问属性的方式调用，而不是通过方法调用。
用途: 适合将计算结果或只读值暴露为属性而不是方法。

示例:

1
class MyClass:
2
    def __init__(self, value):
3
        self._value = value
4

5
    @property
6
    def value(self):
7
        return self._value
8

9
    @value.setter
10
    def value(self, new_value):
11
        self._value = new_value
12

13
obj = MyClass(10)
14
print(obj.value)  # 通过属性访问
15
obj.value = 20  # 通过属性设置

2.3 只读属性方法（`@property` 的只读部分）#

定义: @property 使方法表现为只读属性，不提供 setter 方法。
用途: 适合提供只读的属性访问，而不允许修改。

示例:

1
class MyClass:
2
    def __init__(self, value):
3
        self._value = value
4

5
    @property
6
    def value(self):
7
        return self._value
8

9
obj = MyClass(10)
10
print(obj.value)  # 通过属性访问
11
# obj.value = 20  # AttributeError: can't set attribute

2.4 `@staticmethod` 和 `@classmethod` 的组合#

定义: 可以在一个类中同时使用静态方法和类方法，以实现不同的功能需求。

示例:

1
class MyClass:
2
    @staticmethod
3
    def static_method():
4
        print("This is a static method")
5

6
    @classmethod
7
    def class_method(cls):
8
        print("This is a class method")
9

10
MyClass.static_method()
11
MyClass.class_method()

1 类练习一#

1.1 示例程序：#

1.2 特殊方法与普通方法#

1.2.1 特殊方法（魔法方法）#

1.2.2 普通方法#

1.2.3总结#

1.3代码详解#

1.3.1 导入模块#

1.3.2 初始化函数 `init`#

1.3.3 加法运算符重载 `add`#

1.3.4 修改系数 `add`#

1.3.5 静态方法 `que`#

1.3.6 字符串表示 `str`#

1.4 静态方法修饰器#

1.4.1 定义和调用方式#

1.4.2 访问权限#

1.4.3. 使用场景#

2 拓展：关于类的其他修饰器#

2.1 类方法（`@classmethod`）#

2.2 属性方法（`@property`）#

2.3 只读属性方法（`@property` 的只读部分）#

2.4 `@staticmethod` 和 `@classmethod` 的组合#

支持与分享

评论区

目录

Python学习笔记之类

1 类练习一#

1.1 示例程序：#

1.2 特殊方法与普通方法#

1.2.1 特殊方法（魔法方法）#

1.2.2 普通方法#

1.2.3总结#

1.3代码详解#

1.3.1 导入模块#

1.3.2 初始化函数 __init__#

1.3.3 加法运算符重载 __add__#

1.3.4 修改系数 add#

1.3.5 静态方法 que#

1.3.6 字符串表示 __str__#

1.4 静态方法修饰器#

1.4.1 定义和调用方式#

1.4.2 访问权限#

1.4.3. 使用场景#

2 拓展：关于类的其他修饰器#

2.1 类方法（@classmethod）#

2.2 属性方法（@property）#

2.3 只读属性方法（@property 的只读部分）#

2.4 @staticmethod 和 @classmethod 的组合#

支持与分享

评论区

目录

1.3.2 初始化函数 `init`#

1.3.3 加法运算符重载 `add`#

1.3.4 修改系数 `add`#

1.3.5 静态方法 `que`#

1.3.6 字符串表示 `str`#

2.1 类方法（`@classmethod`）#

2.2 属性方法（`@property`）#

2.3 只读属性方法（`@property` 的只读部分）#

2.4 `@staticmethod` 和 `@classmethod` 的组合#