个人Python核心笔记

个人学习记录文档，欢迎补充

Python的运行：Python转换成字节码byte code，再用c语言做的虚拟机运行该字节码。

所以看python代码差别的时候，最简单最直接的是使用import dis中dis.dis()，将他们转化成字节码，查看它们之间有什么不一样。

迭代器

迭代：是访问序列类型元素的一种方式

可迭代对象Iterable：可以迭代的数据类型有列表list、元组tuple、字典dict、字符串str

迭代器Iterator：可以记住遍历的位置的对象。将迭代时的状态保存在对象中。

  • 对可迭代对象调用iter()可获取可迭代对象的迭代器
  • 对迭代器调用next()可获取迭代器中的数据

for...in...循环的本质

  1. 先调用iter()函数，它会自动调用可迭代对象中的__iter__方法，此方法返回这个可迭代对象的 迭代器对象
  2. 对获取到的迭代器不断调用next()函数，它会自动调用迭代器中的__next__方法来获取下一个值
  3. 当遇到StopIteration异常后循环结束

自定义迭代器

定义了__iter__的类是可迭代对象

定义了__next__的类是迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from collections.abc import Iterable # 迭代对象
from collections.abc import Iterator # 迭代器

class MyIterator(object):
    def __next__(self):
        pass

    def __iter__(self):
        pass

class MyList(object):
    def __iter__(self):
        return MyIterator()

instance = MyList() # 实例化
instance_iter = iter(instance) # iter()变成迭代器，以支持直接调用next()

print(isinstance(instance, Iterable)) # True，可迭代对象
print(isinstance(instance_iter, Iterator)) # True，迭代器

**python官方规定，迭代器__next__本身必须要是可迭代对象__iter__**。不过人家cpython似乎也没太遵守。

注意定义迭代器的__next__时候需要定义完善

  1. 无法再给出数据时，raise一个StopIteration
  2. 还有数据时，return

实际案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class NodeIter:
    def __init__(self, node):
        self.curr_node = node
    
    def __next__(self):
        if self.curr_node is None:
            raise StopIteration
        node, self.curr_node = self.curr_node, self.curr_node.next
        return nde
    
    def __iter__(self):
		return self
    
class Node:
    def __init__(self, name):
        self.name = name
        self.next = None
        
    def __iter__(self):
        return NodeIter(self)

node1 = Node("node1")
node2 = Node("node2")
node3 = Node("node3")
node1.next = node2
node2.next = node3

it = iter(node1)
first = next(it) # 让node2称为第一个迭代数据

# 如果NodeIter不定义def __iter__(self)
# 下面一行就会抛出TypeError:'NodeIter' object is not iterable
for node in it:
    print(node.name)
"""
node2
node3
"""

生成器

生成器 ( generator ) 是一种特殊的迭代器，用法几乎一样。但是它还有send()和close()的用法。

生成器函数：定义了yield语句的function

生成器对象：通过生成器函数产生的对象，会保存迭代时的状态，记录函数运行到哪一步了。生成器对象本身就是一个迭代器

生成器中的yield：一次next()调用返回一个结果。一个语法糖，内部实现支持了迭代器协议，它内部是一个状态机，维护着挂起和继续的状态。

先看看下面的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 生成器函数
def gen(num):
    while num > 0:
        yield num
        num -= 1
        # 执行到 yield 语句处停止
        # 再次调用后，会接着上一次停止的 yield 语句处继续执行
    return
# 生成器对象
g = gen(5)
first = next(g)
for i in g:
    print(i)
"""
4
3
2
1
"""

<小明 : gen(5)不应该直接return一个None给g吗？>

python在编译时发现一个函数定义里有yield关键词时，它不会把这个函数当成普通函数来处理，python会给这个函数打上一个标签 说明这是一个生成器函数。

调用一个生成器函数会生成一个生成器对象，不会执行。所以g = gen(5)的时候它不会返回值，而是返回一个生成器对象保存到g。

里面的yield和return都不是它的返回值，只用对生成器对象使用next()的时候，它才会开始运行函数本体。

在生成器函数里面，return等价于raise StopIteration，不管有没有返回值，在调用next的时候都不会返回。

send和close

send：可以将参数传递到生成器函数中。对于生成器来说，next()和.send(None)一样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 生成器函数
def gen(num):
    while num > 0:
        tmp = yield num # send的10会被保存到tmp这个变量
        if tmp is not None:
            num = tmp
        num -= 1
        
g = gen(5)

first = next(g) # first = g.send(None) # 完全等价
print(f"first: { first }")
print(f"send: { g.send(10) }")
for i in g:
    print(i)
"""
first: 5
send: 9
8
7
6
5
4
3
2
1
"""

close()：这个方法用于关闭生成器，对关闭的生成器后再次调用next或send将抛出StopIteration异常。

asyncio

本次学习的是python3.7以上的用法

在python的asyncio中同时执行的任务只能有一个，不存在系统级的上下文切换，一个线程里只能有一个事件循环

事件循环（event loop）：

  • 它是一个运行在单线程中的调度器，负责管理和调度所有注册的异步任务。

    这些任务可以是协程、回调函数或者 Future 对象。

  • asyncio 的事件循环在单个线程中运行，它利用 Python 的协程特性（通过 async 和 await 关键字）来实现并发执行。

    • async：通过async定义的函数，是协程函数。在直接调用协程函数时，它返回的是协程对象，它不会运行其中函数的代码
    • await：await关键字表示该位置阻塞时可让出cpu执行，即切换到下一协程运行

事件循环会自动调度任务的执行，由程序员显示的在代码中控制任务切换，从而实现异步执行的效果

协程的运行：

  1. 通过asyncio.run或run_until_complete, run_forever等方法，运行一个event loop死循环。使python的同步模式变成异步模式。
  2. 使用下面列举的方法，会把你传入的携程方法等封装成task并注册到loop中，并启动这个loop
  3. 事件循环建立后，寻找可执行task

python的协程也并不是真正意义上只有一条线程，asyncio库内是有一个方法叫做 run_in_executor，他会将你传入的普通函数或者方法扔到子线程中运行，许多python的携程库都是基于这个方法实现的。协程之所以没办法用time.sleep来写，就是因为time.sleep是python解析器底层的一个c实现的方法，他会直接卡住整条线程的运行，而asyncio底层就是一条死循环，不停的在一个一个的执行各个task，一旦线程卡住了，循环也就执行不下去了。

await coroutine：像调用生成器一样调用coroutine，等待直到拿到返回值。不交还控制权给loop，导致不能实现异步。

await task：阻塞程序，并将控制权交还给loop。

create_task( coroutine )：将单个coroutine包装成task的方法，注册到event_loop，不交还控制权给loop，会返回一个任务对象

gather( coroutine, coroutine… )：将多个coroutine包装成task，注册到event_loop，交还控制权给loop

gather( task, task… )：将多个task进行await，注册到event_loop并等待，阻塞直到所有task完成，交还控制权给loop

class的定义

指路：【python】你知道定义class背后的机制和原理嘛？当你定义class的时候，python实际运行了什么呢？

定义一个class的时候相当于：

  1. 运行了所有在这个class中的代码

  2. （用一个命名空间ns）把产生的所有局部变量（variable、function）的名字 和 对应的值，保存到__dict__中

    __dict__：在 Python 中，每个类都有一个 __dict__ 属性，它是一个字典对象，用于存储类或实例的属性。如类变量 class_var、实例方法 instance_method、静态方法 static_method、类方法 class_method，以及一些特殊的属性 __module__、__init__、__dict__等。

  3. 如无继承任何类，默认会给你继承python object，然后建立一个type，赋值给我们定义的class的名字作为变量

图例：拓展知识—平常定义类为静态建立一个类，动态建立类方法如下。下面与上面等价。

动态建立与静态建立

私有属性

是只有在类自己的方法里才能使用/读取变量/方法。

在python中通过添加下划线__var构成一个私有变量/方法。

python实现私有变量的方式，本质上是把self.__var在程序在编译期（源代码变字节码）变为了self._类名_var。

所以python的私有属性可以理解为是一种伪私有，只是一种“约定‘，外部照样能访问和修改。

但是它不支持骚操作，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A:
    def __init__(self):
        setattr(self, "__v", "0")
# 或者
class A:
    def __init__(self):
        pass
o = A()
o.__dict__["__v"] = 0
# 或者
def g(self):
    self.__v = 0
class A:
    __init__ = g

上面的方式通过实例化的o.__v调用能正常输出

class中的self、function、method

指路：【python】class里定义的函数是怎么变成方法的？函数里的self有什么特殊意义么？

self：

self就是obj实例对象的内存地址。

在用类定义obj实例对象的时候，实例对象已经把自己这个object作为第一个argument变量传进去了。

function：

类中定义的function与平常定义的function无异；self魔法方法在object对象上调用才会出现（实例化后）。

所以实际上类的方法和对象的方法拥有同一个attribute，但是得到了不同的结果，该机制核心见章节你知道描述器是多么重要的东西嘛？你写的所有程序都用到了！

图例：类与实例的function的打印结果。类中方法为普通方法，实例中方法 ( bound method ) 为绑定了实例对象的方法。

这个method object当被调用的时候会记住created的时候绑定的是哪个object

function和method

当我们在python中定义函数，其实是建立了function object，他有一个descripter get函数。如上图，我们通过实例o调用f方法，实际上是调用A类中f方法的descript get，而这个描述器返回了实例绑定的method，其中已对第一个argument自动处理绑定了。

实验代码：分清楚function object还是method

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 代码示例
class FuncDescr:
	def __get__(self, *args):
        def f(self, data):
            print(self.name)
            print(data)
        return f

class A:
    f = FuncDescr()

o = A()
o.name = "Bob"
# 想想看下面哪个运行结果是对的？
o.f("hello")
o.f(o, "hello")

"""
解答：

o.name进行STORE_LOAD的时候，给o这个实例obj传递了name="Bob"在__dict__
下面通过o.f调用的方法时候，其实运行的是FuncDescr的descript get方法
而这个方法返回了一个function object，其name为f，它不是bound method即不是一个绑定了实例对象的方法
所以要传递一个obj实例对象
o.f(o, "hello")是对的√
"""

衍生知识 (chatGPT)

在Python中，“函数”（function）和“方法”（method）有一些关键的区别，尽管它们在很多方面是相似的。要更好地理解它们的差异，可以从CPython（即Python官方实现）的角度进行分析。

函数（Function）

  1. 定义: 一个函数是通过 def 关键字定义的独立的代码块，它接收输入参数并返回输出结果。

  2. 调用方式: 函数可以独立于类或对象使用。

  3. 语法:

    1
    2
    3
    def my_function(param1, param2):
        # Function body
        return result

方法（Method）

  1. 定义: 一个方法是定义在类内部的函数。方法依附于特定的对象实例，并且通常需要通过对象调用。

  2. 调用方式: 方法必须通过对象实例或者类本身调用。

  3. 类型:

    • 实例方法: 绑定到对象实例的方法，调用时第一个参数是 self，代表调用方法的实例。

      1
      2
      3
      4
      class MyClass:
          def my_method(self, param1, param2):
              # Method body
              return result

    • 类方法: 绑定到类的方法，调用时第一个参数是 cls，代表调用方法的类。本质上是用 @classmethod 装饰器标记的函数。

      1
      2
      3
      4
      5
      class MyClass:
          @classmethod
          def my_class_method(cls, param1, param2):
              # Method body
              return result

    • 静态方法: 不绑定到实例或类，调用时没有默认的第一个参数。本质上是用 @staticmethod 装饰器标记的函数。

      1
      2
      3
      4
      5
      class MyClass:
          @staticmethod
          def my_static_method(param1, param2):
              # Method body
              return result

CPython 实现中的区别

函数对象

在CPython中，函数是一种特定类型的对象。每个函数对象包含一个或多个字节码指令和其他元数据，例如函数名、文档字符串、默认参数等。函数对象的类型是 types.FunctionType。

方法对象

方法在CPython中实现为不同类型的对象，根据它们是实例方法、类方法还是静态方法而有所不同：

  • 实例方法: 当一个函数在类的上下文中被访问时，Python会自动将其转换为一个绑定方法对象 (types.MethodType)。
  • 类方法: 通过 @classmethod 装饰器定义的函数，在类或实例上访问时会返回一个 classmethod 对象。
  • 静态方法: 通过 @staticmethod 装饰器定义的函数，在类或实例上访问时会返回一个 staticmethod 对象。
绑定与非绑定
  • 绑定方法: 绑定方法是已经将实例（对于实例方法）或类（对于类方法）绑定到自身的方法对象。调用绑定方法时，不需要显式传递实例或类，会自动作为第一个参数传入。
  • 非绑定方法: 非绑定方法是未绑定到任何实例或类的函数。在类定义体中直接引用的方法是非绑定的，需要手动绑定后才可调用。
例子

以下是一个具体例子展示函数和方法的区别：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class MyClass:
    def instance_method(self):
        return "This is an instance method"

    @classmethod
    def class_method(cls):
        return "This is a class method"

    @staticmethod
    def static_method():
        return "This is a static method"

def standalone_function():
    return "This is a standalone function"

# 调用实例方法
obj = MyClass()
print(obj.instance_method())  # 输出: This is an instance method

# 调用类方法
print(MyClass.class_method())  # 输出: This is a class method

# 调用静态方法
print(MyClass.static_method())  # 输出: This is a static method

# 调用独立函数
print(standalone_function())  # 输出: This is a standalone function

总结来说，函数和方法在Python中虽然相似，但它们的定义位置和调用方式有所不同，而在CPython实现中，它们也有不同的对象类型和绑定机制。

super()

super是一个type/类。

在子类中调用super().__init__(*args)会调用父类的init初始化函数，它等价于super(子类, self).__init__(*args)

在它的两个参数中，第一个决定了在mro链上从哪开始找（找如__init__方法），第二个决定了这个函数的对象和mro

super().__init__中动态的继承方法过程：

  1. 从self中拿到mro：子类→父类→object实例
  2. 找到第一个argument、略过，向后面的class找。
  3. 如有__init__函数，bind其到self上，也就是父类.__init__(self, *args)

所以 super当然可以在class外使用，直接覆盖继承

super的外部使用

一、如果只传递一个参数（class）的话，它会返回unbound object，需要bind一个object上才能使用，代码如下。这里不深入讨论，略过了

1
2
ubo = super(Male)
ubo.__get__(self).__init__(*args)

二、我们平时常用的super()用法，必须要在class中进行。

  1. 它会寻找自己在哪个class被定义，作为第一个参数；
  2. 然后寻找自己在哪个函数中被定义，拿这个函数的第一个argument（通常是self），作为第二个参数

注意：想想看下面的运行结果是什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
"""
M开始的mro为BCA
"""
class A:
	def say(self):
    	print("A")
        
class B(A):
	def say(self):
    	super().say()
        
class C(A):
    def say(self):
        print("c")
        
class M(B，C):
	def say(self):
         # super().say() # 等同
		B.say(self)
        
m = M()
m.say()

上述的运行结果均为C，但是B.say(self)也是这个结果！

似乎有点反直觉，为什么？明明他跟C一点关系都没有

答案是：在class M的super()中，我们第二个参数self决定了它的mro，而我们传递的self是M类的实例

元类 metaclass

主要了解概念和应用

回顾class的定义章节，列出了动态和静态建立一个class的过程，并且提到是使用type建立一个class。如下：

1
2
3
4
5
6
7
# 静态建立
class A():
    pass
# 动态建立
A = type("A", (), {})

# 两者等价

元类的建立：

1
2
3
4
5
6
7
8
9
10
11
class M(type):
	def new_(cls, name, bases, dict):
        return type.__new__(cls, name, bases, dict)
# 静态建立
class A(metaclass=M):
    pass

# 动态建立
A = M("A", (), {})

# 两者等价

元类会隐式的重写class，当在被继承的时候，就会调用父元类的new、init方法。

所以元类可以实现普通继承无法很好实现的方法。推荐用于单例。

单例模式：

  • 单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

    在某些场景下，并不需要多个实例对象。而是重用第一次创建的实例对象。

  • 由于__new__负责分配内存，__init__负责初始化内存，如果只想让元类成为单例就可以在__new__里面限制，避免不必要的内存分配

    • __new__方法是一个静态方法，没有默认的实现，需要显示地重写。

      它的作用是创建并返回一个新的实例对象。__new__方法在对象创建之前调用，它返回一个实例对象，并且这个对象会传递给__init__方法的第一个参数（即self）。

    • __init__方法是一个实例方法，不需要返回值。

      它在对象创建后被调用，接收实例对象作为第一个参数（即self），并可以进行实例属性的初始化、设置默认值和执行其他操作。

案例一：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# __call__ 方法用来拦截类的实例化过程，确保类 A 的实例是单例的
# 如果使用super()来调用父类函数，在__init__和__call__中需要去掉self和cls。高天又留了一个坑
class M(type):
    def __new__(cls, name, bases, dict):
        print("new")
        return type.__new__(cls, name, bases, dict)
        # return super().__new__(cls, name, bases, dict)

    def __init__(self, name, bases, dict):
        print("init")
        return type.__init__(self, name, bases, dict)
        # return super().__init__(name, bases, dict)

    def __call__(cls, *args, **kwargs):
        print("call")
        if not hasattr(cls, "_instance"): # 如没有cls.instance，通过调用 cls 类对象的初始化方法创建的新的类实例
            cls._instance = type.__call__(cls, *args, **kwargs)
            # cls._instance = super().__call__(*args, **kwargs)
        return cls._instance

class A(metaclass=M):
    pass

a = A() #调用了call
b = A() #调用了call
print(id(a) == id(b))

print(A.__dict__)
"""输出结果：
new
init
call
call
True
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None, '_instance': <__main__.A object at 0x000001C10F9A2BB0>}
"""

案例二：限制coder在定义类的时候不允许定义开头为test_的函数

1
2
3
4
5
6
7
8
9
10
11
12
class metaM(type):
    def __new__(cls, name, bases, dict):
        # print("I'm metaM", name, bases, dict)
        for key in dict.keys():
            if key.startswith('test_'):
                raise ValueError('metaM不许定义test_的有关函数')
        return super().__new__(cls, name, bases, dict)

class metaA(metaclass=metaM):
    def test_case(self):
        pass
# 这样在定义metaA的时候，就会直接抛出ValueError，因为元类在被继承的时候就会调用__new__、__init__

如果要使用原来的class用法来实现，则实例化后才会抛出异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class M:
    def __new__(cls, *args, **kwargs):
        # print("I'm M", *args, **kwargs)
        for key in cls.__dict__.keys():
            if key.startswith('test_'):
                raise ValueError('M不许定义test_的有关函数')
        instance = super().__new__(cls, *args, **kwargs)
        return instance

class A(M):
    def test_case(self):
        pass

a = A() #这里才会抛出异常

案例三：在一个类中创建了多个关于云服务器的连接信息，这些信息是不变的。那么只是需要一个实例对象来访问这些信息，而不是创建多个来占用内存。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class ConnectionServer(type):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self, host, port, password):
        self.host = host
        self.port = port
        self.password = password


server_1 = ConnectionServer('192.168.1.1', 1234, '123')
server_2 = ConnectionServer('192.168.1.2', 3456, '456')
print(id(server_1) == id(server_2))

print(server_1.host, server_1.port, server_1.password)
print(server_2.host, server_2.port, server_2.password)

描述器 descripter

指路：【python】你知道描述器是多么重要的东西嘛？你写的所有程序都用到了！

定义了__get__、__set__、__delete__的类为描述器

使用 什么.什么 都会用到这个描述器机制

print(o.name)和o.name='Bob'分别为 LOAD_ATTR和STORE_ATTR

LOAD_ATTR return的顺序问题：

  1. 优先在带有__get__和__set__的描述器对象中查找
  2. 在类对象中__dict__定义的attribute中查找
  3. 在带有__get__中的描述器对象中查找
  4. 都没有，就返回descriptor本身。返回他的type ( 类/class ) 中甚至父类中的__dict__查找

图例：运行结果示例
注意o.name的变化

实验代码：STORE_ATTR是否能设置成功，输出结果是什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Name:
    def __get__(self, obj, objtype):
        return '我是get'

    def __set__(self, obj, objtype):
        return None

class A:
    name = Name()

o = A()
o.name = "I'm attribute"
print(o.__dict__)
print(o.name)
'''
答案：
    {}
    我是get
解析：
    存在get和set, 直接return __get__中定义的方法结果: "I'm attribute"
    就算定义了obj attr —— o.name也没用
'''

实验代码2：LOAD_ATTR return的实验思考，猜猜运行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Name:
    def __get__(self, obj, objtype):
        return '我是get'

class A:
    name = Name()

o = A()
o.name = "I'm attribute"
print(o.__dict__)
print(o.name)
Name.__set__ = lambda x:None
print(o.name)

'''
答案：
    {'name': "I'm attribute"}
    I'm attribute
    我是get
解析：
    只存在get, 返回obj对象中定义的attribute (obj中的attr保存在__dict__) 返回: "I'm attribute"
    在设置了__set__方法后, 再次调用LOAD_ATTR则返回: "我是get"
'''

关于import

先了解两个概念

module

  • 是运行时的概念，保存在内存中，独立构成命名空间。它是一个python object（可包含其他python object），是一个组织单位
  • 而文件是操作系统级的概念，我们需要通过import导入这个过程，从文件中生成module

实际应用中，一个module常常对应一个.py文件

package

  • 特殊的module，几乎有着一模一样的功能，只多了一个__path__
  • package往往对应文件夹，它可包含subpackage或module。其中module在组织结构中最末端

从Python3.3开始：无论有没有__init__.py文件，一个文件夹都可以作为package被使用

import的时候发生了什么？

其中module和package大致相同，在最后一步需要区分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"""
─local
│  ├─example.py
│  ├─test.py
├─mypackage
│  ├─mymodule.py
│  ├─util.py
│  ├─__init__.py
"""
# example.py
import test
# from test import A

import mypackage # absolute import
from .util import f # relative import

  1. 拿到test字符串，作为名字查找module

    1. 检查缓存，有没有读取记录
      • 叫test的module已经被读取进来了，直接把它赋值给test
      • 没有则寻找 ↓

  2. 首先看这个名字是不是python自带的module（builtin module），如sys、os

  3. 不是builtin module，则寻找可以被加载为test的文件，它会在sys.path提供的几个路径中按顺序寻找。sys.path类似输出如下

    1
    2
    ['','/usr/lib/python311.zip','/usr/lib/python3.11','/usr/lib/python3.11/lib-dynload','/home/gaogaotiantian/programs/bilibili video/venv3.11/lib/python3.11/site-packages']
    # site-packages是当前环境pip install的位置

  4. 如是module：找到这个文件后，它会在单独的命名空间中运行这个文件（建立一个module）

    完成后变成module object，更新缓存，以后有其他代码import这个名字的时候就不用再加载/寻找一次

    • module object赋值给变量test —— import test
    • module object赋值给变量t —— import test as t
    • module object中找到名字为A的变量，将其保存的object赋值给变量A —— from test import A

  5. 如是package：查看这个package文件夹下是否存在__init__.py文件

    • 没有，不会运行任何额外的代码

    • 有，在单独命名空间中运行__init__.py文件，构成一个特殊的module即package。而package import分为两种

      • absolute import：绝对引入。如果通过import mypackage引入，则其他文件如mymodule.py并不会在dir(mypackage)中。

        如果想import一个package下的module，则需要import mypackage.mymodule，而此时我们会有一个mypackage的全局变量并且中dir(mypackage)有了mymodule.py。如果你此时使用as语句将module赋值给了一个变量，它会把最后面的module赋值到对应变量，同时mypackage全局变量也不存在

      • relative import：相对引入。根据包的相对路径来引入一个module或package。但重点是，绝对引入的写法帮助module确认了它所属的package，相对引入没有！所以使用python module.py运行含有相对引入的代码的脚本时，会抛出ImportError: attempted relative import with no known parent package或者类似的异常。

        **所以在python中，相对导入的设计更适合用于模块化的包结构中，而不是直接运行的顶层脚本中**。如果需要直接运行带有相对引入的module脚本，推荐使用python -m package.module来执行模块。

一个案例分享：

1
2
3
4
5
6
│  test.py
│
└─mypackage
    │  main_module.py
    │  util.py
    │  __init__.py
1
2
3
# main_module.py
from .util import f
print(" --I'm main_module-- ")
1
2
3
# util.py
def f():
    pass
1
2
3
4
5
6
7
# __init__.py
from . import main_module
from .util import f

print(" --I'm main_module.py __init__ file-- ")

a = 1
1
2
3
4
5
6
7
8
# test.py 可直接执行查看运行示例
import mypackage

print(mypackage.__package__)
print(mypackage.a)
print(mypackage.main_module)
print(mypackage.main_module.f, mypackage.f)
print(mypackage.main_module.f is mypackage.f)

运行结果如下：

1
2
3
4
5
6
7
--I'm main_module--
 --I'm main_module.py __init__ file--
mypackage
1
<module 'mypackage.main_module' from '......\\package实验\\mypackage\\main_module.py'>
<function f at 0x000001F90AF61550> <function f at 0x000001F90AF61550>
True

内存管理结构

简单入门：详细请看Python内存分配器

主要讨论Cpython的内存管理机制，CPython是最广泛使用的Python实现。

Python会在程序启动时从操作系统申请一块较大的内存作为内存池，然后将这块内存分割成固定大小的小块（通常是8字节的倍数）。

  • Python程序请求分配一个小于512字节的对象时，Python会直接从内存池中分配一个空闲的小块，而不是每次都向操作系统请求新的内存空间。

    当对象不再需要时，Python将其关联的内存块标记为空闲，而非立即将内存返回给操作系统，从而避免了频繁的系统调用开销。

  • 若大于512字节，则调用c的malloc申请。

操作系统对于Python内存池中的具体对象分配和释放过程并不感知。从操作系统的角度看，它只知道Python一开始申请了一块较大的内存，但具体内部的小块分配和释放过程并不影响操作系统级别的内存管理。

Python中并不是在生成所有对象时都去调用malloc()，而是根据要分配的内存大小来改变分配方法，判断申请的内存大小是否大于512字节

  • 是，调用c的malloc申请
  • 不是，使用内存分配器做内存对齐。如下说明

内存分配器：负责管理对象的分配和释放，会根据请求的内存大小 以及Python数据对象类型、内存大小，进行内存的分配和释放，与垃圾回收机制紧密集成。

内存对齐：指在内存中按照特定的边界（4字节或8字节）对数据进行排列，以确保数据的起始地址是该边界的整数倍，使得数据在内存中的布局更加紧凑和高效。

内存管理系统中的内存分类：分为三个层级，Block < Pool < Arena。

  • 最小的单位为block。 最终给申请者的就是block的地址

  • 比他大的是pool。 用于管理相同大小的Block，以便快速分配和释放。

    其中使用used_pools数组来快速查找和分配内存。

  • 最大的是arena。 作为顶层的内存管理单元，负责从操作系统申请一大块内存，并将其分割成多个Pool

    内存分类图例

当申请一个小于512字节的内存空间时：

  1. 确定Pool：根据申请的内存大小，CPython确定需要哪个大小的Pool。
  2. 查找used_pools：在used_pools列表中查找具有足够大小且有空闲Block的Pool。
  3. 分配Block：如果找到了合适的Pool，CPython从该Pool中分配一个Block给请求的对象。
  4. 更新Pool状态：更新Pool的状态，标记分配的Block为已使用。
  5. 内存对齐：确保分配的Block是按照内存对齐规则对齐的。
  6. 返回内存地址：返回Block的地址给请求者，作为新分配内存的地址。
  7. 处理Pool耗尽：如果当前Arena中的Pool没有足够的空闲Block，CPython可能会从操作系统申请新的内存来创建新的Pool或Arena。
  8. 垃圾收集：当对象被销毁，其占用的Block会被返回到Pool中，Pool的状态会更新以反映Block现在是空闲的。
  9. 内存整理：在垃圾收集过程中，CPython可能会进行内存整理，以减少内存碎片。

涉及组件详细介绍

Arena：为避免频繁的调用malloc和free，内存分配器会以最大的单位arena来保留内存，所以内存的free和malloc都是以Arena层级进行的，即：如果在一个Arena中，一个Pool中的一个Block还正在被使用，这个Arena就无法被free。

  • Python在运行的时候会建立一堆Arena（一般是16个），不够再增加。
  • Arena只记录还没有被使用的pool

Pool：用于有效管理空的block，申请Pool时，优先用满所有的Arenas。

  • 有一个freeblock链表，其中记录着空闲链表。
  • 各个pool的大小固定为4k字节（计算机内存中的页就是这么大，设置为4k字节）

Block：每个block的大小定为8的倍数，例如16字节、24字节等。按照此区间预申请多余的内存，避免内存碎片化。

  • block划分的大小在pool初始化的时候就决定了。一旦确定了块(block)的大小，Python会从操作系统申请一块大的内存，这块内存会被分割成多个固定大小的块，而这些块构成了内存池。

  • 如下，申请一定区间大小内的空间会返回8的倍数的block：

    内存管理

usedpools：是一个数组，保存了很多Pool指针，按Pool的大小排序，用于跟踪当前已经分配了对象的Pool，负责从众多Pool里返回适合申请的Pool，即快速查找和分配内存。

  • 这个数组中的index对应了pool中block的大小，例如index0每一个block为8字节，index1每一个block为16字节，index2每一个block为24字节……

    如果申请了大小为20字节，则根据 usedpools 索引出index为2的元素中的pool（该pool拥有24字节block）

所以你可以发现python中object的byte数永远可以被8整除。整存整取。

垃圾回收机制

GC是Garbage Collection的简称，中文称为“垃圾回收”，是指程序把不用的内存空间视为垃圾并回收掉的整套动作。

GC 要做的有两件事：

  1. 找到内存空间里的垃圾；
  2. 回收垃圾，让程序能再次利用这部分空间。

在CPython中，对象可以分为容器对象和非容器对象两种，并且各自有不同的具体method来实现，也分别引申涉及到了不同的GC算法。

  • 非容器对象，通常使用引用计数就可以解决

  • 容器对象，分不同的情况，有两种主要GC算法

    1. 标记清除算法：对于容器对象，如果它们参与了循环引用，会在标记阶段被识别出来，并在清除阶段被回收。

      循环引用：在某些情况下，对象之间形成循环引用，导致它们的引用计数永远不会达到零，即使它们不再被访问。这会导致内存泄漏。

    2. 分代回收的GC算法：针对对象中的子对象，根据存活时间长短而使用该GC算法：

      该算法基于一个观察结果：绝大多数对象都是短暂存在的，而长时间存活的对象往往会持续存活。这个策略将对象分为不同的“代”，通常分为年轻代、中年代、老年代，这些代的垃圾收集的次数由非常频繁到较少发生。

引用计数

  • Python里，在对象的建立中，python不仅要保存对象的值，还要去保存该对象的头信息（被引用了多少次）

    所以每个对象都有一个引用计数器，用于记录有多少个变量引用了该对象。

  • 当引用计数器归0时，表示没有变量引用该对象，该对象就成为垃圾对象，会被垃圾回收机制自动删除。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import gc 
# import sys
# sys.getrefcount(node1) # 可以对打印象的引用计数器，包含这次引用

class TreeNode:
    def __init__(self, parent=None):
        self.left = None
        self.right = None
        self.parent = parent
    
    def __del__(self):
        print(f'node被删除')

node1 = TreeNode()               # node1引用+1
node2 = TreeNode(parent=node1)   # node1引用+1，node2引用+1

del node1
del node2

print(f"Unreachable objects: {gc.collect()}") # Unreachable objects: 0

循环引用情况：标记清除

  • 由于两个对象互相引用，所以各对象的计数器的值都是1。

    但是这些对象组并没有被其他任何对象引用。因此想一并回收这两个对象都不行，只要它们的计数器值都是1，就无法回收。

  • 由此引入了循环垃圾收集器，它会定期扫描内存中的对象，检测循环引用并清理掉这些无法访问的对象。

容器对象：有元组，字典，列表。保留了指向其他对象的引用的对象

非容器对象：有字符串和数值等。这些对象不能保留指向其他对象的引用，那么这些对象就不存在循环引用问题。

  • 两种类型在CPython中建立的方式各不相同

    容器对象类型在CPython中使用PyObject_GC_New建立，其中有PyObject_GC_Link方法

    ^也就是说每建立一个容器，Cpython就把这个容器放到垃圾回收专门的链表里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import gc

class TreeNode:
    def __init__(self, parent=None):
        self.left = None
        self.right = None
        self.parent = parent
    
    def __del__(self):
        print(f'node被删除')
node1 = TreeNode()
node2 = TreeNode(parent=node1)
node1.left = node2                            # 容器对象循环引用

del node1
del node2

print(f"Unreachable objects: {gc.collect()}") # Unreachable objects: 2

小总结

CPython的垃圾回收算法结合了多种技术来有效管理内存，有：

  1. 引用计数器（Reference Counting）：

    • 每个对象都有一个引用计数器，用于跟踪引用该对象的活跃对象数量。
    • 当对象的引用计数降到零时，意味着没有任何活跃的引用指向该对象，它将被立即回收。

  2. 标记-清除（Mark-and-Sweep）：

    • 用于解决引用计数无法处理的循环引用问题。

      当两个或多个对象相互引用时，即使它们不再被使用，引用计数器也不会降到零。

    • 垃圾收集器通过“标记”阶段识别所有可达对象，然后在“清除”阶段清除未被标记的对象。

  3. 分代回收（Generational Collection）：

    • 根据对象的存活时间将对象分为不同的代：年轻代、中年代和老年代。
    • 不同代的对象以不同的频率进行垃圾回收，年轻代更频繁，老年代较少。

CPython的垃圾回收机制通过这些方法的结合，实现了有效的内存管理和回收，同时最小化了程序运行时的性能影响。引用计数器提供了快速的内存回收，而标记-清除算法解决了循环引用问题。分代回收策略进一步优化了垃圾收集过程，通过区分对象的生命周期来减少不必要的垃圾收集工作。

学习 > 编程
#Python
个人Python核心笔记
https://www.fishingrodd.cn/2024/08/28/鱼竿的Python笔记/
作者
FishingRod
发布于
2024年8月28日
更新于
2024年10月6日
许可协议