argument unpacking and assignment to class variables

Question

Hi I have the following code, which attempts to create an instance of a class and assign argument values to it. I am trying to use *args to do this as follows:

def main():
    testdata = ['FDR', False, 4, 1933]
    apresident = President(testdata)
    print apresident
    print apresident.alive

class President:
    id_iter = itertools.count(1)
    #def __init__(self, president, alive, terms, firstelected):
    def __init__(self, *args):
        self.id = self.id_iter.next()
        self.president = args[0]
        self.alive = args[1]
        self.terms = args[2]
        self.firstelected = args[3]

I get a "tuple index out of range" error. As you can see from the commented line, I was previously using positional arguments to accomplish this (which worked), and used lines like the following to do it:

    self.president = president

What is the right way to use *args in this case? should I be using *kwargs?

ok, so I see that adding the * is how you make it work as I intended. I intend to extend the functionality of the class, and would like to add additional properties to it later, all of which might not, at some point, be needed for each instance of "President", for this toy example, "datedied". I am beginning to think I should use *kwargs for this purpose, but how would I then assign them within the class? — domoarigato, Aug 24 '13 at 16:57

Zero Piraeus · Accepted Answer · 2013-08-24T17:10:44.157

You're passing only one argument to President(), which is the list

['FDR', False, 4, 1933]

If you want to pass the items in that list as separate arguments, you do it like this:

    apresident = President(*testdata)  # note the * character

As Colonel Panic points out, in your example the use of argument-unpacking is a little pointless - presumably your actual use case is more complex, and justifies its use.

UPDATE:

Your comment is really a follow-up question which would be better as a separate question, but:

def main():
    testdata = {
        "president": "FDR",
        "alive": False,
        "terms": 4,
        "firstelected": 1933,
    }
    apresident = President(**testdata)
    anotherpresident = President(president="BHO", terms=2, firstelected=2008)
    print apresident
    print apresident.alive
    print anotherpresident
    print anotherpresident.alive

class President:
    id_iter = itertools.count(1)
    #def __init__(self, president, alive, terms, firstelected):
    def __init__(self, **kwargs):
        self.id = self.id_iter.next()
        self.president = kwargs.get("president", None)
        self.alive = kwargs.get("alive", True)
        self.terms = kwargs.get("president", 1)
        self.firstelected = kwargs.get("president", None)

This shows how you can define default values as well.

this is precisely what I am trying to do. I selected this answer for that reason, although I agree that Colonel Panic's answer also answered my original question as it was originally posed. I don't have enough reputation to upvote him though. — domoarigato, Aug 24 '13 at 17:20

score 2 · Answer 2 · edited May 23 '17 at 12:06

You should only use *args if you do not know how many arguments will be passed to function.

In your case, it looks like you need all of president, alive, terms, firstelected. There is nothing wrong with having a constructor that takes all of those as parameters.

*kwargs is used for a few reasons. One is if you have default values that should be used, unless the user wants to specify them.

For more info, see this question, this question, and the official documentation.

In response to your comment

I would recommend you do have the datedied property for each president. If they haven't died yet, then the value should be None. When you extend only certain instances with functionality, it becomes harder (but not impossible) to reason about the code.

Having said that, if you wanted arbitrary properties for each president that clearly won't be applicable to each instance, then you could use keyword arguments. But adding properties isn't limited to the constructor. I would simply use setattr() and getattr().

How to set class properties with kwargs

class President(object):
   def __init__(self, *args, **kwargs):
      for name, value in kwargs.items():
         # Make each keyword-argument a property of the class.
         setattr(self, name, value)

tVar = President(is_cool=True)
print tVar.is_cool # Returns True

Fair, and perhaps it is a bad example. Ultimately, id like to instantiate the class, using fairly arbitrary properties, without regard to the order that those properties might appear in the list or dictionary that is being passed to them so as not to have to fuss too much with the underlying class. If non-assigned properties end up being None, that would be fine with me. — domoarigato, Aug 24 '13 at 17:10
I have edited the question to show what you want to do with kwargs. — Colonel Panic, Aug 24 '13 at 17:14

score 1 · Answer 3 · answered Aug 24 '13 at 16:44

You're calling President(testdata), when you should be doing President(*testdata) in order to unpack the list as you call the constructor.

Right now, you're essentially passing a single argument (the list), hence the IndexError: you're passing a single argument, so args is equal to [testdata] and not testdata.

As mentioned in the other answer though, it's not very Pythonic to use *args in your constructor here. You know which arguments you expect, so just use these.

It's OK-ish to use it when you call the function, though.

argument unpacking and assignment to class variables

3 Answers3

In response to your comment

How to set class properties with kwargs