Back to functions (less basics)

A function is a block of organized, reusable code that is used to perform a single, related action. Functions provide better modularity for your application and a high degree of code reusing.

Simple function definitions and calls¶

Function blocks begin with the keyword def followed by the function name and parentheses (()).

• The code block within every function starts with a colon (:) and is indented.

• Any input parameters or arguments should be placed within these parentheses.

def print_hello():
    "hello printer"
    print("hello")


def myprint(my_var):
    "my hello printer"
    print("I print", my_var)


# function calls
print_hello()
print_hello()
myprint("First call of myprint")
myprint("Second call of myprint")

hello
hello
I print First call of myprint
I print Second call of myprint

• The first statement of a function can be the documentation string of the function, also called “docstring”.

• The statement return [expression] exits a function, optionally passing back an expression to the caller. No return statement or a return statement with no arguments is the same as return None.

All Python functions return exactly one object but... None and tuple¶

type(print())

The history saving thread hit an unexpected error (OperationalError('attempt to write a readonly database')).History will not be written to the database.

def return_a_tuple():
    return 1, "hello", 3  # a tuple, same as (1, 'hello', 3)


my_tuple = return_a_tuple()
print(my_tuple)

(1, 'hello', 3)

a, b, c = return_a_tuple()
print(b)

hello

Function call: namespaces and objects “passed by references”¶

For each function call:

• a new namespace is created (as at the beginning of a module)

• the objects are “passed by references”: new names of the arguments are created in the function namespace and they point towards the objects given as arguments to the function (so it is possible to modify the mutable objects).

Global vs Local variables¶

Variables that are defined inside a function body have a local scope (i.e. are defined in the function namespace), and those defined outside have a global scope.

This means that local variables can be accessed only inside the function in which they are declared, whereas global variables can be accessed throughout the module by all functions.

# global variables
result = 0
multiplicator = 2


def multiply(arg0):
    # here we create a new name `result` in the function namespace
    # `result` is a local variable
    # we can use the global variable `multiplicator`
    result = multiplicator * arg0
    print("Inside the function local result:\t", result)
    return result


multiply(10)
print("Outside the function global result:\t", result)

Inside the function local result:	 20
Outside the function global result:	 0

• Global variables can be used in a function.

• Global variables can not be modified in a function (except with the global keyword. Discourage!).

global keyword¶

There is a keyword global to define inside a function a global variable and to modify a global variable in the function. It is often a bad idea to use it :-)

def func():
    global me
    # Defined locally but declared as global
    me = "global variable locally defined"
    print(me)


func()
# Ask for a global variable
print(me)

global variable locally defined
global variable locally defined

delta = 0


def add_1_to_delta():
    global delta
    # global variable modified in a function
    delta += 1


for i in range(4):
    add_1_to_delta()
    print(delta, end=", ")

1, 2, 3, 4, 

Function Arguments¶

You can call a function by using the following types of formal arguments:

• Required arguments

• Keyword arguments

• Default arguments

• Variable-length arguments

Required arguments¶

Required arguments are the arguments passed to a function in correct positional order. Here, the number of arguments in the function call should match exactly with the function definition.

def power(value, n):
    "Return value to power n"
    result = value**n
    print(f"value^n = {value}^{n} = {result}")
    return result


power(10, 2)

value^n = 10^2 = 100

To call the function power, you definitely need to pass two arguments, otherwise it gives a syntax error.

Keyword arguments¶

Keyword arguments are related to the function calls. When you use keyword arguments in a function call, Python identifies the arguments by the parameter name.

power(n=2, value=10)

value^n = 10^2 = 100

Default arguments¶

A default argument is an argument that assumes a default value if a value is not provided in the function call for that argument.

def power_def(value, n=2):
    "Return value to power n. By default: return value to power 2."
    result = value**n
    print(f"value^n = {value}^{n} = {result}")
    return result


power_def(10)

value^n = 10^2 = 100

power_def(10, 3)

value^n = 10^3 = 1000

def do_not_use_mutable_object_for_default_arg(l=[]):
    l.append(1)
    print(l)

def do_not_use_mutable_object_for_default_arg(l=[]):
    l.append(1)
    print(l)

do_not_use_mutable_object_for_default_arg()
do_not_use_mutable_object_for_default_arg()
do_not_use_mutable_object_for_default_arg()

[1]
[1, 1]
[1, 1, 1]

def how_to_use_list_as_default_arg(l=None):
    if l is None:
        l = []
    l.append(1)
    print(l)


how_to_use_list_as_default_arg()
how_to_use_list_as_default_arg()
how_to_use_list_as_default_arg()
l1 = [1, 2, 3]
how_to_use_list_as_default_arg(l1)
l1

[1]
[1]
[1]
[1, 2, 3, 1]

Variable-length arguments¶

You may need to process a function for more arguments than you specified while defining the function. These arguments are called variable-length arguments and are not named in the function definition, unlike required and default arguments.

An asterisk (*) is placed before the variable name that holds the values of all nonkeyword variable arguments.

def sum_args(*args):
    """Return the sum of numbers."""
    totalsum = 0
    print("args =", args)
    for var in args:
        totalsum += var
    print("totalsum =", totalsum)
    return totalsum


sum_args()
sum_args(4)
sum_args(4, 3, 4, 7)

args = ()
totalsum = 0
args = (4,)
totalsum = 4
args = (4, 3, 4, 7)
totalsum = 18

There is also a (very useful) syntax with two asterisks **, which works like this:

def func(a, b, *args, **kwargs):
    print(f"call:\n\ta = {a}\n\targs = {args}\n\tkwargs = {kwargs}")


func(1, 2, 3, toto=3, titi=3)
func("a", "b", bob=3)

call:
	a = 1
	args = (3,)
	kwargs = {'toto': 3, 'titi': 3}
call:
	a = a
	args = ()
	kwargs = {'bob': 3}

def func(l, a=2):
    for i, val in enumerate(l):
        l[i] = a * val


l = list(range(3))
print(l)
func(l)
print(l)
func(l, 4)
print(l)
l = ["a", "b"]
func(l, 4)
print(l)

[0, 1, 2]
[0, 2, 4]
[0, 8, 16]
['aaaa', 'bbbb']

lambda keyword and anonymous functions¶

These functions are called anonymous because they are not declared by using the def keyword but with the lambda keyword so they have not name.

• Lambda forms can take any number of arguments but return just one value in the form of an expression. They cannot contain commands or multiple expressions.

• Lambda form is used in functional programming (but it is usually better to use list comprehension) and for callbacks in GUI.

f = lambda x, y: x + y
f(1, 2)

Example of the builtin function print¶

In [1]: print?
Docstring:
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file:  a file-like object (stream); defaults to the current sys.stdout.
sep:   string inserted between values, default a space.
end:   string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
Type:      builtin_function_or_method

print("hello", "Eric")

hello Eric

print("hello", "Eric", sep="_", end="")
print(".")

hello_Eric.

Input from Keyboard (builtin function input)¶

answer = input("what's your name ?")
print("your name is ", answer)