Python Functions Complete Guide

# Simple function without parameters
def greet():
    print("Hello, World!")

# Call the function
greet()  # Output: Hello, World!

# Function with one parameter
def greet_person(name):
    print(f"Hello, {name}!")

greet_person("Alice")  # Output: Hello, Alice!

# Function with multiple parameters
def add_numbers(a, b):
    result = a + b
    print(f"{a} + {b} = {result}")

add_numbers(5, 3)  # Output: 5 + 3 = 8

def multiply(x, y):
    return x * y

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

# Functions can have multiple return statements
def check_even(number):
    if number % 2 == 0:
        return True
    else:
        return False

print(check_even(4))  # Output: True
print(check_even(7))  # Output: False

def function_to_implement_later():
    pass  # Placeholder, does nothing

# This allows the code to run without errors
function_to_implement_later()

def describe_person(name, age, city):
    print(f"{name} is {age} years old and lives in {city}")

# Arguments must be in correct order
describe_person("Alice", 30, "New York")
# Output: Alice is 30 years old and lives in New York

def describe_person(name, age, city):
    print(f"{name} is {age} years old and lives in {city}")

# Order doesn't matter with keyword arguments
describe_person(city="Boston", name="Bob", age=25)
# Output: Bob is 25 years old and lives in Boston

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

greet("Alice")              # Output: Hello, Alice!
greet("Bob", "Hi")          # Output: Hi, Bob!
greet("Charlie", greeting="Good morning")  # Output: Good morning, Charlie!

# Default parameters must come after non-default
def example(a, b=10, c=20):  # Correct
    pass

# def example(a=10, b):  # Incorrect - syntax error
#     pass

# *args - variable number of positional arguments (tuple)
def sum_all(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

print(sum_all(1, 2, 3))        # Output: 6
print(sum_all(5, 10, 15, 20))  # Output: 50
print(sum_all())               # Output: 0

# **kwargs - variable number of keyword arguments (dictionary)
def print_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="New York")
# Output:
# name: Alice
# age: 30
# city: New York

# Combining *args and **kwargs
def combined_function(*args, **kwargs):
    print(f"Positional arguments: {args}")
    print(f"Keyword arguments: {kwargs}")

combined_function(1, 2, 3, name="Alice", age=30)
# Output:
# Positional arguments: (1, 2, 3)
# Keyword arguments: {'name': 'Alice', 'age': 30}

def square(x):
    return x ** 2

result = square(5)
print(result)  # Output: 25

def get_min_max(numbers):
    return min(numbers), max(numbers)

minimum, maximum = get_min_max([1, 5, 3, 9, 2])
print(f"Min: {minimum}, Max: {maximum}")  # Output: Min: 1, Max: 9

# Functions return None if no return statement
def no_return():
    pass

result = no_return()
print(result)  # Output: None

def check_access(age, has_id):
    if age < 18:
        return "Too young"
    if not has_id:
        return "ID required"
    return "Access granted"

print(check_access(16, True))   # Output: Too young
print(check_access(20, False))  # Output: ID required
print(check_access(25, True))   # Output: Access granted

# Global variable
global_var = "I am global"

def my_function():
    # Local variable
    local_var = "I am local"
    print(global_var)  # Can access global
    print(local_var)   # Can access local

my_function()
# print(local_var)  # Error! local_var not accessible outside

# Modifying global variables
counter = 0

def increment():
    global counter  # Declare that we're using global variable
    counter += 1

increment()
increment()
print(counter)  # Output: 2

def outer_function():
    outer_var = "I'm in outer"

    def inner_function():
        nonlocal outer_var  # Modify variable from outer scope
        outer_var = "Modified by inner"
        print(outer_var)

    inner_function()
    print(outer_var)

outer_function()
# Output:
# Modified by inner
# Modified by inner

# Without nonlocal inside inner, assigning would create a new local name;
# reading still sees the enclosing variable.
def example():
    x = 10

    def inner():
        print(x)  # Reads from enclosing scope

    inner()

# Adding type hints (Python 3.5+)
def greet(name: str) -> str:
    return f"Hello, {name}!"

def divide(dividend: float, divisor: float) -> float:
    if divisor == 0:
        raise ValueError("Cannot divide by zero")
    return dividend / divisor

# Annotations are stored in __annotations__
print(greet.__annotations__)  # {'name': <class 'str'>, 'return': <class 'str'>}

# Complex annotations (Python 3.9+ built-in generics)
def process_data(
    data: list[int],
    threshold: float = 0.5,
    verbose: bool = False
) -> dict[str, float]:
    """Process data and return statistics"""
    result = {
        "mean": sum(data) / len(data),
        "max": max(data),
        "min": min(data)
    }
    return result