Python Tutorial - 4 Function

Introduction

The function is a callable unit containing instructions, aimed at reducing code duplication and organizing complex tasks. There are two types: void functions (no return value) and those that return a value.

This is the basic structure of function in Python.

def function_name(args):
    function body

This is an example of a void function (no return value) in Python.

# create a function
def hello():
    print("hello!")

# call the function
hello()

Output

hello!

Based on the code above, the function called hello() is created. The function is called by specifying the function name followed by parentheses ().

This is an example of fa unction with the return value.

# create a function with return value
def add(a,b):
    return a + b

result = add(2,4)

print(result)

Output

6

Based on the code above, the function called add() is created to sum two numbers. The return value of the add() function is stored inside the result variable.

When working with the return value function, ensure the returned value is being used.

Arguments and Keyword Arguments

The function in Python can take multiple arguments dynamically. There are two approaches to implementing multiple arguments in a function:

• Arguments: the multiple arguments are implemented in a function without specifying the keywords. the arguments can be implemented using *args.

• Keyword arguments: the multiple arguments are implemented in a function with the specified keywords. the keyword arguments can be implemented using **kwargs.

Both arguments and keyword arguments must be located in the last position of the argument definition in a function.

This is an example of multiple arguments implementation using the arguments approach to calculate the sum of the numbers dynamically.

def sum(*args):
    result = 0
    for arg in args:
        result += arg
    return result

print(sum(1,2))
print(sum(1,2,3))
print(sum(1,2,3,4,5,4,3,2))

Output

3
6
24

Based on the code above, the sum() function can be called with a different number of parameters.

This is an example of multiple arguments implementation using the keyword arguments approach.

def display_info(name,**kwargs):
    print("========")
    print(f"name: {name}")
    print("other informations")
    for k, val in kwargs.items():
        print(f"{k}: {val}")
    print("========")

display_info("john",job="programmer",company="acme inc")
display_info("doe",job="programmer",company="acme inc",skills="go,java,php")

Output

========
name: john
other informations
job: programmer
company: acme inc
========
========
name: doe
other informations
job: programmer
company: acme inc
skills: go,java,php
========

Based on the code above, the display_info() function can be called with a different number of parameters. By using **kwargs, the parameters can be defined with the keywords.

Both arguments and keyword arguments can be used together. This is an example.

def display(*args,**kwargs):
    print("===========")
    print("items")
    for arg in args:
        print(arg)
    print("other information")
    for k, val in kwargs.items():
        print(f"{k}: {val}")
    print("===========")

display("apple","coffee","milk",payment="cash")
display("TV","Camera",payment="cash",delivery="express")

Output

===========
items
apple
coffee
milk
other information
payment: cash
===========
===========
items
TV
Camera
other information
payment: cash
delivery: express
===========

Recursive Function

The recursive function is a function that calls itself when accomplishing its task. The recursive function can solve many problems including factorial numbers, the Fibonacci sequence, and others.

There are two main components in a recursive function:

• Base case: the base case defines when the function is stopped.
• Recurrence relation: the recurrence relation defines the recursive process of the function.

In this example, the factorial calculation is implemented using a recursive function.

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)

# call the function
result = factorial(5)

print(result)

Output

120

Let's take a closer look to the factorial() function. There are two components involved in this function:

• base case: the function execution terminates if the value of n equals to 0 or 1.

• recurrence relation: the function executes if the value of n greater than 1.
  

def factorial(n):
    if n == 0 or n == 1: # base case
        return 1
    else:
        return n * factorial(n-1) # recurrence relation

The factorial() function is illustrated in this picture below.

Lambda

The lambda is an anonymous function. The lambda can contain many arguments just like function in general. The lambda function is suitable for creating a small function that returns the value directly.

This is an example of the sum() function.

def sum(a,b):
    return a + b

This is the example of a lambda function to sum two numbers. The lambda function is stored inside a variable called sum_func.

sum_func = lambda a,b: a + b

To use the lambda function, call the function by its variable name.

sum_func = lambda a,b: a + b

# call the function
print(sum_func(1,2))

Map and Filter

Map Function

The map() function executes a provided callback function for each item inside a list.

This is the example of the map() function to multiply each number by 3.

# create a function to multiply a number by 3
def triple(num):
    return num * 3


# list of numbers
numbers = [1, 2, 3, 4, 5]

# call triple() function for each item in a numbers
map_result = map(triple, numbers)

# convert the map result into the list
result = list(map_result)

# display the result
print(f"result: {result}")

Output

result: [3, 6, 9, 12, 15]

Based on the code above, the triple() function acts as a callback for the map() function which means the triple() function is called for each item in the numbers list. Then, the result of the map() function is converted into the list and then stored inside the variable called result.

The example above can be simplified using the lambda function.

# list of numbers
numbers = [1, 2, 3, 4, 5]

# using lambda function to multiply the number by 3
# then convert the result to the list
result = list(map(lambda num: num * 3, numbers))

# display the result
print(f"result: {result}")

Output

result: [3, 6, 9, 12, 15]

Filter Function

The filter() function selects the item inside a list based on the given callback function. The filter() function is suitable for filtering the items inside a list by using the provided callback function. The filter() function requires a callback function that returns a boolean value.

This is the example of the filter() function to select only even numbers in a list.

# create a function to check if the number is even
def is_even(num):
    return num % 2 == 0


# list of numbers
numbers = [11, 2, 4, 25, 65, 19, 20]

# select only even numbers
# then convert the result to the list
result = list(filter(is_even, numbers))

print(f"even numbers: {result}")

Output

even numbers: [2, 4, 20]

Based on the code above, the filter() function uses is_even() as a callback function to select the even numbers from the list.

This example can be simplified using the lambda function.

# list of numbers
numbers = [11, 2, 4, 25, 65, 19, 20]

# select only even numbers
# then convert the result to the list
result = list(filter(lambda num: num % 2 == 0, numbers))

print(f"even numbers: {result}")

Output

even numbers: [2, 4, 20]

Example - Remove Duplicate Codes

The function can be used to remove duplicate codes. For example, there are two functions called register() and login(). Both functions is using the validation process.

def register(email, password):
    # perform simple validation
    if email != "" and password != "":
        print("register succeed")
    else:
        print("invalid request")


def login(email, password):
    # perform simple validation
    if email != "" and password != "":
        print("login succeed")
    else:
        print("invalid request")

There is a duplicate code for the validation process. To remove these duplicates, the validation process can be wrapped in a separate function.

def validate(email, password):
    return email != "" and password != ""

The validate() function can be used inside the register() and login() functions.

def validate(email, password):
    return email != "" and password != ""


def register(email, password):
    # perform simple validation
    if validate(email, password):
        print("register succeed")
    else:
        print("invalid request")


def login(email, password):
    # perform simple validation
    if validate(email, password):
        print("login succeed")
    else:
        print("invalid request")

Based on the code above, the code is cleaner and easier to modify because if the additional validation rules are updated, the validation rules can be updated in one place (inside the validate() function).

Tips

These are the key tips when working with a function in Python.

• The function must complete a single task. If multiple tasks are required, create a separate function for other tasks.

• The maximum number of function arguments is 3. If the arguments seem more than 3, consider using a dedicated data object for the function argument.

The maximum number of function arguments seems debatable.

This is the example of the create_account() function using arguments.

def create_user(username, email, password, address):
    # create a new user...
    pass

The create_account() function can be modified to use data object for cleaner code.

def create_user(user: User):
    # create a new user with user data object
    pass

• Use documentation to explain the function description. The documentation can be added using """ syntax.

This is an example of using documentation inside a function.

def div(a, b):
    """
    divide two numbers
    """
    if b == 0:
        pass
    else:
        return a / b

Sources

• Arguments and keyword arguments in function
• Recursive function illustrations

I hope this article helps you learn Python. If you have any feedback, please let me know in the comment section.