Question

I need help with parameteres. Do both of these function definitions do the exact same thing for print_twice?

def print_twice(lol):
    print lol
    print lol

def print_twice(michael):
    print michael
    print michael

If yes, then I’m guessing the word used for the parameter doesn’t matter, correct?

Answer 1

The word we use for the parameter does matter. It is important that the word you use:

• is meaningful and clearly explains what the argument is for,
• does not override some variable name from the external scope.

Importance of meaningful arguments’ names

The name you use for argument is important, because the names of the arguments, their default values and the function name are the things developers using your function first see, even without the need to look into function documentation (eg. by using help(your_function)). Just use IDLE to define your function and then try to use it – when writing it, the IDLE will show you possible arguments.

So please, give them meaningful names that will make using your function easier and will not require looking into the documentation.

Overriding variables from outer scopes

When it comes to the second point, just look at this example:

def show_elements(elements):
    """Shows elements of the passed argument
    """
    for element in elements:
        print element

which works ok, but if you replace elements with eg. list, you will override list within this specific scope:

def show_elements(list):
    """Shows elements of the passed argument
    """
    for element in list:
        print element

and then if you would like to use list eg. for building a list, or converting from other type into list, then you will have problems. list is a builtin and you should not override it. Similar is true also about the other variables from the scopes surrounding the function.

Historically, when Python was resolving variable names by first looking into local scope, then global and builtin scopes, skipping all nonlocal ones (eg. scope from the function in which our function was defined), enclosing scope’s variables were passed that way:

def funca():
    local_val1 = 'some value1'
    local_val2 = 'some value2'
    def funcb(local_val1=local_val1):
        # local_val1 is accessible here, even though local_val2 is not
        ...
    ...

But since the above is no longer true, you will need to take surrounding scopes into account, thus using non-conflicting name is important.