Understand Python Function

Question

I'm learning Python and wanted to see if anyone could help break down and understand what this function does step by step?

def label(self, index, *args): 
    """ 
    Label each axes one at a time 
    args are of the form <label 1>,...,<label n> 
    APIPARAM: chxl 
    """ 
    self.data['labels'].append( 
    str('%s:|%s'%(index, '|'.join(map(str,args)) )).replace('None','') 
    ) 
    return self.parent

Which parts of it do you not understand? It's a class method, so the return value `self.parent` is defined elsewhere. Otherwise, it's doing some string manipulation and appending to a list. — g.d.d.c, Oct 24 '12 at 21:49
@g.d.d.c For someone new to Python this is not exactly obvious, the syntax is python-specific and there are couple of functions not seen in "Hello World" examples. — kgr, Oct 24 '12 at 22:00
@kgr thanks that's exactly right, although I usually find it best to ignore the trolls. — rolling stone, Oct 24 '12 at 22:49
PS, Part of the reason this is confusing is that it's bad code. The outer `str` is completely unnecessary. Unconditionally calling `str` on each arg and then doing `replace('None','')` on the joined result, rather than just doing the right conversion in the first place, is confusing (and a red flag that someone hasn't learned list comprehensions…). Of course you do need to learn how to read code like this anyway, but it's worth knowing that this is as much the original coder's fault than your own, so you don't get too down on yourself. — abarnert, Oct 25 '12 at 00:07
@abarnert that was my thought too, looks as if someone wanted to show off and let others know how much of a hardcore programmer he or she is ignoring the readability of the code and some python guidelines along the way. — kgr, Oct 25 '12 at 10:37

score 3 · Accepted Answer · edited May 23 '17 at 12:27

It's a good idea to change the formatting, before trying to understand what it does:

def label(self, index, *args): 
    """ 
    Label each axes one at a time 
    args are of the form <label 1>,...,<label n> 
    APIPARAM: chxl 
    """ 
    self.data['labels'].append( 
        str( '%s:|%s' % \ 
            ( index, '|'.join( map( str,args ) ) ) 
        ).replace( 'None', '' ) 
    ) 
    return self.parent

So:

it appends something to self.data[ 'labels' ] list. We know this because append() is a method of list object.

This something is a string such that:

string is of the form xxx:|yyy
xxx is replaced with the value of argument index
yyy is replaced with all the other arguments converted to strings (map(str,args)) and joined with | character (join(...)) so resulting in something like 'a|b|None|c'
every occurence of None in the string above is replaced with an empty string and this is appended to the list

EDIT:

As @abarnert pointed out it might be good to explain what does *args mean and why later on it's used as args, so here it goes.

*args (which is an asterisk + an arbitrary name) means "any number of anonymous arguments available further in args list". One can also use **kwargs - note two asterisk which is used for accepting keyworded arguments, i.e. ones passed to the function in the form of foo = bar where foo is the name of the argument and bar is its value rather than just bar.

As said above args and kwargs are arbitrary, one could just as well use *potatoes or **potatoes but using args and kwargs is a convention in Python (sometimes people also use **kw instead of **kwargs, but the meaning is the same - any number of anonymous and any number of keyworded arguments respectively).

Both are used if the number of arguments which the function/method should accept is not known beforehand - consider for a example a function which processes names of the party guests, one may not know how many there may be, so defining a following function makes sense:

def add_party_quests( *quests ):
    for guest in quests:
        do_some_processing( guest )

Then both calls below are valid:

add_party_guests( 'John' )
add_party_guests( 'Beth', 'Tim', 'Fred' )

This is also explained in this SO post: https://stackoverflow.com/a/287101/680238

This is the best answer here, but it's missing an explanation of how `args` works, which might be easier to show with an example rather than trying to describe it. — abarnert, Oct 24 '12 at 23:29
@kgr so the explanation of how `args` work actually led me to solve the original problem I had, and why I was trying to figure out what this function was doing in the first place. The link to my original question is below, you should add your answer there as well and I'll accept it as the answer for that question. http://stackoverflow.com/questions/13055783/create-dynamic-labels-for-google-chart-using-gchartwrapper — rolling stone, Oct 25 '12 at 01:39
@rollingstone Didn't notice the other question :) I have added an answer which shows the proper call syntax and links to this answer for more details. — kgr, Oct 25 '12 at 10:35

score 2 · Answer 2 · answered Oct 24 '12 at 21:56

I assume the misleading lines are:

self.data['labels'].append( 
str('%s:|%s'%(index, '|'.join(map(str,args)) )).replace('None','') 
)

Those can be formatted more clearly to aid reading:

self.data['labels'].append( 
    str('%s:|%s' % (
        index,
        '|'.join(map(str, args))
    )).replace('None', '') 
)

But can be better rewritten as:

self.data['labels'].append(  # append to the list at `self.data['labels']`
    '%s:|%s' % (             # a string of the format X:|Y
        index,               # where X is the index
        '|'.join(            # and Y is a list joined with '|'s
            str(arg) if arg is not None else  # with each item in the list
            '' for arg in args                # being it's string representation
        )
    )
)

This is a nice rewrite, but I think you then need to explain how `map(str, args)` and the generator expression relate to each other. — abarnert, Oct 25 '12 at 00:01

score 1 · Answer 3 · answered Oct 24 '12 at 21:54

*args turns into a list of arguments called args. self.data['labels'] looks to be a list. .append adds an item to the list. The item appended is returned by the string returned by the right most part, replace. To parse what string that is, start inside the parens and work your way out. map(str,args) converts all the args to strings and returns that list. '|'.join( takes the output of map and joins it into a single string, of the general pattern elem1|elem2|elem3..., it then uses the format string '%s:|%s'. The first %s gets replaced by the value of index, the second by the string output by '|'.join. It then calls replace on this string, replacing all occurences of 'None' with ''. Then it returns self.parent.

Understand Python Function

3 Answers3

Linked