指向相同阵列的实例

Question

here is my problem. I want to create a class which with static array visible for every instance of my class and created only once. The problem is this array does not have constant dimension but instead it will be created with given size by instance of class.

Here is an example

class My(object):
   def __init__(self, N):
      self.a = My.arr(N)

   @classmethod
   def arr(cls, N):
      return [i for i in range(0,N)]

The problem is every Instance will have a copy of the array. I would like to create let's say two instances

p1 = My(5)
p2 = My(5)

But the array should be created once and stored somewhere in a memory. When I specify different dimension it should create another array which would be visible for the same dimension instances.

Answer 1

Something like this might work, but I must say it's a very peculiar design pattern:

class My(object):
    _arrays = {}

    def __init__(self, N):
        self._dimension = N
        self._arr(N)

    def _arr(self, N):
        if N not in self._arrays:
            arr = [i for i in range(0,N)]
            self._arrays[N] = arr
        return self._arrays

    @property
    def a(self):
        return self._arrays[self._dimension]

    @a.setter
    def a(self, new):
        if len(new) != self._dimension:
            raise ValueError('Wrong length, should be %d but was %d' %
                             (self._dimension, len(new)))
        self._arrays[self._dimension] = new


if __name__ == '__main__':
    a = My(5)
    b = My(5)
    c = My(10)
    print "# Instances of the same size get the same array:"
    print "a.a and b.a same instance: %r" % (a.a is b.a)
    print "a.a and c.a same instance: %r" % (a.a is c.a)

    a.a[0] = 'five'
    c.a[0] = 'ten'
    print "# Updating the arrays work:"
    print "a array contents: %r" % a.a
    print "b array contents: %r" % b.a
    print "c array contents: %r" % c.a

    a.a = list('abcde')  # new array
    print "# Changing the reference to a new array works:"
    print "a array contents: %r" % a.a
    print "b array contents: %r" % b.a

    print "# Size is protected:"
    a.a = [1, 2, 3]

In this class, each time an instance is created, the _arr method is called. It will create and store a new array of the correct length in the dictionary _arrays , which is a class member. The correct array for the current instance is looked up when the property a is accessed or changed.

You could also set self.a = self._arrays[self._dimension] but it won't work if you try to assign a new array like aa = [1, 2, 3] and you might also end up with an array of the wrong length. The setter takes care of checking that.

The output looks like this:

# Instances of the same size get the same array:
a.a and b.a same instance: True
a.a and c.a same instance: False
# Updating the arrays work:
a array contents: ['five', 1, 2, 3, 4]
b array contents: ['five', 1, 2, 3, 4]
c array contents: ['ten', 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Changing the reference to a new array works:
a array contents: ['a', 'b', 'c', 'd', 'e']
b array contents: ['a', 'b', 'c', 'd', 'e']
# Size is protected:
Traceback (most recent call last):
  File "arrays.py", line 47, in <module>
    a.a = [1, 2, 3]
  File "arrays.py", line 22, in a
    (self._dimension, len(new)))
ValueError: Wrong length, should be 5 but was 3

Answer 2

Here's another way to do it:

#!/usr/bin/env python

class My(object):
    arraystore = {}
    def __init__(self, n):
        if not n in My.arraystore:
            My.arraystore[n] = range(n)
        self.a = My.arraystore[n]

a5 = My(5)
print a5.a, id(a5.a)

a5.a[3] *= 10

b5 = My(5)
print b5.a, id(b5.a)

c = My(7)
print c.a, id(c.a)

typical output

[0, 1, 2, 3, 4] 3074609804
[0, 1, 2, 30, 4] 3074609804
[0, 1, 2, 3, 4, 5, 6] 3074604812

Answer 3

You could do it like this:

class My(object):
    a = None  # shared class attribute

    def __init__(self, N):
        My.arr(N)

    @classmethod
    def arr(cls, N):
        if cls.a is None:
            cls.a = list(range(N))
        elif len(cls.a) != N:
            raise ValueError('attempt to change dimension of "a"')

p1 = My(5)
p2 = My(5)
p1.a[0] = 42
print(p1.a)  # --> [42, 1, 2, 3, 4]
print(p2.a)  # --> [42, 1, 2, 3, 4]