Lesson Six: Functions in Python

Welcome to the sixth lesson in our Python learning series! In this lesson, we will focus on functions and how to use them to organize your code and make it more reusable. Functions are one of the most important concepts in programming, as they allow you to break down a program into smaller, manageable parts.

1. What Are Functions?

Functions are blocks of code that perform a specific task and can be called whenever needed. By using functions, you can:

• Avoid repeating code.
• Organize your code better.
• Make your program more readable and maintainable.

A. Defining a Function

A function is defined using the def keyword, followed by the function name and parentheses containing parameters (if any).

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

B. Calling a Function

After defining the function, you can call it by using its name followed by parentheses.

greet() # Output: Hello, World!

2. Functions with Parameters

Parameters are values passed to the function when it is called. Functions can have no parameters or multiple ones.

A. Function with One Parameter

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


greet("Ali") # Output: Hello, Ali!

B. Function with Multiple Parameters

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


add(5, 3) # Output: 8

3. Returning Values from Functions

Instead of printing results inside the function, you can return values using the return keyword. These values can be stored in variables or used directly.

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


result = multiply(4, 5)
print(result) # Output: 20

Note : When the return statement is reached, the function stops executing, and no further code within the function is executed.

4. Default Parameter Values

You can assign default values to parameters so that if no value is passed during the function call, the default value is used.

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


greet() # Output: Hello, Guest!
greet("Ali") # Output: Hello, Ali!

5. Functions with an Indefinite Number of Parameters

If you don't know how many parameters will be passed to the function, you can use *args to pass an indefinite number of arguments.

A. Using *args

def sum_all(*args):
total = 0
for num in args:
total += num
return total


print(sum_all(1, 2, 3, 4)) # Output: 10

B. Using **kwargs

If you want to pass an indefinite number of key-value pairs as arguments, you can use **kwargs.

def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")


print_info(name="Ali", age=25, city="Riyadh")
# Output:
# name: Ali
# age: 25
# city: Riyadh

6. Nested Functions

You can define a function inside another function. These inner functions can only be used within the outer function.

def outer_function():
print("This is the outer function.")

def inner_function():
print("This is the inner function.")

inner_function()


outer_function()
# Output:
# This is the outer function.
# This is the inner function.

7. Anonymous Functions (Lambda Functions)

Anonymous functions (or lambda) are small functions that can be written in a single line. They are typically used for simple, temporary tasks.

A. Lambda Function Syntax

square = lambda x: x ** 2
print(square(5)) # Output: 25

B. Using Lambda with Other Functions

You can use lambda with functions like map() and filter().

# Using map() to apply a function to each element in a list
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
print(squares) # Output: [1, 4, 9, 16]


# Using filter() to filter elements based on a condition
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # Output: [2, 4]

8. Variable Scope

The scope of a variable determines where it can be accessed within the program. There are two main types of scopes:

• Local Variables : Defined inside a function and cannot be accessed outside of it.
• Global Variables : Defined outside of functions and can be accessed from anywhere.

A. Local Variables

def my_function():
x = 10 # Local variable
print(x)


my_function() # Output: 10
# print(x) # Error: x is not defined here

B. Global Variables

x = 10 # Global variable
def my_function():
print(x)


my_function() # Output: 10
print(x) # Output: 10

Note : If you want to modify a global variable inside a function, you must use the global keyword.

x = 10
def modify_global():
global x
x = 20


modify_global()
print(x) # Output: 20

9. Practical Applications

Application 1: Calculating the Average

def calculate_average(numbers):
if len(numbers) == 0:
return 0
return sum(numbers) / len(numbers)


nums = [10, 20, 30, 40, 50]
average = calculate_average(nums)
print(f"The average is: {average}") # Output: The average is: 30.0

Application 2: Checking for Prime Numbers

def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True


print(is_prime(11)) # Output: True
print(is_prime(15)) # Output: False

Application 3: Using Lambda with filter()

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # Output: [2, 4, 6]

10. Tips for Using Functions

• Keep Functions Small and Specific : Try to make each function responsible for only one task. This makes the code more readable and maintainable.
• Use Clear Names : Choose names that clearly describe the function's purpose.
• Avoid Using Global Variables Unless Necessary : Limit the use of global variables because they can lead to issues in larger programs.

Conclusion

In this lesson, you learned how to create and use functions to organize your code and make it more reusable. Functions are a powerful tool that help you break down a program into smaller, manageable parts.

In the next lesson, we will discuss Error Handling and how to deal with exceptions in programs. Keep practicing and don't hesitate to ask questions if you need help!

🚀 You're now on the right path to becoming a professional programmer!