python - 在两个类(class)之间共享资源

Question

我提供了一个工作示例，其中我在 Python 3 中将动态数组实现为自定义类型。我希望将此动态数组的单个实例用作实现的公共(public)资源，例如 N。堆栈。我怎么做？
我想我想让每个堆栈只能访问 DynamicArray 的特定部分通过划界_start和 _end .为了有_start和 _end对于每个堆栈，我想将它们包装在一个帮助器类中 _StackRecord .如果我成功提供了 DynamicArray 的可修改 View , 我要 _StackRecord完成所有繁重的弹出和推送操作，以使堆栈不会在底层 DynamicArray 发生碰撞时发生碰撞根据需要扩展/收缩。我知道我要求太多，但我可能会在我没有做到这一点时学到一些无用的技能。
任何对模块化、可维护性和良好实践的建议/批评都受到热烈欢迎。

import ctypes

class DynamicArray:
    """Expandable array class similar to Python list"""
    def __init__(self, size=0):
        self._n        = size
        self._capacity = size + 1
        self._A        = self._make_low_level_array(self._capacity)
        
    def _make_low_level_array(self, capacity):
        return (capacity*ctypes.py_object)()
    
    # following two methods are needed for Python to implement __iter__
    def __len__(self):
        return self._n
    
    def __getitem__(self, index_key):
        if isinstance(index_key, slice):
            start, stop, step = index_key.indices(len(self))
            return [self._A[i] for i in range(start, stop, step)]
        elif isinstance(index_key, int):
            if 0 <= index_key < self._n :
                return self._A[index_key]
            else:
                raise IndexError("index out of bounds")
        elif isinstance(index_key, tuple):
            raise NotImplementedError('Tuple as index')
        else:
            raise TypeError('Invalid argument type: {}'.format(type(key)))
         
    def __setitem__(self, index_k, value):
        if 0 <= index_k < self._n :
            self._A[index_k] = value
        else:
            raise IndexError("index out of bounds")
    ###################################################################        
    
class FixedMultiStack:
    class _StackRecord(DynamicArray):
        def __init__(self, array: DynamicArray, stack_number=0, size_of_each=10):
            self._stack = stack_number
            self._start = stack_number*size_of_each
            self._end   = self._start + size_of_each
            # try commenting the following lines
            self._n     = size_of_each
            self._A     = DynamicArray(self._n)
            # If I have to use self._A then I would like it to point 
            # to array[self._start:self._end]
            for i in range(self._start, self._end):
                array[i]   = i
            for i in range(self._n):
                self._A[i] = array[self._start+ i]

    def __init__(self, numStack=1, sizeEach=10):
        self._stacks = []
        self._items  = DynamicArray(numStack*sizeEach)
        
        for i in range(numStack):
            self._stacks.append(self._StackRecord(self._items, i, sizeEach))
            
    def __getitem__(self, stack_number):
        return self._stacks[stack_number]
    
if __name__ == "__main__":
    fms = FixedMultiStack(3,10)
    print(list(fms[0]))
    print(list(fms[1]))
    print(list(fms[2]))
    print(list(fms._items))

问题
我正在做一个名为 self._A 的本地副本的浪费行为.我该如何避免呢？为什么我不能只处理传递给本地记录管理器的全局动态数组 _StackRecord ?
我期待什么？

fms = FixedMultiStack(3,10) , 一个固定的多堆包装 3 堆，每堆大小为 10，这样

我想，如果 self._A是必要的，本地self._A引用 DynamicArray 的那部分它对应于给定的堆栈号。

这样print(list(fms[n]))给了我第 n 个堆栈的内容

而print(list(fms._items))应该给我所有堆栈的组合状态。哎呀! print(list(fms._items))很丑。 print(list(fms)) 怎么样?

我应该可以写self._items[n].push(val)之类的东西, self._items[n].pop()在第 n 个堆栈上推送和弹出。

Answer 1

您可以使用 memoryview 用于在整个阵列上创建不同的 View :

class FixedMultiStack:
    def __init__(self, m, n):
        self.data = bytearray(m*n)
        view = memoryview(self.data)
        self.stacks = [view[i*n:(i+1)*n] for i in range(m)]

    def __getitem__(self, index):
        return self.stacks[index]