Functions and Lambdas in Python

Introduction to Functions

Title	Concept	Codes
What are Functions?	Blocks of reusable code that perform a specific task.	Encapsulate logic, promote code reuse, and enhance code modularity.
Function Syntax in Python	Define functions, arguments, and return values in Python.	Functions are defined using the `def` keyword with optional parameters and return statements.
Purpose of Functions	Modularity, Reusability, and Improved Code Organization.	Functions break down complex systems into manageable components and streamline code maintenance.

Function Syntax:

def my_function(param1, param2):
    # Function code here
    return result

Title	Concept	Codes
Positional Parameters	Arguments passed based on order.	`def greet(name, message):` `print(f"Hello, {name}! {message}")`
Keyword Parameters	Arguments passed based on names provided.	`greet(message="How are you?", name="Alice")`
Default Parameters	Predefined values for function arguments.	`def greet(name, message="Good day!"):` `print(f"Hello, {name}! {message}")`
Variable-Length Arguments	Handle arbitrary number of arguments.	`def sum_values(*args):` `return sum(args)`

Title	Concept	Codes
Global vs. Local Scope	Differentiating variable accessibility within functions.	Global variables accessible throughout, local variables limited to function scope.
Accessing Variables in Different Scopes	Utilizing variables with specific scopes.	`global_var = 10` `def my_func():` `local_var = 5`
The 'global' Keyword	Modifying global variables within function scope.	`def change_global_value():` `global global_var` `global_var = 20`

Title	Concept	Codes
Definition and Syntax	Anonymous functions defined in a single line.	`lambda x, y: x + y`
Advantages of Lambda Functions	Concise, no need for `def` keyword, used for short functions.	`lambda x: x**2 if x > 0 else 0`
Use Cases for Lambda Functions	Functional programming, data transformations, quick functions.	`list(map(lambda x: x+2, [1, 2, 3]))`

Using map() with Functions

numbers = [1, 2, 3]
squared = list(map(lambda x: x**2, numbers))

Lambda Functions with map()

names = ['Alice', 'Bob', 'Charlie']
lengths = list(map(lambda x: len(x), names))

Using filter() with Functions

numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

Lambda Functions with filter()

names = ['Alice', 'Bob', 'Charlie']
long_names = list(filter(lambda x: len(x) > 5, names))

Writing Recursive Functions

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)