[Tutor] Don't understand this class/constructor call syntax

[dave]

Thank you for the two explanations.  I think I have a good idea of what is
going on now with the arguments and keyword arguments.

My only remaining question is the pad_for_usrp argument.  The default value is
True so I thought it was a boolean and couldn't have anything to do with the
"self<transmit_path>" that was passed to it.  However, I can probably puzzle
that out by looking at how it's used in the code.  

If you want to look at the full code and make any more comments, the code tree
is here: https://www.cgran.org/browser/projects/ucla_zigbee_phy/trunk/src

The example I'm looking at is (I quoted line 56):
https://www.cgran.org/browser/projects/ucla_zigbee_phy/trunk/src/examples/cc2420_txtest.py

The example relies on two files.  This one:
https://www.cgran.org/browser/projects/ucla_zigbee_phy/trunk/src/python/ieee802_15_4.py

And this one (I quoted the class at line 138):
https://www.cgran.org/browser/projects/ucla_zigbee_phy/trunk/src/python/ieee802_15_4_pkt.py

Thanks,
Dave


On Sat, 23 Jul 2011 13:09:07 +1000, Steven D'Aprano wrote
> dave wrote:
> 
> > class transmit_path(gr.top_block)
> [...]
> >         self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts(self,
> >                                   spb=self._spb, msgq_limit=2)
> 
> This calls the ieee802_15_4_mod_pkts initializer (not a constructor -
> - see below) with one positional argument and two keyword arguments.
> 
> The positional argument is "self", that is, the transmit_path instance.
> 
> The keyword arguments are called spb and msgq_limit; spb is set to 
> the value of self._spb, and msgq_limit is set to 2.
> 
> The reason I say this is an initializer and not a constructor is 
> that Python treats the two as different. The constructor that 
> creates the instance is called __new__ not __init__. When __init__ 
> is called, the instance has already been constructed, and is now 
> being initialized. The reason for this is mostly historical, 
> although it is useful.
> 
> (Disclaimer -- so called "old style" or "classic" classes don't have 
> a __new__ method, and you cannot customize the actual creation of 
> the instance, only the initialization.)
> 
> Looking at the ieee802_15_4_mod_pkts initializer:
> 
> > class ieee802_15_4_mod_pkts(gr.hier_block2):
> >     def __init__(self, pad_for_usrp=True, *args, **kwargs):[/code]
> 
> As a method, this takes the instance as first argument (called 
> "self"), plus one named argument "pad_for_usrp", an arbitrary number 
> of unnamed positional arguments collected into "args", and an 
> arbitrary number of named keyword arguments collected into "kwargs".
> 
> (Note that args and kwargs are conventions. You could call them 
> anything you like -- the "magic", so to speak, comes from the 
> leading * and ** and not from the names.)
> 
> Given the call:
> 
> ieee802_15_4_mod_pkts(self, spb=self._spb, msgq_limit=2)
> 
> this corresponds to the initializer receiving arguments:
> 
> self = the freshly created ieee802_15_4_mod_pkts instance
> pad_for_usrp = the transmit_path instance doing the calling
> args = an empty tuple (no positional arguments collect)
> kwargs = a dictionary of keyword arguments
>           {'spb': value of _spb of the transmit_path instance,
>            'msgq_limit': 2}
> 
> > What I don't understand is the call to the constructor and the constructor
> > definition.  Since it's using a number of advanced features, I'm having
> > trouble looking it all up in documentation.
> > 
> > What does it mean to call with spb=self._spb?  In the example file, spb is set
> > = to 2 and so is self._spb.  Is it a sort of pass by reference like C while
> > also assigning a value? Why the  ** on kwargs then? as if it is a matrix
> 
> No, this is nothing to do with pass by reference, or pass by value 
> either. This often confuses people coming to Python from some other 
> languages, and if it isn't a FAQ it ought to be. You can read one of 
> my posts on this here:
> 
> http://www.mail-archive.com/tutor%40python.org/msg46612.html
> 
> and the Wikipedia article:
> 
> http://en.wikipedia.org/wiki/Evaluation_strategy
> 
> What it means is that the method being called (in this case, 
> ieee802_15_4_mod_pkts.__init__) sees a keyword argument called 
> "spb". This keyword argument has name "spb", and value whatever 
> self._spb has at the time it is called.
> 
> When Python allocates arguments to the named parameters in a method 
> or function, its basic process is roughly something like this:
> 
> (1) for methods, automatically assign the instance being called to 
> the first named parameter (usually called "self" by convention);
> 
> (2) take each positional argument from the caller and assign it to 
> the remaining positional parameters, from left to right;
> 
> (3) assign any keyword arguments, raising an error if it duplicates 
> a value already seen;
> 
> (4) raise an error if any unassigned parameter doesn't have a 
> default value;
> 
> (5) collect any left over positional arguments into the *args parameter;
> 
> (6) collect any left over keyword arguments into the **kwargs parameter.
> 
> > (and does anyone have any idea what kwargs are (as opposed to args)?)
> 
> Positional arguments: function(1, 2)
> Keyword arguments: function(a=1, b=2)
> 
> > I'm uncertain about the first argument, but I guess it must be the
> > transmit_path object passed in place of the usually implicit self...  I'm just
> > not sure how Python figures out that it's not pad_for_usrp... magic I guess!
> 
> I don't think that it is used as the implicit self. I think it is 
> the pad_for_usrp.
> 
> -- 
> Steven
> 
> _______________________________________________
> Tutor maillist  -  Tutor at python.org
> To unsubscribe or change subscription options:
> http://mail.python.org/mailman/listinfo/tutor


--
Open WebMail Project (http://openwebmail.org)