How to Call Multiple Functions in Python

In Python, calling multiple functions is a common practice, especially when building modular, organized and maintainable code. In this article, we’ll explore various ways we can call multiple functions in Python.

The most straightforward way to call multiple functions is by executing them one after another. Python makes this process simple and intuitive each function call happens in the order it’s written.

def func1():
    print("Hello, World!")

def func2():
    print("Goodbye, World!")

func1()
func2()

Hello, World!
Goodbye, World!

Explanation:

• In this example, we have two functions: func1() and func2().
• We call each function one by one. When executed, Python runs each function in the order it appears.

Let's take a look at other cases of calling multiple functions:

Calling Multiple Functions from Another Function

Sometimes, we may want to group multiple function calls together within a single function. This approach can make our code more organized and easier to manage.

def func1():
    print("Function One Called")

def func2():
    print("Function Two Called")

def call_multiple():
    func1()
    func2()

call_multiple()

Function One Called
Function Two Called

Explanation:

• The call_multiple() function calls func1() and func2().
• When we call call_multiple(), both functions are executed in sequence, allowing us to group related functionality in one place.

Calling Functions in a Loop

When we need to call multiple functions that follow a similar pattern, it’s often more efficient to use a loop. This is particularly useful when we need to execute functions that take similar arguments or perform related tasks.

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


def multiply(a, b):
    return a * b


functions = [add, multiply]

for func in functions:
    print(func(3, 5))

8
15

Explanation:

• We store add and multiply functions in a list called functions.
• We then loop through this list and call each function with the arguments (3, 5). This approach is efficient because it lets us call each function without repeating the same code.

Calling Functions with Arguments

When functions require arguments, we can still call multiple functions in sequence or from within another function. Passing the right parameters ensures that each function behaves as expected.

def func1(name):
    print(f"Hello, {name}!")

def func2(name):
    print(f"Goodbye, {name}!")

# Calling functions with arguments
func1("Alice")
func2("Bob")

Hello, Alice!
Goodbye, Bob!

Explanation:

• Both func1() and func2() require a name argument.
• We pass different names to each function when we call them. This demonstrates how we can use functions with parameters while calling multiple functions in sequence.

Calling Functions in Parallel (Concurrency)

In some situations, we might want to execute multiple functions concurrently, especially when dealing with tasks that are independent of each other. Python provides several tools for concurrency, such as the threading and multiprocessing modules, as well as asynchronous programming with asyncio.

import threading

def func1():
    print("Task One Started")
    
def func2():
    print("Task Two Started")

thread1 = threading.Thread(target=func1)
thread2 = threading.Thread(target=func2)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

Task One Started
Task Two Started

Explanation:

• We create two threads, thread1 and thread2, each responsible for calling func1() and func2(), respectively.
• By calling start(), both functions begin executing concurrently. This allows us to run them at the same time, rather than sequentially.
• The join() method ensures that the main thread waits for both threads to complete before proceeding.