Python Functions

Lesson 1

Introduction to Functions

Learn the fundamentals of Python functions and how they help organize and reuse code effectively.

30 mins Beginner 3 Exercises

# Basic function definition
def greet(name):
    """Return a greeting message."""
    return f"Hello, {name}!"

# Function with multiple parameters
def calculate_area(length, width):
    """Calculate the area of a rectangle."""
    return length * width

# Function with default parameter
def greet_user(name="Guest"):
    """Greet a user with a default name."""
    return f"Welcome, {name}!"

Learning Objectives:

Understanding function definition and syntax
Basic function calls and return values
Function naming conventions
Writing docstrings for documentation

Practice Exercises:

1. Create a function that calculates the volume of a cube.

def calculate_cube_volume(side):
    """Calculate the volume of a cube."""
    return side ** 3

Start Lesson

Lesson 2

Function Parameters

Master different types of parameters and learn how to use them effectively in your functions.

45 mins Beginner 4 Exercises

# Required parameters
def add(x, y):
    """Add two numbers."""
    return x + y

# Default parameters
def greet(name, greeting="Hello"):
    """Greet with custom message."""
    return f"{greeting}, {name}!"

# Variable arguments
def sum_all(*args):
    """Sum all provided numbers."""
    return sum(args)

# Keyword arguments
def create_profile(**kwargs):
    """Create a user profile."""
    return kwargs

Learning Objectives:

Required vs optional parameters
Default parameter values
Variable arguments (*args)
Keyword arguments (**kwargs)
Parameter order and best practices

Practice Exercises:

1. Create a function that can calculate the average of any number of values.

def calculate_average(*numbers):
    """Calculate the average of provided numbers."""
    return sum(numbers) / len(numbers) if numbers else 0

Start Lesson

Lesson 3

Return Values and Multiple Returns

Learn how to effectively use return values and handle multiple return scenarios.

40 mins Beginner 3 Exercises

# Single return value
def square(number):
    """Return the square of a number."""
    return number ** 2

# Multiple return values
def get_coordinates():
    """Return x and y coordinates."""
    return 10, 20

# Conditional returns
def absolute_value(number):
    """Return the absolute value."""
    if number >= 0:
        return number
    return -number

Learning Objectives:

Understanding return statements
Returning multiple values
Conditional returns
Return value unpacking

Practice Exercises:

1. Create a function that returns both the quotient and remainder of a division.

def divide_with_remainder(dividend, divisor):
    """Return quotient and remainder."""
    return dividend // divisor, dividend % divisor

Start Lesson

Lesson 4

Lambda Functions

Learn about anonymous functions and their practical applications in Python.

35 mins Beginner 3 Exercises

# Basic lambda function
square = lambda x: x ** 2

# Lambda with multiple arguments
multiply = lambda x, y: x * y

# Using lambda with built-in functions
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))

# Lambda with conditional expression
absolute = lambda x: x if x >= 0 else -x

Learning Objectives:

Understanding lambda function syntax
Using lambda with built-in functions
When to use lambda functions
Best practices and limitations

Practice Exercises:

1. Create a lambda function that checks if a number is even.

is_even = lambda x: x % 2 == 0

Start Lesson

Lesson 5

Function Scope

Understand variable scope and how it affects your functions.

40 mins Beginner 4 Exercises

# Global variable
x = 10

def my_function():
    # Local variable
    y = 20
    print(f"Inside function: x = {x}, y = {y}")

# Using global keyword
def modify_global():
    global x
    x = 30
    print(f"Modified global x: {x}")

# Nested functions
def outer():
    z = 50
    def inner():
        print(f"Accessing z from inner: {z}")
    inner()

Learning Objectives:

Global vs local scope
Using the global keyword
Nested functions and scope
Variable lifetime and memory management

Practice Exercises:

1. Create a counter function that maintains its count between calls.

def create_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

Start Lesson

Lesson 6

Recursion

Learn about recursive functions and how to implement them in Python.

45 mins Intermediate 4 Exercises

# Factorial using recursion
def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

# Fibonacci sequence
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Binary search
def binary_search(arr, target, low, high):
    if low > high:
        return -1
    mid = (low + high) // 2
    if arr[mid] == target:
        return mid
    elif arr[mid] > target:
        return binary_search(arr, target, low, mid-1)
    else:
        return binary_search(arr, target, mid+1, high)

Learning Objectives:

Understanding recursion
Base cases and recursive cases
Common recursive patterns
Recursion vs iteration

Practice Exercises:

1. Implement a recursive function to calculate the sum of digits in a number.

def sum_digits(n):
    if n < 10:
        return n
    return n % 10 + sum_digits(n // 10)

Start Lesson

Lesson 7

Decorators

Master function decorators and their powerful applications in Python.

50 mins Intermediate 3 Exercises

# Basic decorator
def timer(func):
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Function took {end - start} seconds")
        return result
    return wrapper

# Decorator with arguments
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

# Using decorators
@timer
def slow_function():
    import time
    time.sleep(1)
    return "Done!"

@repeat(times=3)
def greet(name):
    print(f"Hello, {name}!")

Learning Objectives:

Understanding decorator syntax
Creating custom decorators
Decorators with arguments
Common decorator patterns

Practice Exercises:

1. Create a decorator that caches function results.

def cache(func):
    cache = {}
    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]
    return wrapper

Start Lesson

Course Lessons

Introduction to Functions

Learning Objectives:

Practice Exercises:

Function Parameters

Learning Objectives:

Practice Exercises:

Return Values and Multiple Returns

Learning Objectives:

Practice Exercises:

Lambda Functions

Learning Objectives:

Practice Exercises:

Function Scope

Learning Objectives:

Practice Exercises:

Recursion

Learning Objectives:

Practice Exercises:

Decorators

Learning Objectives:

Practice Exercises: