Python入门（三）

类#

1
class A:
2
    def __new__(cls, *args, **kwargs):
3
        return super().__new__(cls)
4

5
    def __init__(self, value):
6
        self.value = value
7

8
    def display(self):
9
        print(f"Value: {self.value}")
10

11
    def __del__(self):
12
        print(f"Deleting instance with value: {self.value}")
13

14
a = A(10)
15
a.display() # Value: 10
16

17
b = a
18
del a
19
b.display() # Value: 10
20

21
# Deleting instance with value: 10

别的语言的构造函数被Python分成了两块。__new__负责内存分配，这个内存是固定大小的，只放对象的骨架。这块固定的内存里有一个空字典__dict__={}。

__init__负责初始化属性，在这里第一次定义的变量就是放在__dict__指向的地方。

self.value = 10本质是self.__dict__['value'] = 10。

__del__是析构函数，引用计数为零的时候就会被调用。

手动调用del只会让引用计数减一，不会强制回收内存里这块值。

1
class A:
2
    name = "Class A"
3

4
    def __init__(self, value):
5
        self.value = value
6

7
    version = 1.0
8
    _speed = 100
9
    __hidden = "This is a hidden attribute"
10

11
    def display(self):
12
        print(f"Value: {self.value}")
13

14

15
print(A.name)  # Class A
16
print(A.version)  # 1.0
17
print(A._speed)  # 100
18
print(A._A__hidden)  # This is a hidden attribute

不在方法里的属性都是类属性。

在属性前面加一个下划线是约定“不要访问我”，但硬要访问也可以。

加两个下划线是让编译器改名，但这个改名的模式是可预测的。一般用于防止子类意外覆盖父类的同名属性。

1
class A:
2
    name = "Class A"
3

4
    def __init__(self, value):
5
        self.value = value
6

7
    @classmethod
8
    def get_name(cls):
9
        return cls.name
10

11
    @staticmethod
12
    def add(a, b):
13
        return a + b
14

15
    @property
16
    def info(self):
17
        return f"{self.__class__.__name__}(value={self.value})"
18

19

20
print(A.get_name())       # Class A
21
print(A.add(1, 2))        # 3
22

23
a = A(10)
24
print(a.info)             # A(value=10)

@classmethod修饰的是类方法，第一个参数是类本身，所以通常只访问类属性。

@staticmethod修饰的是静态方法，类似工具函数。

@property修饰的让方法能像属性一样被访问。

这三个装饰器的原理和普通的函数套函数语法糖不一样，是基于描述符协议实现的。经过我和AI的讨论，我决定姑且把它们记作Python的特殊实现，描述符协议我不打算深入了解。

一般情况下，Python的装饰器有两个用法，一个就是普通的函数套函数语法糖，一个是给函数注入一些元信息方便框架进行扫描。

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

5
    def __str__(self):
6
        return f"A(value={self.value})"
7

8
    def __lt__(self, other):
9
        return self.value < other.value
10

11
    def __call__(self, x):
12
        return self.value + x
13

14

15
a = A(10)
16
print(str(a))           # A(value=10)
17
print(a < A(20))        # True
18
print(a(5))             # 15

Python里以两个下划线开头和结尾的是特殊方法，大概有100多个。这里我挑了三个。

__call__很有意思，让对象能被调用。def本质就是创建了一个function的实例对象，而function类实现了__call__。

错误和异常#

1
def make_guess():
2
    guess = int(input("Guess a number between 1 and 10: ")) # fifty
3
    return guess
4

5
guess = make_guess()
6

7
# Traceback (most recent call last):
8
#   File "/Users/cabbage/python-lab/main.py", line 5, in <module>
9
#     guess = make_guess()
10
#   File "/Users/cabbage/python-lab/main.py", line 2, in make_guess
11
#     guess = int(input("Guess a number between 1 and 10: "))
12
# ValueError: invalid literal for int() with base 10: 'fifty'

Python的异常自底向上读，是由近向远的调用栈。

1
def divide(a, b):
2
    try:
3
        result = a / b
4
    except ZeroDivisionError as e:
5
        raise ValueError("b不能等于0") from e
6
    else:
7
        print(f"result = {result}")
8
        return result
9
    finally:
10
        print("divide结束")
11

12

13
divide(10, 2)
14

15
try:
16
    divide(10, 0)
17
except ValueError as e:
18
    print(e)          # b不能等于0
19
    print(e.__cause__) # division by zero

try里放可能出错的代码，except负责捕获异常，else只会在没报错的时候执行，finally无论有没有异常都会执行（只要配对的try执行了就会执行，不管有没有return或raise。不过进程被杀或者解释器崩溃的话还是会执行不了）。

raise ... from e会把新的异常和原来的异常串起来，形成异常链。如果不用raise from只是简单raise有可能丢失原始错误的上下文。