Python - functions

Python - Functions

Functions

Specify optional parameters in the end. Specify the default values for optional parameters with = value notation

def func_name(arg1, arg2=None):
    operations
    return value
In [1]:
def func_add_numbers(num1, num2=10):
    return (num1 + num2)  # return can be called as a statement or as a function
In [2]:
func_add_numbers(2)
Out[2]:
12
In [3]:
func_add_numbers(2,34)
Out[3]:
36
In [4]:
func_add_numbers()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/var/folders/d8/93856prx6tj3x7vdn97z2ps40000gn/T/ipykernel_43270/1819578982.py in <module>
----> 1 func_add_numbers()

TypeError: func_add_numbers() missing 1 required positional argument: 'num1'

Type hinting

Starting at Python 3.7 you can provide hits to specify argument data type

In [10]:
def func_add_numbers(a: int, b: int = 10) -> int:
    sum = a + b
    return sum
In [12]:
print(func_add_numbers(5, 4))
print(func_add_numbers(5))
print(func_add_numbers(5.5, 4.3))  # will still work as types are only hinted not enforced

9
15
9.8

Productivity hacks for Python

These are good to know shortcuts and methods that will reduce the need for writing explicit loops and condition checks. The comprehensions explained in cheat sheet 1 is a start, and falls under this category.

Productivity functions

lambda functions

lambdas are anonymous functions, typicaly one liner functions

lambda arg : ret_val
In [1]:
def doubler(input_number):
    return input_number*2
In [2]:
doubler(45)
Out[2]:
90
In [3]:
temp_fn = lambda arg : arg*2
In [4]:
temp_fn(55)
Out[4]:
110
In [5]:
type(temp_fn)
Out[5]:
function

It looks silly now, but lambdas work great with map and other productivity functions. You can have other methods and functions that do the heavy lifting and call them in a particular order from a lambda

map function

The map function will perform an operation on all elements of an input list. You can execute a function on all elements of a list without a loop, like a comprehension.

map(function, sequence)  --> applies the function for each element in the sequence. The return sequence if of same length as input sequence
In [6]:
l1 = [1,2,3,4,5,6,7]

#to double elements in this list using list comp
l1_double = [i*2 for i in l1]
l1_double
Out[6]:
[2, 4, 6, 8, 10, 12, 14]
In [7]:
#double using map and a function
l1_double_2 = list(map(doubler, l1))
l1_double_2
Out[7]:
[2, 4, 6, 8, 10, 12, 14]
In [15]:
#double using map and a lambda function
l1_double_3 = list(map(lambda arg:arg*2, l1))
l1_double_3
Out[15]:
[2, 4, 6, 8, 10, 12, 14]

filter function

filter function is used to filter out elements in a sequence based on a condition

filter(function, sequence)  --> applies the function for each element in sequence, but the return sequence is same or smaller than input based on the condition in the `function`.
The function should return a bool
In [9]:
#find only the odd numbers --> list comp way
l1_odd = [i for i in l1 if i%2 > 0]
l1_odd
Out[9]:
[1, 3, 5, 7]
In [13]:
# find only odd numbers --> filter with lambda way
l1_odd_2 = list(filter(lambda arg:arg%2>0, l1))
l1_odd_2
Out[13]:
[1, 3, 5, 7]
In [ ]: