Functions and Functional Programming

Functions are reusable blocks of code that perform specific tasks. They enhance code modularity and readability, making it easier to manage complex applications.

# Example of a simple function
def greet(name):
return f”Hello, {name}!”

# Using the function
print(greet(“Alice”)) # Output: “Hello, Alice!”

Lambda functions, also known as anonymous functions, are concise one-liners used for simple tasks. Higher-order functions are functions that take other functions as arguments or return functions as output.

# Example of lambda and higher-order functions
# Lambda function to calculate the square of a number
square = lambda x: x ** 2

# Higher-order function to apply a function to a list
def apply_to_list(func, num_list):
return [func(num) for num in num_list]

numbers = [1, 2, 3, 4, 5] squared_numbers = apply_to_list(square, numbers)
print(squared_numbers) # Output: [1, 4, 9, 16, 25]

Closures are functions that remember the environment in which they were created. They are often used to create function factories. Decorators are functions that modify the behavior of other functions.

# Example of closures and decorators
# Closure: Function factory
def power_of(n):
def power(x):
return x ** n
return power

cube = power_of(3)
print(cube(2)) # Output: 8

# Decorator: Add functionality to an existing function
def square_decorator(func):
def wrapper(x):
result = func(x)
return result ** 2
return wrapper

@square_decorator
def add(a, b):
return a + b

print(add(3, 5)) # Output: 64 (square of the sum)

Recursion is a powerful technique where a function calls itself to solve a problem. It is often used in solving problems with repetitive subproblems.

# Example of recursion
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n – 1)

print(factorial(5)) # Output: 120