Python Parameters (beginner)
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: 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**.

