why the value of `*args` is strange?

Question

Here is my code snappt:

class C(dict):
    def __init__(*args, **kwds):
        print 'args = {}'.format(args)
        print 'kwds = {}'.format(kwds)
        if not args:
            raise TypeError("descriptor '__init__' of 'Counter' object needs an argument")

        self = args[0]

        args = args[1:]

        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))

        super(C, self).__init__()


if __name__ == '__main__':
    c = C()

When i run this code, i am confused with the output:

C:\Users\elqstux\Desktop>python wy.py
args = ({},)
kwds = {}

For c = C(), i think the code will raise a Error, because args will be () in this case, but from the output, args is ({},), what't the reason?

self, args = args[0], args[1:] # allow the "self" keyword be passed

Possible duplicate of [What does \*\* (double star) and \* (star) do for Python parameters?](http://stackoverflow.com/questions/36901/what-does-double-star-and-star-do-for-python-parameters) — Jason, Apr 06 '16 at 02:32
@Signal, i know `*args` will be a `tuple`, but why it is `({},)` in my case, why not `()`? — BlackMamba, Apr 06 '16 at 02:33

ShadowRanger · Accepted Answer · 2016-04-07T16:04:31.353

6

*args is ({},) because you didn't declare an explicit self parameter. So when __init__ is called, the self parameter ends up becoming the first element in args. Since you inherit from dict, you get dict's repr, which is {}.

This trick is used intentionally in Python's dict subclasses nowadays, because otherwise code that initialized the dict subclass with mydict(self=123) would break the initializer. The fix is to do:

 def __init__(*args, **kwargs):
     self, *args = args
     # On Python 2 without unpacking generalizations you'd use the more repetitive:
     # self, args = args[0], args[1:]

which forces self to be accepted purely as a positional argument (which is passed implicitly by the instance construction machinery). For an example of real world usage, see the implementation of collections.Counter.

edited Apr 07 '16 at 16:04

answered Apr 06 '16 at 02:38

ShadowRanger

143,180
12
188
271

Why `mydict(self=123)` will break the legacy if i write `def __init__(self, *args, **kwds):`? what's the purpose using `def __init__(*args, **kwds):`? – BlackMamba Apr 06 '16 at 02:45
1

@BlackMamba: Try it out yourself. The problem is that when you accept `self` by name, it can be passed both positionally (by Python initialization machinery) and by keyword, and doing `mydict(self=123)` is now trying to pass `self` twice (instead of creating a `dict` with key `'self'`), which triggers `TypeError: __init__() got multiple values for argument 'self'`. Python isn't smart enough to use the positional `self` and put the keyword `self` in `kwargs`, so you need to help it out. – ShadowRanger Apr 06 '16 at 02:53
`self, args = args[0], args[1:] # allow the "self" keyword be passed·` – BlackMamba Apr 07 '16 at 06:44
@BlackMamba: That's how you'd have to do it in Python 2; in Python 3, using `*` in plain expressions (not just function calls) is possible (and generalized almost completely in 3.5), so you can do `self, *args = args` which is less repetitive and generalizes to other scenarios (`args` is always a sequence in this case so slicing is possible, but it couldn't be done w/an iterator/generator, while `x, *y, z = mygeneratorfunction()` still works seamlessly & fast in Py3, but would require the ugly/slow: `gen = mygeneratorfunction()`, `x = next(gen)`, `y = list(gen)`, `z = y.pop()` to work on Py2). – ShadowRanger Apr 07 '16 at 16:01

score 3 · Answer 2 · answered Apr 06 '16 at 02:38

I was intrigued by your output! The reason is clear enough: you ommitted self from the __init__ function definition. Running the example with a regular class will make it clear what happened:

>>> class C():
...   def __init__(*args, **kwargs):
...     print args, kwargs
...
>>> C()
(<__main__.C instance at 0x103152368>,) {}
<__main__.C instance at 0x103152368>

Of course, self got stuck into args as the single element of the args tuple. self is just like any other argument, after all.

What made it more puzzling in your case is that since you subclassed dict, the repr() of your class at that point was {}, i.e. the repr() of an empty dict. Hence the ({},).

score 1 · Answer 3 · answered Apr 06 '16 at 02:41

Your class __init__ function is being called with a single argument, the implicit self argument (i.e., the new class instance that's being created). Normally this would print as a class instance. But because the class subclasses dict, it prints as a dict, initially with no elements.

why the value of `*args` is strange?

3 Answers3