• Let's define a very simple function that has no parameters.

def do_nothing():
    pass      # indention is needed here

• We use the pass statement when we want Python to do nothing.
  • It's the equivalent of This page intentionally left blank.

• We call the do_nothing() function just by typing its name and parentheses.

do_nothing()

• Let's try a function that has no parameters but returns a value:

def agree():
    return True

• We can call the agree() function and test its returned value by using if:

if agree():
    print('Splendid!')
else:
    print('That was unexpected.')

• What did we get back?

print(comment)

• A function can take any number of input arguments (including zero) of any type.

• It can return any number of output results (also including zero) of any type.

• If a function doesn't call return explicitly, the caller gets the result None.

def do_nothing():
    pass
print(do_nothing())

• To distinguish None from a boolean False value, use Python's is operator:

thing = None
if thing is None:
    print("It's some thing")
else:
    print("It's no thing")

• Zero-valued numbers, empty strings (''), lists ([]), tuples ((,)), dictionaries ({}), and sets (set()) are all False, but are not the same as None.

• == is for value equality. It tests if two objects have the same value.

• is is for reference equality. It tests if two objects refer to the same object, i.e if they're identical.

a = [1, 2]
b = a
c = a[:]

a == b  # True or False?
a == c  # True or False?
a is b  # True or False?
a is c  # True or False?

• Let's write a quick function that prints whether its argument is None, True, or False:

def whatis(thing):
    if thing is None:
        print(thing, "is None")
    elif thing:
        print(thing, "is True")
    else:
        print(thing, "is False")

• Let's run some sanity tests:

whatis(None)
whatis(True)
whatis(False)

Positional Arguments

• A downside of positional arguments is that we need to remember the meaning of each position.

menu('beef', 'bagel', 'bordeaux')

Keyword Arguments

• To avoid positional argument confusion, we can specify arguments by the names of their corresponding parameters, even in a different order from their definition in the function:

menu(entree='beef', dessert='bagel', wine='bordeaux')
# Specify the wine first, but use keyword arguments for the entree and dessert:
menu('frontenac', dessert='flan', entree='fish')

• If we call a function with both positional and keyword arguments, the positional arguments need to come first.

• We can specify default values for parameters.
  • If we provide an argument, it's used instead of the default:

def menu(wine, entree, dessert='pudding'):
    return {'wine': wine, 'entree': entree, 'dessert': dessert}
menu('dunkelfelder', 'duck', 'doughnut')

• It would have worked if it had been written like this:

def works(arg):
    result = []
    result.append(arg)
    return result
works('a')
works('b')

• The fix is to pass in something else to indicate the first call:

def nonbuggy(arg, result=None):
    if result is None:
        result = []
    result.append(arg)
    print(result)
nonbuggy('a')
nonbuggy('b')

• If our function has required positional arguments, as well, put them first; *args goes at the end and grabs all the rest:

def print_more(required1, required2, *args):
    print('Need this one:', required1)
    print('Need this one too:', required2)
    print('All the rest:', args)
print_more('cap', 'gloves', 'scarf', 'monocle', 'mustache wax')

• We can pass positional argument to a function, which will match them inside to positional parameters.

• We can pass a tuple argument to a function, and inside it will be a tuple parameter.

• We can pass positional arguments to a function, and gather them inside as the parameter *args, which resolves to the tuple args.

• We can also "explode" a tuple argument called args to positional parameters *args inside the function, which will be regathered inside into the tuple parameter args:

def print_args(*args):
    print('Positional tuple:', args)
print_args(2, 5, 7, 'x')
args = (2,5,7,'x')
print_args(args)
print_args(*args)

• We can only use the * syntax in a function call or definition.

• Outside the function, *args explodes the tuple args into comma-separated positional parameters.

• Inside the function, *args gathers all of the positional arguments into a single args tuple.

• We can pass keyword arguments to a function, which will match them inside to keyword parameters.

• We can pass a dictionary argument to a function, and inside it will be dictionary parameters.

• We can pass one or more keyword arguments (name=value) to a function, and gather them inside as **kwargs, which resolves to the dictionary parameter called kwargs.

• Outside a function, **kwargs explodes a dictionary kwargs into name=value arguments.

• Inside a function, **kwargs gathers name=value arguments into the single dictionary parameter kwargs.

• a keyword-only argument is an argument that can only be provided as a keyword argument when a function is called.
  • It is recommended to be provided as name=value.

def print_data(data, *, start=0, end=100):
    for value in (data[start:end]):
        print(value)

• The single * in the definition above means that the parameters start and end must be provided as named arguments if we don’t want their default values.

def print_data2(data, *, start, end):
    for value in data[start:end]:
        print(value)
print_data2(data)
print_data2(data, start=4)
print_data2(data, end=2)
print_data2(data, start = 2, end = 4)

• start and end are required arguments, because they doesn't have a default value and they must be specified as a keyword argument when we call the print_data2() function.

• If we don’t provide your own exception handler, Python prints an error message and some information about where the error occurred and then terminates the program:

short_list = [1, 2, 3]
position = 5
short_list[position]

short_list = [1, 2, 3]
position = 5
try:
    short_list[position]
except:
    print('Need a position between 0 and', len(short_list)-1, ' but got',
    position)

• The code inside the try block is run.
  • If there is an error, an exception is raised and the code inside the except block runs.
• If there are no errors, the except block is skipped.

• Specifying a plain except with no arguments, as we did here, is a catchall for any exception type.

• If more than one type of exception could occur, it’s best to provide a separate exception handler for each.

• We get the full exception object in the variable name if we use the form:

short_list = [1, 2, 3]
while True:
    value = input('Position [q to quit]? ')
    if value == 'q':
        break
    try:
        position = int(value)
        print(short_list[position])
    except IndexError as err:
        print('Bad index:', position)
    except Exception as other:
        print('Something else broke:', other)

• The example looks for an IndexError first, because that’s the exception type raised when we provide an illegal position to a sequence.

• It saves an IndexError exception in the variable err, and any other exception in the variable other.

• The example prints everything stored in other to show what you get in that object.

  • Inputting position 3 raised an IndexError as expected.
  • Entering two annoyed the int() function, which we handled in our second, catchall except code.