如何从python的zip继承而使用class attrs？

Question

I ran into an interesting issue... I was trying to SubClass python's zip type... I wanted to create a class that acted as a zip yet has class attrs.

At First I tried

class SomeClass(zip):
    def __init__(self):
        print('I ran')
        self.x = np.array([1,2,3,4])
        self.y = np.array([1,4,9,16])
        super().__init__(self.x,self.y)

But it seems like zip 's __init__ takes nothing but self ?

So I tried

class SomeClass(zip):
    def __init__(self):
        self.x = np.array([1, 2, 3, 4])
        self.y = np.array([1, 4, 9, 16])

    def new(self):
        return zip.__new__(SomeClass, self.x, self.y)

Which works but requires I do x=SomeClass().new()

Finally I got to this...

class SomeClass(zip):
    def __init__(self):
        print('I ran')
        self.x = np.array([1,2,3,4])
        self.y = np.array([1,4,9,16])
    def __new__(self):
        self.__init__(self)
        return zip.__new__(self, self.x, self.y)

for i in SomeClass():
...     print(i)
...
I ran
I ran
(1, 1)
(2, 4)
(3, 9)
(4, 16)

This runs __init__ twice... I am just curious if there is a way to circumvent this or will class attrs never exist at the time __new__ runs?

UPDATE: This ALMOST works

class SomeClass(zip):
    def __new__(self):
        self.x = np.array([1,2,3,4])
        self.y = np.array([1,4,9,16])
        return super().__new__(self, self.x, self.y)

How ever x and y are not instance variables :(. Example

class SomeClass(zip):
    def __new__(self, x, y):
        self.x = x
        self.y = y
        return super().__new__(self, self.x, self.y)

>>> k=SomeClass([1,2],[3,4])
>>> k.x
[1, 2]
>>> j=SomeClass([2,2],[4,4])
>>> j.x
[2, 2]
>>> k.x
[2, 2]

Why is this?

Answer 1

Your problem is that you're trying to use the object attributes self.x and self.y in __new__ , where self doesn't actually exist yet. (The thing you've so inappropriately labeled self is actually the class.) You're going about this backwards. First, __new__ must create an object ( self ), and only then can you call __init__ . (You shouldn't, though, because python will do it for you automatically.)

Now, as you've already found out, you have to have access to x and y before __init__ is executed (because you have to pass them to zip.__new__ ). Because of this, it's easiest to initialize x and y directly in __new__ . (The __init__ then no longer serves a purpose, so it can be removed.)

class SomeClass(zip):
    def __new__(cls):
        x = [1, 2, 3, 4]
        y = [1, 4, 9, 16]

        obj = super().__new__(cls, x, y)

        obj.x = x
        obj.y = y
        return obj

    def __init__(self):
        print('I ran')

Demo:

>>> k = SomeClass()
I ran
>>> k.x
[1, 2, 3, 4]
>>> k.y
[1, 4, 9, 16]
>>> list(k)
[(1, 1), (2, 4), (3, 9), (4, 16)]

Answer 2

zip doesn't define __init__ . super().__init__ actually calls object.__init__ (since in this example, the MRO consists of just SomeClass , zip , and object ), which expects no arguments. After calling that, you can set your own attributes.

class SomeClass(zip):
    def __init__(self, *args, **kwargs):
        super().__init__(**kwargs)
        self.x = np.array([1,2,3,4])
        self.y = np.array([1,4,9,16])

If you don't care about cooperative inheritance, you can simplify it to

class SomeClass(zip):
    def __init__(self, *args):
        self.x = np.array([1,2,3,4])
        self.y = np.array([1,4,9,16])

Answer 3

While I'm not sure to understand the purpose of this, you can do it by using delegation instead of inheritance:

class SomeClass:
    def __init__(self):
        self.x = [1,2,3,4]
        self.y = [1,4,9,16]
        self.zipp = zip(self.x, self.y)

    def __iter__(self):
        return self.zipp

for x, y in SomeClass():
    print(x, y)