Function Definition and Structure

Functions in Python are reusable blocks of code that perform specific tasks. They enhance modularity and code reusability. Functions are defined using the def keyword followed by a name and parentheses containing optional parameters.

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

greet()

A function can accept parameters to make it more flexible:

def compare_values(x, y):
    return x if x > y else y

result = compare_values(7, 10)
print(result)  # Output: 10

Function Parameters and Arguments

Parameters can be mutable or immutable. Immutable types like integers and strings are passed by value, while mutable types like lists and dictionaries are passed by reference.

def modify_immutable(val):
    print(id(val))
    val = 100
    print(id(val))

number = 5
print(id(number))
modify_immutable(number)

For mutable objects:

def update_list(target_list):
    target_list.append([1, 2, 3])
    print("Inside function:", target_list)

my_list = [10, 20]
update_list(my_list)
print("Outside function:", my_list)

Parameter Types

• Required praameters: Must be provided in correct order
• Keyword parameters: Allow passing arguments by name
• Default parameters: Use predefined values if not provided
• Variable-length parameters: Accept arbitrary number of arguments

def display_info(name, age=25):
    print(f"Name: {name}, Age: {age}")

display_info("Alice", 30)
display_info("Bob")

Variable-Length Arguments

def process_data(first, *rest):
    print("First:", first)
    print("Rest:", rest)

process_data(1, 2, 3, 4)

Dictionary-based variable arguments:

def process_kwargs(first, **kwargs):
    print("First:", first)
    print("Additional:", kwargs)

process_kwargs(1, a=2, b=3)

Lambda Functions

Anonymous functions can be created using lambda expressions:

add_ten = lambda x: x + 10
print(add_ten(5))  # Output: 15

multiply = lambda a, b: a * b
print(multiply(3, 4))  # Output: 12

Lambda functions can be nested inside regular functions:

def create_multiplier(n):
    return lambda x: x * n

doubler = create_multiplier(2)
tripler = create_multiplier(3)

print(doubler(10))  # Output: 20
print(tripler(10))  # Output: 30

Return Statements

Functions return values using the return statement:

def calculate_sum(a, b):
    result = a + b
    print("Inside function:", result)
    return result

total = calculate_sum(15, 25)
print("Outside function:", total)

Positional-only Parameters

Python 3.8 introduced positional-only parameters using the / syntax:

def calculate(a, b, /, c, *, d):
    return a + b + c + d

print(calculate(1, 2, c=3, d=4))  # Valid
# calculate(a=1, b=2, c=3, d=4)  # Invalid
# calculate(1, 2, 3, 4)  # Invalid