是否可以同时让 numpy 数组值和对象属性指向内存中的相同位置？

Question

In a project I am developing I was wondering if it is possible to do something like:

class P:
    def __init__(self, x):
        self.x = x

    def __str__(self):
        return str(self.x)

    def __repr__(self):
        return self.__str__()

obj_lst = [P(x=2), P(x=3), P(x=4), P(x=5)]

np_x = array([p.x for p in obj_lst])

obj_lst[0].x = 10
print(np_x)

The expected result would be,

array([10, 3, 4, 5])

Also,

np_x[2] = 20
print(obj_lst)

I would get,

[10, 3, 20, 5]

So the both the object's attribute and the values in the array are pointing to the same position in memory.

This way I could use the OOP abstraction by one side and the numpy speed for the complex algebraic operations.

Answer 1

You can do it if you think a bit outside the box (and possibly tweak your requirements just slightly). Let's reverse the way things are set up and create a buffer that holds the data first:

np_x = np.array([2, 3, 4, 5])

Now define your class a bit differently. Instead of recording the value of x , we will record a pointer to it as an array and index (later you can do some interesting things with raw memory locations, but let's not do that for now). You can keep pretty much the exact same interface by making the x attribute a property in the class, and stashing the data for it in an instance attribute of the same name:

class P:
    def __init__(self, buffer, offset):
        self.__dict__['x'] = (buffer, offset)

    @property
    def x(self):
        buf, off = self.__dict__['x']
        return buf[off]

    @x.setter
    def x(self, value):
        buf, off = self.__dict__['x']
        buf[off] = value

    def __str__(self):
        return str(self.x)

    def __repr__(self):
        return self.__str__()

Now you can make the list of objects. This is the only part of your code that changes outside the class definition:

obj_lst = [P(np_x, 0), P(np_x, 1), P(np_x, 2), P(np_x, 3)]

All your changes are now mutually transparent because you share a buffer:

>>> obj_lst[0].x = 10
>>> np_x
array([10,  3,  4,  5])
>>> np_x[-2] = 20
>>> obj_lst
[10, 3, 20, 5]

The neat thing about this is that P will work with essentially any type that supports __getitem__ and __setitem__ , regardless of how it is indexed. For example, you can apply it to a dict :

>>> d_x = {'a': 2, 'b': 3, 'c': 4, 'd': 5}
>>> obj_lst = [P(d_x, 'a'), P(d_x, 'b'), P(d_x, 'c'), P(d_x, 'd')]
>>> obj_lst[0].x = 10
>>> d_x
{'a': 10, 'b': 3, 'c': 20, 'd': 5}
>>> d_x['c'] = 20
>>> obj_lst
[10, 3, 20, 5]

You can also supply complex indices to numpy arrays:

>>> np_x = np.arange(10)
>>> obj_lst = [P(np_x, 0), P(np_x, slice(1, None, 2)), P(np_x, [1, 2, 6, 8])]
>>> obj_lst
[0, [1 3 5 7 9], [1 2 6 8]]
>>> obj_lst[-1].x = 100
>>> np_x
array([  0, 100, 100,   3,   4,   5, 100,   7, 100,   9])
>>> np_x[5:] = 20
>>> obj_lst
[0, [100   3  20  20  20], [100 100  20  20]]