🔷 Introduction

Functions are the foundation of reusable and maintainable code. At the beginner level, you learned how to define and call functions. In this lesson, we take it further by exploring advanced function features that are widely used in real-world Python applications.

You will learn:

✔ Flexible arguments with *args and **kwargs
✔ Default, positional, and keyword arguments
✔ Lambda (anonymous) functions
✔ Higher-order functions (map, filter, reduce)
✔ Introduction to decorators

These tools will allow you to write cleaner, more dynamic, and reusable code.

🟩 1. Default, Positional, and Keyword Arguments

Default arguments

def greet(name="Guest"):
    print("Hello", name)

greet()          # Hello Guest
greet("Ali")     # Hello Ali

Positional vs Keyword arguments

def info(name, age):
    print(name, age)

info("Sara", 25)            # positional
info(age=25, name="Sara")   # keyword

🟩 2. args (Variable Positional Arguments)

*args allows a function to accept any number of positional arguments.

def add_numbers(*args):
    total = 0
    for n in args:
        total += n
    return total

print(add_numbers(1, 2, 3, 4))  # 10

💡 args is a tuple.

🟩 3. kwargs (Variable Keyword Arguments)

**kwargs allows a function to accept any number of keyword arguments.

def display_info(**kwargs):
    for key, value in kwargs.items():
        print(key, ":", value)

display_info(name="Ali", age=22)

💡 kwargs is a dictionary.

🟩 4. Lambda Functions (Anonymous Functions)

A lambda is a small, one-line function.

Example:

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

Use with map:

nums = [1, 2, 3]
result = list(map(lambda x: x*2, nums))
print(result)

🟩 5. Higher-Order Functions

These are functions that take other functions as arguments.

A. map()

Applies a function to each item:

nums = [1, 2, 3]
result = list(map(lambda x: x * 2, nums))

B. filter()

Filters elements:

nums = [1, 2, 3, 4]
evens = list(filter(lambda x: x % 2 == 0, nums))

C. reduce()

Requires functools:

from functools import reduce

nums = [1, 2, 3, 4]
result = reduce(lambda x, y: x + y, nums)

🟩 6. Decorators (Introduction)

A decorator is a function that wraps another function.

Basic Example:

def my_decorator(func):
    def wrapper():
        print("Before function")
        func()
        print("After function")
    return wrapper

Using the decorator:

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Output:

Before function
Hello!
After function

🟧 7. Exercises (Hidden Solutions)

Exercise 1 — Use args to multiply numbers

def multiply(*args):
    result = 1
    for n in args:
        result *= n
    return result

print(multiply(2, 3, 4))  # 24

Exercise 2 — Use kwargs to print user info

def show_user(**kwargs):
    for k, v in kwargs.items():
        print(k, v)

show_user(name="Sara", country="Morocco")

Exercise 3 — Use lambda to cube numbers

nums = [1, 2, 3]
cubes = list(map(lambda x: x**3, nums))
print(cubes)

Exercise 4 — Filter numbers greater than 10

nums = [5, 12, 8, 20]
result = list(filter(lambda x: x > 10, nums))
print(result)

Exercise 5 — Create a decorator that logs function calls

def logger(func):
    def wrapper():
        print("Function is called")
        func()
    return wrapper

@logger
def test():
    print("Hello")

test()

🟦 Conclusion

In this lesson, you’ve unlocked some of Python’s most powerful function features:

• Flexible argument handling
• Functional programming tools
• Anonymous functions
• Code reuse with decorators

These concepts are widely used in frameworks like Django, Flask, and FastAPI.