Python的内存优化：如何使用`__slots__`、生成器表达式和内存视图（memoryview）来减少内存占用。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Python内存优化：`slots`、生成器表达式和内存视图

各位朋友，大家好。今天，我们来聊聊Python内存优化这个话题。Python作为一种动态类型的、解释型的语言，以其易用性和灵活性著称。然而，这种灵活性也带来了一定的内存开销。理解并掌握一些内存优化技巧，对于编写高性能的Python程序至关重要。

今天，我们将重点关注三个关键技术：__slots__、生成器表达式和内存视图（memoryview）。我们将深入探讨它们的工作原理，并通过具体的代码示例来展示如何在实际应用中减少内存占用。

`slots`：告别`dict`，拥抱高效内存

Python对象通常使用一个名为__dict__的字典来存储实例属性。这个__dict__非常灵活，允许我们在运行时动态地添加和删除属性。然而，这种灵活性是有代价的：__dict__本身会占用一定的内存空间，特别是当创建大量对象时，这个开销就会变得显著。

__slots__就是用来解决这个问题的。通过在类定义中声明__slots__，我们可以告诉Python解释器，该类的实例只允许拥有预先定义的属性，从而避免创建__dict__。

工作原理：

当定义了__slots__时，Python会为每个声明的属性分配固定的内存空间，而不是使用动态的__dict__。这意味着：

更少的内存占用： 对象不再需要存储一个字典，从而减少了每个实例的内存开销。
更快的属性访问： 由于属性存储在固定的位置，访问速度通常比从__dict__中查找更快。
限制属性动态添加： 无法在运行时动态地添加未在__slots__中声明的属性。

代码示例：

import tracemalloc

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

class SlotsClass:
    __slots__ = ('name', 'age')
    def __init__(self, name, age):
        self.name = name
        self.age = age

def memory_usage(obj_factory, num_objects):
    tracemalloc.start()
    before = tracemalloc.take_snapshot()

    objects = [obj_factory("Object {}".format(i), i) for i in range(num_objects)]

    after = tracemalloc.take_snapshot()
    stats = after.compare_to(before, 'filename')
    total_allocated = sum(stat.size_diff for stat in stats)
    tracemalloc.stop()
    return total_allocated

num_objects = 100000

regular_memory = memory_usage(RegularClass, num_objects)
slots_memory = memory_usage(SlotsClass, num_objects)

print(f"RegularClass memory usage for {num_objects} objects: {regular_memory / 1024:.2f} KB")
print(f"SlotsClass memory usage for {num_objects} objects: {slots_memory / 1024:.2f} KB")

代码解释：

我们定义了两个类：RegularClass和SlotsClass。RegularClass使用默认的__dict__来存储属性，而SlotsClass使用__slots__来预先声明属性。
memory_usage函数使用tracemalloc模块来测量创建大量对象时所使用的内存。
运行结果显示，SlotsClass使用的内存明显少于RegularClass。

注意事项：

__slots__只影响实例，不影响类本身。类仍然可以使用__dict__来存储类属性。
如果类继承自一个没有定义__slots__的类，那么子类仍然会拥有__dict__，除非子类也定义了__slots__。
如果需要支持弱引用，需要在__slots__中包含'__weakref__'。
使用__slots__会阻止类被赋予动态属性，这可能会影响某些依赖动态属性的代码。

何时使用__slots__：

当需要创建大量对象，并且内存占用是一个关键问题时。
当类的属性是固定的，不需要动态添加和删除属性时。

表格：__slots__的优缺点

优点	缺点
减少内存占用	无法动态添加属性
提高属性访问速度	需要预先声明所有属性
	可能影响继承关系
	需要考虑弱引用 (`'__weakref__'`)

生成器表达式：延迟计算，节省内存

在Python中，列表推导式是一种简洁的创建列表的方式。例如：[x * 2 for x in range(10)]会生成一个包含0到18之间所有偶数的列表。然而，当处理大量数据时，列表推导式会将所有结果一次性存储在内存中，这可能会导致内存不足。

生成器表达式则提供了一种更节省内存的方式。与列表推导式不同，生成器表达式不会立即生成所有结果，而是返回一个生成器对象。只有在需要时，才会逐个生成结果。

工作原理：

生成器表达式使用圆括号()而不是方括号[]。它定义了一个计算结果的规则，但只有在迭代生成器时，才会实际执行计算。

代码示例：

import sys

# 列表推导式
list_comprehension = [x * 2 for x in range(1000000)]
print(f"List comprehension memory usage: {sys.getsizeof(list_comprehension) / 1024 / 1024:.2f} MB")

# 生成器表达式
generator_expression = (x * 2 for x in range(1000000))
print(f"Generator expression memory usage: {sys.getsizeof(generator_expression) / 1024 / 1024:.2f} MB")

# 迭代生成器表达式
for i in range(10):
    print(next(generator_expression))

代码解释：

我们分别使用列表推导式和生成器表达式创建了包含100万个元素的序列。
sys.getsizeof()函数用于获取对象的大小。
运行结果显示，生成器表达式占用的内存远小于列表推导式。这是因为生成器表达式只存储计算规则，而不是所有结果。
我们使用next()函数迭代生成器表达式，每次只生成一个结果。

何时使用生成器表达式：

当处理大量数据，并且不需要一次性访问所有结果时。
当需要迭代一个序列，但不想将所有元素存储在内存中时。
在需要惰性计算的场景中。

表格：列表推导式 vs. 生成器表达式

特性	列表推导式	生成器表达式
内存占用	高 (一次性存储所有结果)	低 (仅存储计算规则，按需生成)
计算方式	立即计算	惰性计算
返回值	列表	生成器对象
适用场景	数据量较小，需要一次性访问所有结果	数据量较大，不需要一次性访问所有结果

内存视图（memoryview）：零拷贝访问缓冲区

在Python中，处理二进制数据（例如图像、音频、视频）时，通常会使用bytes或bytearray对象。然而，当需要对这些数据进行切片、修改或传递给其他函数时，通常会涉及数据的复制，这会消耗大量的内存和时间。

memoryview提供了一种零拷贝的方式来访问缓冲区（buffer）。它允许我们直接访问底层数据，而无需进行额外的复制。

工作原理：

memoryview对象可以从任何支持缓冲区协议的对象创建，例如bytes、bytearray、array.array等。它提供了一个类似于数组的接口，可以进行切片、索引等操作，但所有操作都直接作用于原始数据，而不会创建新的副本。

代码示例：

import array

# 创建一个bytearray对象
data = bytearray(b'This is a test string.')

# 创建一个memoryview对象
view = memoryview(data)

# 切片操作
sub_view = view[5:10]
print(sub_view.tobytes())  # 输出: b'is a '

# 修改原始数据
view[0] = ord('t')
print(data)  # 输出: bytearray(b'this is a test string.')

# 从array.array创建memoryview
arr = array.array('i', [1, 2, 3, 4, 5])  # 'i' 表示有符号整数
view_arr = memoryview(arr)
print(view_arr[2]) #输出 3

代码解释：

我们首先创建了一个bytearray对象data，并使用它创建了一个memoryview对象view。
通过切片操作，我们创建了一个sub_view，它指向data中的一部分数据。注意，sub_view并没有复制数据，而是直接引用了原始数据。
我们修改了view中的一个字节，可以看到原始的data也发生了改变。这证明了memoryview是直接作用于原始数据的。
我们还展示了如何从array.array创建memoryview。

何时使用memoryview：

当需要高效地处理二进制数据时。
当需要在不同的函数或模块之间共享数据，而避免不必要的复制时。
当需要对大型数据集进行切片或索引操作，而不想创建新的副本时。
需要和C扩展进行交互，共享内存数据。

表格：memoryview的优势

优势	说明
零拷贝	避免了数据的复制，节省了内存和时间。
高效的切片和索引	可以对大型数据集进行快速的切片和索引操作。
数据共享	允许在不同的函数或模块之间共享数据，而无需进行额外的复制。
与C扩展的互操作性	可以方便地与C扩展进行交互，共享内存数据。

总结：内存优化，精益求精

今天，我们探讨了三种Python内存优化技术：__slots__、生成器表达式和内存视图。__slots__通过避免创建__dict__来减少对象占用的内存；生成器表达式通过延迟计算来节省内存；内存视图则通过零拷贝的方式访问缓冲区，避免了不必要的数据复制。掌握这些技术，可以帮助我们编写更高效、更节省内存的Python程序。要根据实际情况选择最合适的优化策略，并在性能测试的基础上进行优化。

Python的内存优化：如何使用`slots`、生成器表达式和内存视图（memoryview）来减少内存占用。

Python内存优化：`slots`、生成器表达式和内存视图

`slots`：告别`dict`，拥抱高效内存

生成器表达式：延迟计算，节省内存

内存视图（memoryview）：零拷贝访问缓冲区

总结：内存优化，精益求精

发表回复取消回复

Python内存优化：__slots__、生成器表达式和内存视图

__slots__：告别__dict__，拥抱高效内存

生成器表达式：延迟计算，节省内存

内存视图（memoryview）：零拷贝访问缓冲区

总结：内存优化，精益求精

发表回复 取消回复

Python内存优化：`slots`、生成器表达式和内存视图

`slots`：告别`dict`，拥抱高效内存

发表回复取消回复