How to Define and Call Functions in Python

Functions are the building blocks of Python programming. They allow you to break code into smaller, reusable pieces, making it more readable, maintainable, and efficient. In this article, we’ll explore how to define and call functions in Python, including best practices and real-world examples.

---

1. What is a Function?

A function is a block of code that performs a specific task. Instead of writing the same code multiple times, you can define a function once and reuse it whenever needed.

Why Use Functions?

• Code Reusability – Write once, use multiple times.
• Readability – Makes your program easier to understand.
• Modularity – Breaks large programs into smaller, manageable parts.
• Avoids Duplication – Reduces redundant code.

Example Without Functions (Bad Practice)

print("Welcome, Alice!")
print("Welcome, Bob!")
print("Welcome, Charlie!")

Here, we repeat the print statement for every user, which is inefficient. Instead, we can use a function:

Example With a Function (Good Practice)

def greet(name):
    print(f"Welcome, {name}!")

greet("Alice")
greet("Bob")
greet("Charlie")

This version is more efficient, easier to modify, and reusable.

---

2. How to Define a Function in Python

To define a function in Python, use the def keyword followed by the function name, parentheses (), and a colon :. Inside the function, write the code you want to execute when the function is called.

Syntax:

def function_name():
    # Function body (indented)
    # Statements to execute

Example 1: A Simple Function

def say_hello():
    print("Hello, welcome to Python!")

# Calling the function
say_hello()

Output:

Hello, welcome to Python!

Explanation:

• The function say_hello() prints a message.
• The function must be called to execute.

---

3. Function Parameters and Arguments

Functions can accept inputs (parameters) to make them more flexible.

Example 2: Function with One Parameter

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

# Calling the function with different arguments
greet("Alice")
greet("Bob")

Output:

Hello, Alice!
Hello, Bob!

Explanation:

• The function greet(name) accepts one parameter (name).
• We call the function with different values (Alice, Bob), which get substituted in the function.

Example 3: Function with Multiple Parameters

def add_numbers(a, b):
    print(f"The sum of {a} and {b} is {a + b}")

# Calling the function with different arguments
add_numbers(3, 5)
add_numbers(10, 20)

Output:

The sum of 3 and 5 is 8
The sum of 10 and 20 is 30

Explanation:

• The function add_numbers(a, b) takes two numbers as input.
• It calculates and prints their sum.
• We can reuse this function to add different numbers.

---

4. Returning Values from Functions

Sometimes, you need a function to return a result instead of just printing it. The return statement is used for this.

Example 4: Function That Returns a Value

def square(num):
    return num * num

# Storing the result in a variable
result = square(5)
print(result)

Output:

25

Explanation:

• square(num) calculates the square and returns the result.
• The returned value is stored in result and printed.

Example 5: Using Return in Calculations

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

# Calling the function inside a print statement
print(multiply(4, 5))

Output:

20

Why Use return?

• Returns data instead of just printing it.
• Can be used in further calculations.
• Allows functions to be more flexible.

---

5. Calling Functions in Python

Once a function is defined, you call it by writing its name followed by parentheses ().

Example 6: Calling a Function

def greet():
    print("Hello, Python learner!")

# Calling the function
greet()

Output:

Hello, Python learner!

Calling Functions With Arguments

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

greet_person("John")

Output:

Hello, John!

Function Calls in Expressions

You can also call functions inside expressions.

def square(n):
    return n * n

result = square(3) + square(4)
print(result)

Output:

25

---

6. Function Scope: Local vs. Global Variables

Functions have their own scope, meaning variables inside a function are local to that function and cannot be accessed outside it.

Example 7: Local and Global Variables

global_var = "I am global"

def my_function():
    local_var = "I am local"
    print(local_var)  # Accessible inside function
    print(global_var)  # Accessible inside function

my_function()
print(global_var)  # Accessible outside function
# print(local_var)  # This would cause an error

Output:

I am local
I am global
I am global

Key Takeaways:

• Local variables exist only inside the function.
• Global variables exist outside the function and can be accessed inside.
• Modifying a global variable inside a function requires the global keyword.

Example 8: Using global Keyword

count = 0

def increment():
    global count
    count += 1
    print(count)

increment()
increment()

Output:

1
2

---

7. Lambda Functions (Anonymous Functions)

Python allows defining short, one-line functions using lambda.

Example 9: Lambda Function for Squaring a Number

square = lambda x: x * x
print(square(4))

Output:

16

Example 10: Lambda Function with Multiple Parameters

multiply = lambda a, b: a * b
print(multiply(3, 5))

Output:

15

When to Use Lambda Functions?

• For short, simple operations.
• Inside functions like map(), filter(), and sorted().
• Where a full def function is unnecessary.

---

Conclusion

Functions in Python improve code readability, reusability, and organization.

Key Takeaways:

• Use def function_name(): to define a function.
• Call functions using function_name().
• Use parameters to pass data into functions.
• Use return to return values instead of printing.
• Understand local vs. global variables.
• Lambda functions allow writing short, anonymous functions.

Call to Action

Try creating your own Python functions! Start with simple ones like calculating areas, converting temperatures, or processing text. Experiment with return values and function calls.

Happy coding!