Basic function definition:

Use def keyword to define a function.
Function names should be lowercase (get_message).
The code inside the function must be indented.
The colon character (:) is required after the function signature.

Function parameters and arguments:
Parameters are variables in the function definition.
Arguments are actual values passed when calling the function.

def hello():
  """A simple function that print a hello message."""
  print('Hello!')

# calling hello function
hello()

Output:

Hello!

Return values:

• Single return value.

  def add(i, j):
    return i+j
  
  print(add(3, 5)) # Output: 8

• Multiple return values.

  def div(i, j):
    return i//j, i%j
  
  quotient, remainder = div(7, 2)
  print(f'quotient:{quotient}, remainder:{remainder}') # Output: quotient:3, remainder:1

Positional arguments:

def info(firstname, lastname):
  print(f'firstname: {firstname} | lastname: {lastname}')

# call info function with argument 'A' for the parameter firstname and argument 'B' for the parameter lastname
info('fn_A', 'ln_B')

Output:

firstname: fn_A | lastname: ln_B

Keywords arguments:

def info(firstname, lastname):
  print(f'firstname: {firstname} | lastname: {lastname}')

# explicitly naming the parameters of the function
info(firstname='fn_C', lastname='ln_D')

# the order of the arguments doesn't matter when explicitly naming the parameters
info(lastname='ln_F', firstname='fn_E')

Output:

firstname: fn_C | lastname: ln_D
firstname: fn_E | lastname: ln_F

Mixing positional and keywords arguments:

Positional arguments must be listed first.

def info(firstname, lastname):
  print(f'firstname: {firstname} | lastname: {lastname}')

# mixed positional and keywords arguments
info('fn_G', lastname='ln_H')

Output:

firstname: fn_G | lastname: ln_H

Arbitrary positional arguments (*args):

Passing an arbitrary number of arguments.

# python creates a tuple named values that will contain all the arguments
def print_values(*values):
  print(values)

print_values() # Output: ()
print_values(1) # Output: (1,)
print_values(1, 2) # Output: (1, 2)

# unpacking lists
list1 = [1, 2, 3]
print_values(*list1) # Output: (1, 2, 3)

# unpacking tuples
tuple1 = (1, 2, 3)
print_values(*tuple1) # Output: (1, 2, 3)

Mixing regular arguments and *args:

def print_values(key, *values):
  print(f'{key}={values}')

# the key argument is required
#print_values() # Raises TypeError: print_values() missing 1 required positional argument: 'key'

print_values('none') # Output: none=()
print_values('one', 'a') # Output: one=('a',)
print_values('two', 'a', 'b') # Output: two=('a', 'b')

Arbitrary keyword arguments (**kwargs)

Passing an arbitrary number of key-value pair as arguments.

# python creates a dictionary named values that will contain all the arguments
def print_values(**values):
  print(values)

print_values() # Output: {}
print_values(a=1) # Output: {'a': 1}
print_values(a=1, b=2) # Output: {'a': 1, 'b': 2}
print_values(a=1, b=2, c=3) # Output: {'a': 1, 'b': 2, 'c': 3}

Mixing regular arguments and **kwargs:

Passing regular and arbitrary number of key-value pair as arguments.

def print_values(key, **values):
  print(values[key])

# the key argument is required
#print_values('a') # Raises KeyError: 'a'

print_values('a', a=1) # Output: 1
print_values('b', a=1, b=2) # Output: 2
print_values('c', a=1, b=2, c=3) # Output: 3

Combining all parameter types:

def print_values(msg, *args, **kwargs):
  print(f'msg:{msg}, args:{args}, kwargs:{kwargs}')

print_values('hello', 1, a=1) # Output: msg:hello, args:(1,), kwargs:{'a': 1}

Default parameters:

def info(firstname, lastname='unknown'):
  print(f'firstname: {firstname} | lastname: {lastname}')

# using default with positional argument for the first parameter
info('fn_A') # the second argument is missing, defaults to 'unknown'

# using default with keyword argument for the first parameter
info(firstname='fn_B') # the second argument is missing, defaults to 'unknown'

# overriding the default value
info(firstname='fn_C', lastname='ln_D')

Output:

firstname: fn_A | lastname: unknown
firstname: fn_B | lastname: unknown
firstname: fn_C | lastname: ln_D

Mutable defaults:

You need to avoid mutable defaults like lists or dictionaries.

# using mutable default
def add_message(msg, messages=[]):
  messages.append(msg)
  return messages

print(add_message("hello")) # Output: ['hello']
print(add_message("python")) # Output: ['hello', 'python']

To fix the issue, use None:

def add_message(msg, messages=None):
  if messages is None:
    messages = []
  messages.append(msg)
  return messages

print(add_message("hello")) # Output: ['hello']
print(add_message("python")) # Output: ['python']

Passing lists as arguments:

def pop(x):
  return x.pop()

y = [1, 2, 3]
print(pop(y)) # Output: 3
print(y) # Output: [1, 2]

Passing a copy of a list as an argument:

def pop(x):
  return x.pop()

y = [1, 2, 3]
print(pop(y[:])) # Output: 3 (passing a list slice as argument)
print(y) # Output: [1, 2, 3]

Working with lists copies:

def append(i, list1, list2, list3):
  # modify the original list
  list1.append(i)

  # create new copy
  list_copy = list2.copy()
  list_copy.append(i)

  # create new copy
  list_another_copy = list3[:]
  list_another_copy.append(i)

  return list1, list_copy, list_another_copy

y1 = [1]
y2 = [2]
y3 = [3]
z1, z2, z3 = append(4, y1, y2, y3)
print(f'y1:{y1}, y2:{y2}, y3:{y3}') # Output: y1:[1, 4], y2:[2], y3:[3]
print(f'z1:{z1}, z2:{z2}, z3:{z3}') # Output: z1:[1, 4], z2:[2, 4], z3:[3, 4]

Local and global variables

global_var = "hello"
def use_global_local():
  local_var = "python!"
  print(f'{global_var} {local_var}') # Output: hello python!

def update_global():
  global global_var
  global_var = "hello python!" # the global variable will be changed
  print(global_var) # Output: hello python!

def shadow_global():
  # shadowing the global variable
  global_var = "hello!" # the global variable won't be changed
  print(global_var) # Output: hello!

use_global_local()
print(global_var) # Output: hello

update_global()
print(global_var) # Output: hello python!

shadow_global()
print(global_var) # Output: hello python!

Lambda functions

• Basic lambda:

  square = lambda x: x ** 2
  print(square(3)) # Output: 9

• Lambda with multiple arguments:

  add = lambda x, y: x + y
  print(add(3, 6)) # Output: 9

• Lambda with map function:

  print(list(map(lambda x: x ** 2, [1, 2, 3]))) # Output: [1, 4, 9]

• Lambda with filter function:

  print(list(filter(lambda x: x % 2 == 0, [1, 2, 3]))) # Output: [2]

• Sorting with lambda:

  x = ['abcd', 'abc', 'ab', 'a']
  x.sort(key=lambda i: len(i))
  print(x) # Output: ['a', 'ab', 'abc', 'abcd']

Using functions as arguments

def apply(operation, numbers):
  return [operation(i) for i in numbers]

def square(x):
  return x ** 2

print(apply(square, [1, 2, 3])) # Output: [1, 4, 9]
print(apply(lambda x: x ** 2, [1, 2, 3])) # Output: [1, 4, 9]

Return functions

def apply_lambda(multiplier):
  return lambda x: x * multiplier

def apply_function(multiplier):
  def apply(x):
    return x * multiplier
  return apply

print(apply_lambda(3)(2)) # Output: 6
print(apply_function(3)(2)) # Output: 6

Modules and imports

• Creating a module:

  Create a file function_module_1.py that contains the definition of two functions:

  $ vi function_module_1.py

  def add(i, j):
    return i+j
  
  def multiply(i, j):
    return i*j

• Import entire module:

  Create a file function_import_1.py that imports the module function_module_1 (function_module_1.py):

  $ vi function_import_1.py

  # all functions defined in the module function_module_1 will be accessible using the prefix function_module_1
  import function_module_1
  
  # calling the functions in the module function_module_1 using the name of the module name as a prefix
  print(function_module_1.add(2, 3)) # Output: 5
  print(function_module_1.multiply(2, 3)) # Output: 6

• Import specific functions:

  Create a file function_import_2.py that imports specific functions defined in the module function_module_1 (function_module_1.py):

  $ vi function_import_2.py

  # importing the functions add and multiply from the module function_module_1
  from function_module_1 import add, multiply
  
  # calling directly the functions in the module function_module_1 without specifying the module name
  print(add(2, 3)) # Output: 5
  print(multiply(2, 3)) # Output: 6

• Import all:

  Create a file function_import_3.py that imports all functions defined in the module function_module_1 (function_module_1.py):

  $ vi function_import_3.py

  # importing all functions from the module function_module_1
  from function_module_1 import *
  
  # calling directly the functions in the module function_module_1 without specifying the module name
  print(add(2, 3)) # Output: 5
  print(multiply(2, 3)) # Output: 6

• Import with alias (as):

  Create a file function_import_4.py that imports the module function_module_1 (function_module_1.py) and give it an alias f1:

  $ vi function_import_4.py

  # defining the alias f1 for the module function_module_1
  import function_module_1 as f1
  
  # calling the functions in the module function_module_1 using the alias of the module as a prefix
  print(f1.add(2, 3)) # Output: 5
  print(f1.multiply(2, 3)) # Output: 6

• Import specific functions with aliases (as):

  Create a file function_import_5.py that imports specific functions defined in the module function_module_1 (function_module_1.py) and give them aliases:

  $ vi function_import_5.py

  # defining the alias a for the method add and the alias m for the method multiply
  from function_module_1 import add as a, multiply as m
  
  # calling directly the functions in the module function_module_1 using the specified alias for each function
  print(a(2, 3)) # Output: 5
  print(m(2, 3)) # Output: 6