Python Tutorial - unction

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 function_name(args):
    function body

Output

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

# call the function
hello()

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.
  

hello!

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.

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

result = add(2,4)

print(result)

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

6

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

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))

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.

3
6
24

Output

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")

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.

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

Output

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")

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.

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

Output

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)

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.

120

Output

def function_name(args):
    function body

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.

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

# call the function
hello()

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

hello!

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

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

result = add(2,4)

print(result)

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.

6

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

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))

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

This is an example of using documentation inside a function.

3
6
24

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.

The above is the detailed content of Python Tutorial - unction. For more information, please follow other related articles on the PHP Chinese website!