Python内存管理, since 2021-06-27

(2021.06.27)

赋值

如

>> a = 1

在Python中，万物皆对象，其中的1是一个对象。该赋值语句是一个引用语义，变量a指向对象1。变量a存储的只是一个对象的值所在的内存地址，而不是对象本身。也因此，变量所需的存储空间大小一致。

通过id指令可以查看变量所引用的对象的标识符(identity)，可当作内存地址。

>> id(a)
140014188711232

不同的变量间赋值，实际为引用的复制，比如

>> b = a

实为b引用a所引用的对象的值，此时通过id(b)查看b引用对象的id，会看到a所引用对象的id与之相同。

>> id(b)
140014188711232

查看一个对象被引用的次数，可使用sys.getrefcount指令，考虑到该指令本身会使对象的引用次数增加1，所以返回值比真实引用次数多1.

>> import sys
>> sys.getrefcount(1)
3

如果用del删除变量，则对象的引用数会减少。

>> a = 256
>> sys.getrefcount(a)
23
>> b = a
>> sys.getrefcount(a)
24
>> del b
>> sys.getrefcount(a)
23

is和==的区别

检测两个变量是否指向同一个对象，使用is指令

>> a is b
True

与==不同的是，is指令判断两个变量是否指向同一个对象，而==判断两个变量所指向变量的值是否相等。

>> a = [1, 2]
>> b = [1, 2]
>> a is b
False
>> a == b
True

在这个例子中，a和b所指向的虽然都是list [1, 2]，但在Python中这两个list有不同的identity，是两个不同的对象。

改变对象的内部结构对引用的影响

• 对于list对象来说，内部append不影响引用它的变量所指向的对象。

>> li = [1, 2, 3]
>> id(li)
140014175445504
>> lib = li
>> li.append(4)
>> id(li)
140014175445504
>> id(b)
140014175445504
>> print(b)
[1, 2, 3, 4]

• str的重新赋值会改变变量所引用的对象。

Python对象的缓存

Python为不同的数据类型创建了对象缓存池。

• int类型: 在-5到256范围内的int类型对象，创建时会加入到缓存池中，再次使用时直接从缓存池调用，不需要创建和申请新的内存。对象的值超出这个范围，则每次创建引用需要重新申请内存。

>> a = -5
>> b = -5
>> a is b
True
>> a = -6
>> b = -6
>> a is b
False
>> a, b = -100, -100
>> a is b
True # 这种方法赋值，两个变量指向同一个对象

缓存池的存在避免了频繁申请和释放内存降低应用程序的运行速度和产生大量内存碎片。

注意，超出对象缓存池(256)的范围，则赋值之后的变量和值并不是同一个对象。

# 2022.03.28 Mon
>>> a = 256
>>> b = 257
>>> id(a)
4502612368
>>> id(256)
4502612368 # a与256的id相同
>>> id(b)
4506382128
>>> id(257)
4506382000 # b与257的id不同

• bool类型：缓存。

>> a = True
>> b = True
>> a is b
True

• str类型：通过乘法*得到的字符串，当长度不超过4096，并且字符串中只有字母、数字和下划线(underscore)时，字符串被放进缓存区。

>> a = 'x' * 4096
>> b = 'x' * 4096
>> a is b
True
>> a = 'x' * 4097
>> b = 'x' * 4097
>> a is b
False
>> a = 'z0' * 2048
>> b = 'z0' * 2048
>> a is b
True
>> a = 'z0' * 2049
>> b = 'z0' * 2049
>> a is b
False
>> a = 'y_' * 2048
>> b = 'y_' * 2048
>> a is b
True
>> a = 'y_' * 2049
>> b = 'y_' * 2049
>> a is b
False
>> a = 'p+'
>> b = 'p+'
>> a is b
False

字符串连接操作的join和+对比

(2022.03.28 Mon)
结论：生成字符串的操作join比+更高效。
原因：对list/tuple里面的字符串做join操作时，首先会计算并申请出一块内存空间，之后一次性将字符串的每个元素复制到内存中，故join操作的时间是复杂度，其中s是每个字符的平均复制时间，N是字符串的数目。而做+操作时，因字符串是不可变对象/数据类型，每次+操作之后会为结果新开辟一个内存空间，即当使用s += 'somestring'操作时，每次都为s开辟新的内存，对于N个字符串相加的操作，会进行N-1次的申请内存和复制的步骤。可推知，字符串的复制次数分别是N-1, N-2, ..., 1，因此复制的总时间为复杂度。考虑到申请内存的时间，+操作将远比join操作低效。
实验：
执行1000000次操作，对比两种方法的效率

import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        starting_time = time.perf_counter()
        result = func(*args, **kwargs)
        ending_time = time.perf_counter()
        print('time consumption in seconds: ', ending_time - starting_time)
        return result
    return wrapper

@timer
def string_plus(n):
    a = ['a'] * n
    res = ''
    for i in a:
        res += i
    print('done')
@timer
def string_join(n):
    a = ['a'] * n
    res = ''.join(a)
    print('done')

运行1000000次，时间差距达到10倍

>>> string_plus(10000000)
done
time consumption in seconds:  1.0634183339998344
>>> string_join(10000000)
done
time consumption in seconds:  0.10696152999980768

基于排列(array)的序列(sequence)

(2022.03.28 Mon)
prerequisite:

• 1个字(character) = 2字节(bytes) = 16位(bits)
• RAM: retrieve byte at any address in memory with similar complexity.
• 内存中每个字节(byte)分配一个地址
• 在64位机上，每个地址有64位。以此类推
• Python中character被表达为Unicode symbol，占用2 bytes。String的每个元素都是一个Unicode char，在内存中保存为连续一段地址
• 每个array的元素长度相同，以保证用指数访问时的常数时间

list/tuple在Python中的保存: referential array

list/tuple在Python中采用引用机制(reference)保存数据，保存了一段连续的序列，该序列中的每个元素是该元素的内存地址，而非元素本身。

改变list中元素的值，实际是改变了该元素的引用地址。同理，append/extend操作，加入的都是元素的地址。

注意a = [x] * n这样的操作，列表a中元素保存的都是元素x的地址，不论x是int，string，还是其他对象。而且每个元素指向的地址相同。下面的指令验证了这个说法。

>>> b = [0]*3
>>> id(b[0])
4315080976
>>> id(b[1])
4315080976
>>> id(b[3])
4315080976

str在Python中的保存: compact array

Python中的str采用紧凑排列(compact array)方式保存，即每个元素保存元素本身，而非对元素的引用。
紧凑排列的优点：

• 节约空间，referential的每个元素需要保存64位，compact的每个元素都是Unicode，占2 bytes即16位
• 存放的元素在内存中连续排列

如何生成一个compact array？

from array import array
b = array('i', [ 1,2,3] ) # ‘i'是预定类型

自定义一个compact array

import ctypes

改变可变对象对内存的影响

(2022.03.28 Mon)
Python可变对象，即list和dict的修改操作，不会改变该对象的内存，仅改变其所占空间。

>>> f = [1,2,3,4]
>>> id(f)
4506799488
>>> f.append(10)
>>> id(f)
4506799488
>>> f.remove(4)
>>> id(f)
4506799488

注意到对list的append, remove等操作，改变了其内容，但内存地址并没有变化。同样适用于dict。

>>> d = {'a': 1}
>>> id(d)
4506797312
>>> d.update({'c': 3})
>>> id(d)
4506797312

Reference

1 编写高质量代码 改善Python程序的91个建议，张颖等著，机械工业出版社
2 Data Structures and Algorithms in Python, M. T. Goodrich and etc, John Wiley & Sons