Python Programming (updated)

Table of Contents

1. Introduction to Python
2. Getting Started
3. Python Basics
4. Control Flow
5. Functions
6. Data Structures
7. Object-Oriented Programming
8. Error Handling
9. File Operations
10. Modules and Packages
11. Advanced Topics
12. Web Development
13. Data Science and Analytics
14. Testing and Debugging
15. Best Practices

Introduction to Python

Python is a high-level, interpreted programming language known for its simplicity and readability. Created by Guido van Rossum in 1991, Python emphasizes code readability and allows programmers to express concepts in fewer lines of code.

Why Choose Python?

mindmap
  root((Python Advantages))
    Easy to Learn
      Simple Syntax
      Readable Code
      Beginner Friendly
    Versatile
      Web Development
      Data Science
      AI/ML
      Automation
    Large Community
      Extensive Libraries
      Active Support
      Open Source
    Cross Platform
      Windows
      Mac
      Linux

Python Applications

graph TD
    A[Python Applications] --> B[Web Development]
    A --> C[Data Science]
    A --> D[Machine Learning]
    A --> E[Automation]
    A --> F[Game Development]
    A --> G[Desktop Applications]

    B --> B1[Django]
    B --> B2[Flask]
    B --> B3[FastAPI]

    C --> C1[Pandas]
    C --> C2[NumPy]
    C --> C3[Matplotlib]

    D --> D1[TensorFlow]
    D --> D2[PyTorch]
    D --> D3[Scikit-learn]

Getting Started

Installation

1. Download Python: Visit python.org and download the latest version
2. Install: Run the installer and ensure “Add Python to PATH” is checked
3. Verify Installation: Open command prompt and type:

python --version

python --version

Development Environment

graph LR
    A[Choose IDE] --> B[VS Code]
    A --> C[PyCharm]
    A --> D[Jupyter Notebook]
    A --> E[IDLE]

    B --> F[Recommended for beginners]
    C --> G[Professional development]
    D --> H[Data science & research]
    E --> I[Built-in with Python]

Your First Python Program

# Hello World program
print("Hello, World!")
print("Welcome to Python programming!")

# Variables and basic operations
name = "Python"
version = 3.12
print(f"Learning {name} version {version}")

# Hello World program
print("Hello, World!")
print("Welcome to Python programming!")

# Variables and basic operations
name = "Python"
version = 3.12
print(f"Learning {name} version {version}")

Python Basics

Variables and Data Types

graph TD
    A[Python Data Types] --> B[Numeric]
    A --> C[Sequence]
    A --> D[Mapping]
    A --> E[Set]
    A --> F[Boolean]
    A --> G[None]

    B --> B1[int]
    B --> B2[float]
    B --> B3[complex]

    C --> C1[str]
    C --> C2[list]
    C --> C3[tuple]

    D --> D1[dict]

    E --> E1[set]
    E --> E2[frozenset]

mindmap
  root((Python Data Types))
    Numeric
      Integer
        integer_num = 42
      Float
        float_num = 3.14159
      Complex
        complex_num = 3 + 4j
    String
      text = "Hello, Python!"
      multiline = """This is a\nmultiline string"""
    Boolean
      is_python_fun = True
      is_difficult = False
    Sequence
      List (mutable)
        fruits = ['apple', 'banana', 'orange']
      Tuple (immutable)
        coordinates = (10, 20)
    Mapping
      Dictionary
        person = #123;'name': 'Alice', 'age': 30, 'city': 'New York'#125;
    Set
      unique_numbers = #123;1, 2, 3, 4, 5#125;

# Numeric types
integer_num = 42
float_num = 3.14159
complex_num = 3 + 4j

# String
text = "Hello, Python!"
multiline = """This is a
multiline string"""

# Boolean
is_python_fun = True
is_difficult = False

# List (mutable)
fruits = ["apple", "banana", "orange"]

# Tuple (immutable)
coordinates = (10, 20)

# Dictionary
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

# Set
unique_numbers = {1, 2, 3, 4, 5}

# Numeric types
integer_num = 42
float_num = 3.14159
complex_num = 3 + 4j

# String
text = "Hello, Python!"
multiline = """This is a
multiline string"""

# Boolean
is_python_fun = True
is_difficult = False

# List (mutable)
fruits = ["apple", "banana", "orange"]

# Tuple (immutable)
coordinates = (10, 20)

# Dictionary
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

# Set
unique_numbers = {1, 2, 3, 4, 5}

Numeric Types

• integer_num (int): Represents the whole number 42, which is an immutable integer value. The int type is for storing positive or negative whole numbers without any decimal places.
• float_num (float): Represents the decimal number 3.14159. The float type is used for real numbers that contain a decimal point and can be positive or negative.
• complex_num (complex): Represents the complex number 3 + 4j, where 3 is the real part and 4j is the imaginary part. The j suffix indicates the imaginary component. 

String Type

• text (str): Represents the immutable sequence of characters “Hello, Python!”. It is enclosed in double quotes.
• multiline (str): Represents an immutable, multi-line string. It is created using triple double quotes ("""), which preserves the formatting and line breaks exactly as they appear in the code. 

Boolean Type

• is_python_fun (bool): Represents the truth value True. In Python, booleans are a built-in type with only two possible values: True and False.
• is_difficult (bool): Represents the truth value False. Boolean types are used for logical operations and conditional statements. 

List Type (Mutable Sequence)

• fruits (list): Represents an ordered, mutable sequence of strings, in this case, a list of fruit names. Items can be added, removed, or changed after the list is created. 

Tuple Type (Immutable Sequence)

• coordinates (tuple): Represents an ordered, immutable sequence of two integers. Once defined, the items within a tuple cannot be changed. 

Dictionary Type (Mapping)

• person (dict): Represents a mutable collection of key-value pairs. Each unique key (a string) maps to a specific value (a string or integer). Dictionaries are useful for storing structured data and accessing it by key. 

Set Type

• unique_numbers (set): Represents an unordered, mutable collection of unique integer elements. Sets automatically discard duplicate values and are efficient for membership testing and mathematical set operations.

Operators

graph TD
    A[Python Operators] --> B[Arithmetic]
    A --> C[Comparison]
    A --> D[Logical]
    A --> E[Assignment]
    A --> F[Membership]
    A --> G[Identity]

    B --> B1["+ - * / % ** //"]
    C --> C1["== != < > <= >="]
    D --> D1["and or not"]
    E --> E1["= += -= *= /="]
    F --> F1["in not in"]
    G --> G1["is is not"]

# Arithmetic operators
a, b = 10, 3
print(f"Addition: {a + b}")        # 13
print(f"Subtraction: {a - b}")     # 7
print(f"Multiplication: {a * b}")  # 30
print(f"Division: {a / b}")        # 3.333...
print(f"Floor Division: {a // b}") # 3
print(f"Modulus: {a % b}")         # 1
print(f"Exponentiation: {a ** b}") # 1000

# Comparison operators
print(f"Equal: {a == b}")          # False
print(f"Not equal: {a != b}")      # True
print(f"Greater than: {a > b}")    # True

# Logical operators
x, y = True, False
print(f"AND: {x and y}")           # False
print(f"OR: {x or y}")             # True
print(f"NOT: {not x}")             # False

# Arithmetic operators
a, b = 10, 3
print(f"Addition: {a + b}")        # 13
print(f"Subtraction: {a - b}")     # 7
print(f"Multiplication: {a * b}")  # 30
print(f"Division: {a / b}")        # 3.333...
print(f"Floor Division: {a // b}") # 3
print(f"Modulus: {a % b}")         # 1
print(f"Exponentiation: {a ** b}") # 1000

# Comparison operators
print(f"Equal: {a == b}")          # False
print(f"Not equal: {a != b}")      # True
print(f"Greater than: {a > b}")    # True

# Logical operators
x, y = True, False
print(f"AND: {x and y}")           # False
print(f"OR: {x or y}")             # True
print(f"NOT: {not x}")             # False

Multiple Assignment

• Code: a, b = 10, 3
• Explanation: This concisely assigns 10 to variable a and 3 to variable b in a single line. This is also called “tuple unpacking” because it effectively unpacks the values on the right-hand side and assigns them to the variables on the left. 

Arithmetic Operators

These are used to perform mathematical calculations on numeric values. 

Comparison Operators

These compare two values and return a boolean result (True or False). 

Logical Operators

These combine conditional statements and evaluate to a boolean value. 

Use of f-strings

The code uses f-strings (formatted string literals), a feature in Python 3.6+. 

• The f before the opening quote signifies that it is an f-string.
• Expressions or variables placed inside curly braces ({...}) are evaluated and converted into a string.
• For example, f"Addition: {a + b}" evaluates a + b to 13 and embeds it in the string. This makes the output readable and the code cleaner than other formatting methods.

Input and Output

# Getting user input
name = input("Enter your name: ")
age = int(input("Enter your age: "))

# Formatted output
print(f"Hello {name}, you are {age} years old!")

# Different ways to format strings
print("Hello %s, you are %d years old!" % (name, age))
print("Hello {}, you are {} years old!".format(name, age))
print("Hello {name}, you are {age} years old!".format(name=name, age=age))

# Getting user input
name = input("Enter your name: ")
age = int(input("Enter your age: "))

# Formatted output
print(f"Hello {name}, you are {age} years old!")

# Different ways to format strings
print("Hello %s, you are %d years old!" % (name, age))
print("Hello {}, you are {} years old!".format(name, age))
print("Hello {name}, you are {age} years old!".format(name=name, age=age))

User input

• name = input("Enter your name: "): The input() function is a built-in Python function that prompts the user for input, pauses the program until the user types a value, and then returns that value as a string. The string prompt inside the parentheses is optional and is displayed to the user to give them instructions.
• age = int(input("Enter your age: ")):
  • The inner input("Enter your age: ") function first collects a string from the user, such as "30".
  • The outer int() function then converts that string into an integer (30).
  • This explicit type conversion (or “type casting”) is necessary because the input() function always returns a string, even if the user enters a number. If you tried to perform a mathematical operation with the original string input, it would result in an error. 

Formatted string output

The code demonstrates several methods for formatting strings in Python, from the newest and most readable to older, legacy methods. 

1. F-strings (Formatted String Literals)

• Code: print(f"Hello {name}, you are {age} years old!")
• Explanation: F-strings, introduced in Python 3.6, are the modern and most recommended way to format strings.
  • The f at the beginning signifies a formatted string.
  • Variables and expressions enclosed in curly braces ({...}) are evaluated at runtime and replaced with their values.
  • This method is highly readable and performant. 

2. % Operator (C-style Formatting)

• Code: print("Hello %s, you are %d years old!" % (name, age))
• Explanation: This is an older, legacy method of formatting strings inspired by the printf function in the C language.
  • Format Specifiers: It uses format specifiers like %s for a string and %d for a decimal integer.
  • Variables: The variables to be substituted are passed as a tuple to the right of the % operator. 

3. str.format() Method

• Code: print("Hello {}, you are {} years old!".format(name, age))
• Explanation: This method, introduced in Python 2.6, is more flexible than the % operator. It uses {} as placeholders.
  • Positional Arguments: Without any numbers in the {} placeholders, the format() method fills them in with the arguments provided, in order. 

4. str.format() with Named Arguments

• Code: print("Hello {name}, you are {age} years old!".format(name=name, age=age))
• Explanation: This variation of the str.format() method uses named placeholders.
  • Keyword Arguments: You can pass arguments to the format() method using keyword arguments, which improves the readability of the formatting string by clearly associating the placeholder with its corresponding variable.

Control Flow

Conditional Statements

flowchart TD
    A[Start] --> B{Condition}
    B -->|True| C[Execute if block]
    B -->|False| D{Elif condition?}
    D -->|True| E[Execute elif block]
    D -->|False| F[Execute else block]
    C --> G[End]
    E --> G
    F --> G

# If-elif-else statements
score = 85

if score >= 90:
    grade = "A"
    print("Excellent!")
elif score >= 80:
    grade = "B"
    print("Good job!")
elif score >= 70:
    grade = "C"
    print("Average")
elif score >= 60:
    grade = "D"
    print("Needs improvement")
else:
    grade = "F"
    print("Failed")

print(f"Your grade is: {grade}")

# Ternary operator
status = "Pass" if score >= 60 else "Fail"
print(f"Status: {status}")

# If-elif-else statements
score = 85

if score >= 90:
    grade = "A"
    print("Excellent!")
elif score >= 80:
    grade = "B"
    print("Good job!")
elif score >= 70:
    grade = "C"
    print("Average")
elif score >= 60:
    grade = "D"
    print("Needs improvement")
else:
    grade = "F"
    print("Failed")

print(f"Your grade is: {grade}")

# Ternary operator
status = "Pass" if score >= 60 else "Fail"
print(f"Status: {status}")

If-elif-else statements

This block of code is a conditional statement that executes different code depending on whether the specified conditions are true or false. Python evaluates each condition in order, from top to bottom. 

• score = 85: A variable score is initialized with the integer value 85.
• if score >= 90:: The interpreter first checks if score is greater than or equal to 90.
  • Since 85 >= 90 is false, this block is skipped.
• elif score >= 80:: The interpreter moves to the next condition, checking if score is greater than or equal to 80.
  • 85 >= 80 is true, so the code inside this block is executed.
  • grade is set to "B".
  • "Good job!" is printed to the console.
• Execution stops: As soon as a true condition is found in an if-elif-else block, the corresponding code runs, and the rest of the conditions (elif and else) are skipped.
• print(f"Your grade is: {grade}"): After the conditional block, the final grade value, which is "B", is printed using an f-string. 

Ternary operator

This is a single-line shorthand for a simple if-else statement. It is a concise way to assign a value to a variable based on a single condition. 

• Code: status = "Pass" if score >= 60 else "Fail"
• How it works:
  • The code first evaluates the condition score >= 60.
  • Since 85 >= 60 is true, the expression returns the value before the if, which is "Pass".
  • This value is then assigned to the status variable.
• Equivalent if-else statement: if score >= 60: status = "Pass" else: status = "Fail" print(f"Status: {status}"): The final value of the status variable, "Pass", is printed to the console.

Loops

flowchart TD
    A[For Loop] --> B[Iterate over sequence]
    B --> C[Execute code block]
    C --> D{More items?}
    D -->|Yes| C
    D -->|No| E[End]

    F[While Loop] --> G{Condition True?}
    G -->|Yes| H[Execute code block]
    H --> G
    G -->|No| I[End]

# For loops
fruits = ["apple", "banana", "orange"]

# Iterate over list
for fruit in fruits:
    print(f"I like {fruit}")

# Iterate with index
for index, fruit in enumerate(fruits):
    print(f"{index + 1}. {fruit}")

# Range function
for i in range(1, 6):  # 1 to 5
    print(f"Number: {i}")

# While loops
count = 0
while count < 5:
    print(f"Count: {count}")
    count += 1

# Loop control statements
for i in range(10):
    if i == 3:
        continue  # Skip iteration
    if i == 7:
        break     # Exit loop
    print(i)

# Nested loops
for i in range(3):
    for j in range(3):
        print(f"({i}, {j})")

# For loops
fruits = ["apple", "banana", "orange"]

# Iterate over list
for fruit in fruits:
    print(f"I like {fruit}")

# Iterate with index
for index, fruit in enumerate(fruits):
    print(f"{index + 1}. {fruit}")

# Range function
for i in range(1, 6):  # 1 to 5
    print(f"Number: {i}")

# While loops
count = 0
while count < 5:
    print(f"Count: {count}")
    count += 1

# Loop control statements
for i in range(10):
    if i == 3:
        continue  # Skip iteration
    if i == 7:
        break     # Exit loop
    print(i)

# Nested loops
for i in range(3):
    for j in range(3):
        print(f"({i}, {j})")

For loops

A for loop iterates over a sequence, such as a list, tuple, or string, or other iterable objects. The loop runs a block of code for each item in the sequence. 

• Iterating over a list:
  • Code: for fruit in fruits:
  • Explanation: The loop steps through each element of the fruits list. In each iteration, the variable fruit is assigned the current element’s value, which is then used within the loop.
• Iterating with enumerate():
  • Code: for index, fruit in enumerate(fruits):
  • Explanation: The enumerate() function is a way to iterate through a sequence while automatically keeping track of the index. It provides both the index and the value during each iteration.
• Using the range() function:
  • Code: for i in range(1, 6):
  • Explanation: The range() function generates a sequence of numbers. range(start, stop) generates numbers from start up to, but not including, stop. Here, it produces the sequence 1, 2, 3, 4, 5. 

While loops

A while loop repeatedly runs a block of code as long as a specified condition is true. 

• Code: while count < 5:
• Explanation: The program first initializes count to 0. The loop checks if count < 5 is true. If true, the code inside the loop runs, printing the count and then incrementing it by 1. This repeats until count becomes 5, at which point the condition becomes false and the loop terminates. 

Loop control statements

These statements alter the normal flow of a loop based on specific conditions. 

• continue: Jumps to the next iteration of the loop, skipping any remaining code in the current iteration.
  • Code: if i == 3: continue
  • Explanation: In the for loop, when i is 3, the continue statement is executed. This causes the program to skip the print(i) statement for that iteration and proceed to the next number in the range.
• break: Immediately exits the loop entirely.
  • Code: if i == 7: break
  • Explanation: When i becomes 7, the break statement is executed, and the program terminates the loop completely, skipping the rest of the numbers in the range. 

Nested loops

A nested loop is a loop inside another loop. The inner loop completes all of its iterations for each single iteration of the outer loop. 

• Code: for i in range(3): for j in range(3):
• Explanation: The outer loop (for i) runs three times. For each time the outer loop runs, the inner loop (for j) runs completely, also three times. This results in a total of nine print statements, producing all the coordinate pairs from (0, 0) to (2, 2).

Loop Patterns

flowchart TD
    A[Start] --> B[Initialize range of x]
    B --> C{Loop through each x}
    C --> D["Check condition (if any)"]
    D -->|True| E[Compute x**2]
    D -->|False| C
    E --> F[Store in list or dict]
    F --> C
    C --> G[End]

# List comprehension
squares = [x**2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# Conditional list comprehension
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares)  # [4, 16, 36, 64, 100]

# Dictionary comprehension
square_dict = {x: x**2 for x in range(1, 6)}
print(square_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# List comprehension
squares = [x**2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# Conditional list comprehension
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares)  # [4, 16, 36, 64, 100]

# Dictionary comprehension
square_dict = {x: x**2 for x in range(1, 6)}
print(square_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

List comprehension

List comprehensions provide a concise way to create lists. They consist of an expression followed by a for clause, and optionally, one or more if or for clauses. They offer a more readable and often more efficient alternative to traditional for loops for creating lists.

• Basic list comprehension:
  • Code: squares = [x**2 for x in range(1, 6)]
  • Explanation:
    1. range(1, 6) generates numbers from 1 to 5 (i.e., 1, 2, 3, 4, 5).
    2. for x in range(1, 6) iterates through each number in this sequence.
    3. x**2 is the expression that calculates the square of each number x.
    4. The results of this expression are collected into a new list called squares.
  • Output: [1, 4, 9, 16, 25]
• Conditional list comprehension:
  • Code: even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
  • Explanation: This comprehension adds an if clause to filter elements.
    1. range(1, 11) generates numbers from 1 to 10.
    2. for x in range(1, 11) iterates through these numbers.
    3. if x % 2 == 0 checks if the current number x is even (i.e., its remainder when divided by 2 is 0).
    4. Only if the if condition is True is x**2 calculated and added to the even_squares list.
  • Output: [4, 16, 36, 64, 100] 

Dictionary comprehension

Similar to list comprehensions, dictionary comprehensions provide a concise way to create dictionaries. They consist of a key-value pair expression followed by a for clause, and optionally, one or more if or for clauses.

• Code: square_dict = {x: x**2 for x in range(1, 6)}
• Explanation:
  1. range(1, 6) generates numbers from 1 to 5.
  2. for x in range(1, 6) iterates through each number in this sequence.
  3. x: x**2 is the expression that defines the key-value pair for each item. Here, x becomes the key, and x**2 becomes its corresponding value.
  4. These key-value pairs are collected into a new dictionary called square_dict.
• Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Functions

Function Basics

graph TD
    A[Function Definition] --> B[def keyword]
    A --> C[Function name]
    A --> D[Parameters]
    A --> E[Function body]
    A --> F[Return statement]

    G[Function Call] --> H[Function name]
    G --> I[Arguments]

    J[Function Benefits] --> K[Code reusability]
    J --> L[Modularity]
    J --> M[Easier debugging]
    J --> N[Better organization]

# Basic function
def greet(name):
    """Greet a person with their name."""
    return f"Hello, {name}!"

# Function call
message = greet("Alice")
print(message)

# Function with multiple parameters
def add_numbers(a, b):
    """Add two numbers and return the result."""
    result = a + b
    return result

sum_result = add_numbers(5, 3)
print(f"Sum: {sum_result}")

# Function with default parameters
def introduce(name, age=25, city="Unknown"):
    """Introduce a person with optional age and city."""
    return f"Hi, I'm {name}, {age} years old from {city}"

print(introduce("Bob"))
print(introduce("Carol", 30))
print(introduce("Dave", 35, "Boston"))

# Basic function
def greet(name):
    """Greet a person with their name."""
    return f"Hello, {name}!"

# Function call
message = greet("Alice")
print(message)

# Function with multiple parameters
def add_numbers(a, b):
    """Add two numbers and return the result."""
    result = a + b
    return result

sum_result = add_numbers(5, 3)
print(f"Sum: {sum_result}")

# Function with default parameters
def introduce(name, age=25, city="Unknown"):
    """Introduce a person with optional age and city."""
    return f"Hi, I'm {name}, {age} years old from {city}"

print(introduce("Bob"))
print(introduce("Carol", 30))
print(introduce("Dave", 35, "Boston"))

Basic function

• def greet(name):: This defines a function named greet using the def keyword. The function accepts one argument, name, which is a placeholder for the value that will be passed when the function is called.
• """Greet a person with their name.""": This is a docstring, a type of comment used to explain the function’s purpose. Good practice dictates that you should use docstrings to document your functions for clarity.
• return f"Hello, {name}!": The return statement sends a value back to the code that called the function. In this case, it returns a formatted string literal (f-string) that includes the value of the name argument. 

Function call

• message = greet("Alice"): This line calls the greet function, passing the string "Alice" as an argument. The value returned by the function ("Hello, Alice!") is assigned to the message variable.
• print(message): This prints the value of the message variable to the console. 

Function with multiple parameters

• def add_numbers(a, b):: This function is defined with two parameters, a and b. The function needs two arguments to be passed when it is called.
• result = a + b: The function’s body calculates the sum of the two parameters and stores it in a local variable result.
• return result: The function returns the sum stored in the result variable.
• sum_result = add_numbers(5, 3): This calls add_numbers, passing the values 5 and 3. The arguments are assigned to the parameters a and b based on their position. The returned value (8) is stored in sum_result. 

Function with default parameters

• def introduce(name, age=25, city="Unknown"):: This function definition includes default values for the age and city parameters. If a caller does not provide a value for these parameters, the default value will be used automatically.
• print(introduce("Bob")):
  • This call provides only the name argument.
  • Since age and city are not provided, the function uses their default values (25 and "Unknown").
• print(introduce("Carol", 30)):
  • This call provides values for name and age.
  • The provided 30 overrides the default age value. The default city value is still used.
• print(introduce("Dave", 35, "Boston")):
  • This call explicitly provides values for all three parameters.
  • In this case, none of the default values are used.

Advanced Function Features

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

print(sum_all(1, 2, 3, 4, 5))  # 15

# Keyword arguments
def create_profile(**info):
    """Create a profile with keyword arguments."""
    profile = {}
    for key, value in info.items():
        profile[key] = value
    return profile

profile = create_profile(name="Alice", age=30, profession="Engineer")
print(profile)

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

# Higher-order functions
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

print(f"Squared: {squared}")
print(f"Even numbers: {even_numbers}")

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

print(sum_all(1, 2, 3, 4, 5))  # 15

# Keyword arguments
def create_profile(**info):
    """Create a profile with keyword arguments."""
    profile = {}
    for key, value in info.items():
        profile[key] = value
    return profile

profile = create_profile(name="Alice", age=30, profession="Engineer")
print(profile)

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

# Higher-order functions
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

print(f"Squared: {squared}")
print(f"Even numbers: {even_numbers}")

Variable arguments (*args)

• def sum_all(*numbers):: The *numbers syntax in a function definition allows the function to accept any number of positional arguments.
• How it works: When the sum_all() function is called, all the passed arguments (e.g., 1, 2, 3, 4, 5) are collected and “packed” into a tuple named numbers.
• Inside the function: The sum() built-in function is then applied to the numbers tuple to calculate the total sum.
• Output: 15. 

Keyword arguments (**kwargs)

• **def create_profile(**info):**: The **info syntax allows the function to accept any number of keyword arguments (key-value pairs).
• How it works: All the keyword arguments passed to create_profile() are collected and “packed” into a dictionary named info.
• Inside the function: The code iterates through the items of the info dictionary to build a new profile dictionary, demonstrating how to access the collected keyword arguments.
• Output: {'name': 'Alice', 'age': 30, 'profession': 'Engineer'}. 

Lambda functions

• **square = lambda x: x**2**: A lambda function is a small, anonymous (unnamed) function defined with the lambda keyword.
• Syntax: lambda arguments: expression
• Characteristics:
  • They are restricted to a single expression.
  • They are often used for short-term, throwaway operations.
• Output: square(5) returns 25, the result of the expression 5**2. 

Higher-order functions

A higher-order function is one that takes one or more functions as arguments or returns a function as its result. The map() and filter() functions are common examples. 

• map() with a lambda:
  • Code: squared = list(map(lambda x: x**2, numbers))
  • Explanation: The map() function applies the specified function (in this case, the lambda function that squares a number) to every item in an iterable (numbers).
  • Output: squared is [1, 4, 9, 16, 25].
• filter() with a lambda:
  • Code: even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
  • Explanation: The filter() function constructs an iterator from elements of an iterable for which a function (in this case, the lambda function that checks if a number is even) returns true.
  • Output: even_numbers is [2, 4]. 

Note: Both map() and filter() return iterator objects in Python 3, so list() is used to convert them into a list for printing.

Decorators

# Basic decorator
def timing_decorator(func):
    """Decorator to measure function execution time."""
    import time
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@timing_decorator
def slow_function():
    """A function that takes some time."""
    import time
    time.sleep(1)
    return "Done!"

result = slow_function()

# Basic decorator
def timing_decorator(func):
    """Decorator to measure function execution time."""
    import time
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@timing_decorator
def slow_function():
    """A function that takes some time."""
    import time
    time.sleep(1)
    return "Done!"

result = slow_function()

This code demonstrates a fundamental use of Python decorators: modifying the behavior of a function without changing its source code. The timing_decorator is applied to slow_function using the @timing_decorator syntax. When slow_function is called, the wrapper function within the decorator is executed instead. 

timing_decorator(func)

This is the decorator function, which accepts another function (func) as an argument. 

• It defines a nested function named wrapper.
• The wrapper function is a “closure” that retains access to the func variable from the enclosing scope, even after timing_decorator has finished executing.
• This wrapper is a general-purpose function that can accept any number of positional arguments (*args) and keyword arguments (**kwargs), making it reusable for any function signature.
• The decorator function returns the wrapper function. 

wrapper(*args, **kwargs)

This nested function contains the enhanced behavior.

• start_time = time.time(): It records the current timestamp before calling the original function.
• result = func(*args, **kwargs): It calls the original function (slow_function in this case), passing along all arguments it received. It also captures the return value of the original function.
• end_time = time.time(): It records the timestamp after the original function has finished executing.
• print(...): It prints a formatted string showing the original function’s name and the elapsed time.
• return result: It returns the result of the original function, ensuring the decorator doesn’t interfere with the function’s intended output. 

@timing_decorator

• This is “syntactic sugar” for replacing the original function with the decorated version.
• The line @timing_decorator is equivalent to writing slow_function = timing_decorator(slow_function).
• The original slow_function variable is reassigned to the wrapper function returned by timing_decorator, but the original function is still accessible within the wrapper as the func variable. 

slow_function()

• The function is executed, but because it is decorated, it is actually the wrapper that runs.
• Inside wrapper, slow_function() is called. It waits for one second using time.sleep(1) before returning the string "Done!".
• After the original function completes, the wrapper prints the time taken and then returns the "Done!" string, which is assigned to the result variable.

Data Structures

Lists

graph TD
    A[List Operations] --> B[Creation]
    A --> C[Access]
    A --> D[Modification]
    A --> E[Methods]

    B --> B1["Empty list: []"]
    B --> B2["With values: [1,2,3]"]
    B --> B3["list() constructor"]

    C --> C1["Indexing: list[0]"]
    C --> C2["Slicing: list[1:3]"]
    C --> C3["Negative indexing: list[-1]"]

    D --> D1[Append]
    D --> D2[Insert]
    D --> D3[Remove]
    D --> D4[Pop]

    E --> E1["sort()"]
    E --> E2["reverse()"]
    E --> E3["count()"]
    E --> E4["index()"]

# List creation and operations
fruits = ["apple", "banana", "orange"]

# Adding elements
fruits.append("grape")          # Add at end
fruits.insert(1, "kiwi")       # Insert at index
fruits.extend(["mango", "peach"])  # Add multiple items

print(f"Fruits: {fruits}")

# Accessing elements
print(f"First fruit: {fruits[0]}")
print(f"Last fruit: {fruits[-1]}")
print(f"First three: {fruits[:3]}")

# Modifying elements
fruits[0] = "green apple"
print(f"Modified: {fruits}")

# List methods
fruits.sort()                   # Sort in place
print(f"Sorted: {fruits}")

fruits.reverse()                # Reverse in place
print(f"Reversed: {fruits}")

# List comprehension with conditions
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(f"Even squares: {even_squares}")

# List creation and operations
fruits = ["apple", "banana", "orange"]

# Adding elements
fruits.append("grape")          # Add at end
fruits.insert(1, "kiwi")       # Insert at index
fruits.extend(["mango", "peach"])  # Add multiple items

print(f"Fruits: {fruits}")

# Accessing elements
print(f"First fruit: {fruits[0]}")
print(f"Last fruit: {fruits[-1]}")
print(f"First three: {fruits[:3]}")

# Modifying elements
fruits[0] = "green apple"
print(f"Modified: {fruits}")

# List methods
fruits.sort()                   # Sort in place
print(f"Sorted: {fruits}")

fruits.reverse()                # Reverse in place
print(f"Reversed: {fruits}")

# List comprehension with conditions
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(f"Even squares: {even_squares}")

List creation and initialization

• fruits = ["apple", "banana", "orange"]: This creates and initializes a list named fruits. A list is an ordered, mutable collection of items enclosed in square brackets. 

Adding elements

• fruits.append("grape"): The .append() method adds a single element to the end of the list.
• fruits.insert(1, "kiwi"): The .insert() method adds an element at a specific index. The existing elements from that index onward are shifted to make space for the new item.
• fruits.extend(["mango", "peach"]): The .extend() method adds all the elements from an iterable (like another list) to the end of the current list.
• Result: The list fruits becomes ['apple', 'kiwi', 'banana', 'orange', 'grape', 'mango', 'peach']. 

Accessing elements

• fruits[0]: Accesses the first element of the list using its index, which is 0 in Python.
• fruits[-1]: Accesses the last element of the list using negative indexing.
• fruits[:3]: Uses list slicing to get a sub-list containing the first three elements. The slice includes the starting index (0) but excludes the ending index (3). 

Modifying elements

• fruits[0] = "green apple": Since lists are mutable, you can change an element by assigning a new value to its index.
• Result: The list fruits becomes ['green apple', 'kiwi', 'banana', 'orange', 'grape', 'mango', 'peach']. 

List methods

• fruits.sort(): The .sort() method sorts the elements of the list in place (it modifies the original list). For strings, this is done alphabetically.
• fruits.reverse(): The .reverse() method reverses the order of the elements in the list in place. 

List comprehension with conditions

• **even_squares = [x**2 **for x in numbers if x % 2 == 0]**:
  • This is a concise way to create a new list by applying an expression to each item in an iterable.
  • for x in numbers: Iterates through each element in the numbers list.
  • if x % 2 == 0: A condition that filters the elements. Only even numbers (x divided by 2 has a remainder of 0) will be processed.
  • **x**2****: The expression that squares each even number.
• Output: The resulting list even_squares will contain the squares of all the even numbers from the original numbers list.

Dictionaries

graph TD
    A[Dictionary] --> B[Key-Value Pairs]
    A --> C[Mutable]
    A --> D[Unordered]
    A --> E[Methods]

    B --> B1[Keys must be immutable]
    B --> B2[Values can be any type]

    E --> E1["keys()"]
    E --> E2["values()"]
    E --> E3["items()"]
    E --> E4["get()"]
    E --> E5["pop()"]
    E --> E6["update()"]

# Dictionary creation and operations
student = {
    "name": "Alice",
    "age": 20,
    "grades": [85, 90, 78, 92],
    "is_enrolled": True
}

# Accessing values
print(f"Name: {student['name']}")
print(f"Age: {student.get('age', 'Unknown')}")

# Adding/updating values
student["major"] = "Computer Science"
student["age"] = 21

# Dictionary methods
print(f"Keys: {list(student.keys())}")
print(f"Values: {list(student.values())}")
print(f"Items: {list(student.items())}")

# Iterating through dictionary
for key, value in student.items():
    print(f"{key}: {value}")

# Dictionary comprehension
squares_dict = {x: x**2 for x in range(1, 6)}
print(f"Squares: {squares_dict}")

# Nested dictionaries
class_roster = {
    "student1": {"name": "Alice", "grade": 85},
    "student2": {"name": "Bob", "grade": 90},
    "student3": {"name": "Carol", "grade": 78}
}

for student_id, info in class_roster.items():
    print(f"{student_id}: {info['name']} - Grade: {info['grade']}")

# Dictionary creation and operations
student = {
    "name": "Alice",
    "age": 20,
    "grades": [85, 90, 78, 92],
    "is_enrolled": True
}

# Accessing values
print(f"Name: {student['name']}")
print(f"Age: {student.get('age', 'Unknown')}")

# Adding/updating values
student["major"] = "Computer Science"
student["age"] = 21

# Dictionary methods
print(f"Keys: {list(student.keys())}")
print(f"Values: {list(student.values())}")
print(f"Items: {list(student.items())}")

# Iterating through dictionary
for key, value in student.items():
    print(f"{key}: {value}")

# Dictionary comprehension
squares_dict = {x: x**2 for x in range(1, 6)}
print(f"Squares: {squares_dict}")

# Nested dictionaries
class_roster = {
    "student1": {"name": "Alice", "grade": 85},
    "student2": {"name": "Bob", "grade": 90},
    "student3": {"name": "Carol", "grade": 78}
}

for student_id, info in class_roster.items():
    print(f"{student_id}: {info['name']} - Grade: {info['grade']}")

Dictionary creation and initialization

• student = { ... }: A dictionary named student is created using curly braces {}.
• A dictionary stores data as unique key: value pairs.
• The student dictionary stores a variety of data types, including a string ("Alice"), an integer (20), a list of integers ([85, 90, 78, 92]), and a boolean (True). 

Accessing values

• student['name']: Uses bracket [] notation to access the value associated with the key "name". This method will raise a KeyError if the key does not exist.
• student.get('age', 'Unknown'): Uses the .get() method to access the value for the key "age".
  • Safeguard: This method is safer than bracket notation because it returns None by default (or a specified default value like 'Unknown') if the key is not found, preventing a KeyError. 

Adding and updating values

• student["major"] = "Computer Science": Adds a new key-value pair to the dictionary.
• student["age"] = 21: Updates the value for an existing key. Since dictionary keys must be unique, this overwrites the old value of 20 with 21. 

Dictionary methods

• .keys(): Returns a view object containing all the keys in the dictionary.
• .values(): Returns a view object containing all the values in the dictionary.
• .items(): Returns a view object containing all key-value pairs as tuples.
• list(...): The view objects returned by these methods are dynamic and can be iterated over, but they are not lists. Using list() converts the view into a static list for printing or other operations. 

Iterating through a dictionary

• for key, value in student.items():: This is the most efficient and Pythonic way to loop through a dictionary to access both keys and values simultaneously. The .items() method returns key-value pairs as tuples, which are then unpacked into the key and value variables for each iteration. 

Dictionary comprehension

• squares_dict = {x: x**2 **for x in range(1, 6)}: A concise way to create a new dictionary from an iterable.
  • How it works: It loops through the numbers 1 to 5 from range(1, 6). For each number x, it creates a key-value pair where the key is x and the value is x squared (x**2). 

Nested dictionaries

• class_roster = { ... }: A dictionary where the values are themselves other dictionaries. This allows for structuring more complex data.
• for student_id, info in class_roster.items():: The outer loop iterates through the class_roster dictionary. student_id is the key (e.g., "student1"), and info is the value, which is the inner dictionary (e.g., {"name": "Alice", "grade": 85}).
• info['name']: In each iteration, you can access the values of the inner dictionary info using its keys, such as 'name' and 'grade'.

Sets

flowchart TD
    A["fruits = {'apple', 'banana', 'orange'}"] --> B["fruits.add('grape')"]
    B --> C["fruits = {'apple', 'banana', 'orange', 'grape'}"]
    C --> D["fruits.discard('banana')"]
    D --> E["fruits = {'apple', 'orange', 'grape'}"]

# Set operations
fruits = {"apple", "banana", "orange"}
vegetables = {"carrot", "broccoli", "spinach"}
healthy_foods = {"apple", "banana", "carrot", "broccoli"}

# Set operations
print(f"Fruits: {fruits}")
print(f"Union: {fruits | healthy_foods}")
print(f"Intersection: {fruits & healthy_foods}")
print(f"Difference: {fruits - healthy_foods}")

# Set methods
fruits.add("grape")
fruits.discard("banana")  # Won't raise error if not found
print(f"Modified fruits: {fruits}")

# Set operations
fruits = {"apple", "banana", "orange"}
vegetables = {"carrot", "broccoli", "spinach"}
healthy_foods = {"apple", "banana", "carrot", "broccoli"}

# Set operations
print(f"Fruits: {fruits}")
print(f"Union: {fruits | healthy_foods}")
print(f"Intersection: {fruits & healthy_foods}")
print(f"Difference: {fruits - healthy_foods}")

# Set methods
fruits.add("grape")
fruits.discard("banana")  # Won't raise error if not found
print(f"Modified fruits: {fruits}")

Set creation and initialization

• fruits = {"apple", "banana", "orange"}: A set named fruits is created using curly braces {}. Unlike a list or tuple, a set is an unordered collection and does not allow duplicate elements.
• vegetables = { ... } and healthy_foods = { ... }: These lines create other sets that are used to demonstrate set operations. 

Set operations

Set operations are mathematical-like operations that can be performed on sets using operators or built-in methods.

• Union (|): Combines all unique elements from both sets.
  • Code: fruits | healthy_foods
  • Explanation: The union of fruits ({"apple", "banana", "orange"}) and healthy_foods ({"apple", "banana", "carrot", "broccoli"}) results in a new set containing all the unique elements from both.
  • Output: {'apple', 'banana', 'orange', 'carrot', 'broccoli'} (the order may vary)
• Intersection (&): Returns a new set containing only the elements common to both sets.
  • Code: fruits & healthy_foods
  • Explanation: The intersection identifies the elements that are in both fruits and healthy_foods.
  • Output: {'apple', 'banana'}
• Difference (-): Returns a new set with elements from the first set that are not present in the second.
  • Code: fruits - healthy_foods
  • Explanation: This operation removes all elements found in healthy_foods from the fruits set.
  • Output: {'orange'} 

Set methods

Sets have built-in methods for modifying or inspecting the set.

• .add("grape"): Adds a single element to the set. If the element is already present, the set remains unchanged.
• .discard("banana"): Removes a specified element from the set if it is present. The key difference from the .remove() method is that .discard() does not raise an error if the item is not found, making it safer to use when you are unsure if an element exists.
• fruits modification: After the .add() and .discard() calls, the fruits set is modified in place.
  • Final Output: {'apple', 'orange', 'grape'}

Tuples

mindmap
  root((Tuple Operations))
    Basic Tuples
      coordinates = (10, 20)
      rgb_color = (255, 128, 0)
    Unpacking
      x, y = coordinates
      r, g, b = rgb_color
    Named Tuples
      Point(x, y)
        point = (10, 20)
      Person(name, age, city)
        person = ('Alice', 30, 'New York')

classDiagram
    class Point {
        + x : int
        + y : int
    }

    class Person {
        + name : str
        + age : int
        + city : str
    }

    class point {
        <<instance>>
        x = 10
        y = 20
    }

    class person {
        <<instance>>
        name = "Alice"
        age = 30
        city = "New York"
    }

    Point <|-- point : instantiates
    Person <|-- person : instantiates

# Tuple operations
coordinates = (10, 20)
rgb_color = (255, 128, 0)

# Tuple unpacking
x, y = coordinates
r, g, b = rgb_color

print(f"Coordinates: x={x}, y={y}")
print(f"Color: R={r}, G={g}, B={b}")

# Named tuples
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
point = Point(10, 20)
print(f"Point: x={point.x}, y={point.y}")

Person = namedtuple('Person', ['name', 'age', 'city'])
person = Person("Alice", 30, "New York")
print(f"Person: {person.name}, {person.age}, {person.city}")

# Tuple operations
coordinates = (10, 20)
rgb_color = (255, 128, 0)

# Tuple unpacking
x, y = coordinates
r, g, b = rgb_color

print(f"Coordinates: x={x}, y={y}")
print(f"Color: R={r}, G={g}, B={b}")

# Named tuples
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
point = Point(10, 20)
print(f"Point: x={point.x}, y={point.y}")

Person = namedtuple('Person', ['name', 'age', 'city'])
person = Person("Alice", 30, "New York")
print(f"Person: {person.name}, {person.age}, {person.city}")

Tuple creation and unpacking

• coordinates = (10, 20): A tuple is an immutable, ordered sequence of elements. Like lists, they can store different types of data. Tuples are defined using parentheses () and are often used for data that should not change, such as a coordinate pair.
• x, y = coordinates: This is called tuple unpacking. Python assigns the values from the coordinates tuple (10, 20) to the variables x and y respectively. The number of variables on the left must match the number of elements in the tuple to avoid a ValueError.
• rgb_color = (255, 128, 0): Another tuple is created, representing a color code.
• r, g, b = rgb_color: The color tuple is unpacked into three variables for the red, green, and blue values. This improves readability by giving meaningful names to the variables. 

Named tuples

• from collections import namedtuple: The namedtuple factory function is imported from the collections module. It is used to create tuple-like subclasses with named fields.
• Point = namedtuple('Point', ['x', 'y']): A new class, Point, is created using namedtuple. It is defined with two field names, 'x' and 'y', which function like attributes for each instance of Point.
• point = Point(10, 20): An instance of the Point named tuple is created, with x set to 10 and y set to 20.
• print(f"Point: x={point.x}, y={point.y}"): Named tuples can be accessed via their field names using dot notation (.). This is more descriptive and readable than accessing elements via numerical index (e.g., point[0]), especially when a tuple contains many elements.
• Person = namedtuple('Person', ['name', 'age', 'city']): A second named tuple class, Person, is created to represent structured data.
• person = Person("Alice", 30, "New York"): An instance is created with the given values. Named tuples offer a lightweight way to create an object-like structure without the overhead of defining a full class.
• print(f"Person: {person.name}, {person.age}, {person.city}"): Accessing the Person data is clean and self-documenting. 

Benefits of using named tuples

• Readability: Accessing data by name (e.g., person.name) is much clearer than using an index (person[0]).
• Immutability: Like regular tuples, named tuples are immutable. This means their data cannot be changed after creation, making them safe for storing constant data.
• Efficiency: They are more memory-efficient than dictionaries and offer faster access speeds, making them suitable for representing a large number of data records.

Here is a beginner-friendly example of a simple but robust program that calculates the area of a rectangle.

flowchart TD
    A["Start calculate_rectangle_area(length, width)"] --> B{"length <= 0 or width <= 0?"}
    B -->|Yes| C["Print Error: Length and width must be positive"]
    C --> D[Return None]
    B -->|No| E["area = length * width"]
    E --> F[Return area]

sequenceDiagram
    participant U as User
    participant F as calculate_rectangle_area

    U->>F: (10, 5)
    F-->>U: 50
    U->>U: Print "The area of the rectangle is: 50"

    U->>F: (10, -5)
    F-->>U: None + "Error message"
    U->>U: Print "Could not calculate area due to invalid input."

    U->>F: (0, 5)
    F-->>U: None + "Error message"
    U->>U: Print "Could not calculate area due to invalid input."

"""
This module contains functions for working with rectangles.
"""
from typing import Optional, Union

# Good practice: use type hints for clarity.
def calculate_rectangle_area(length: Union[int, float], width: Union[int, float]) -> Optional[Union[int, float]]:
    """
    Calculates the area of a rectangle.

    This function takes a rectangle's length and width, validates them,
    and returns the area.

    Args:
        length: The length of the rectangle. Must be a positive number.
        width: The width of the rectangle. Must be a positive number.

    Returns:
        The calculated area, or None if the input is invalid.
    """
    # Good practice: handle potential errors and edge cases.
    if length <= 0 or width <= 0:
        print("Error: Length and width must be positive numbers.")
        return None

    # Good practice: use meaningful variable names.
    area = length * width
    return area

# This is a good practice to prevent code from running when the module is imported.
if __name__ == "__main__":
    # Example 1: Valid input
    rect_area = calculate_rectangle_area(10, 5)
    if rect_area is not None:
        # Good practice: use f-strings for clear, readable output.
        print(f"The area of the rectangle is: {rect_area}")

    # Example 2: Invalid input (negative width)
    invalid_area = calculate_rectangle_area(10, -5)
    # The function prints an error message, but we still check the return value.
    if invalid_area is None:
        print("Could not calculate area due to invalid input.")

    # Example 3: Invalid input (zero length)
    zero_area = calculate_rectangle_area(0, 5)
    if zero_area is None:
        print("Could not calculate area due to invalid input.")

"""
This module contains functions for working with rectangles.
"""
from typing import Optional, Union

# Good practice: use type hints for clarity.
def calculate_rectangle_area(length: Union[int, float], width: Union[int, float]) -> Optional[Union[int, float]]:
    """
    Calculates the area of a rectangle.

    This function takes a rectangle's length and width, validates them,
    and returns the area.

    Args:
        length: The length of the rectangle. Must be a positive number.
        width: The width of the rectangle. Must be a positive number.

    Returns:
        The calculated area, or None if the input is invalid.
    """
    # Good practice: handle potential errors and edge cases.
    if length <= 0 or width <= 0:
        print("Error: Length and width must be positive numbers.")
        return None

    # Good practice: use meaningful variable names.
    area = length * width
    return area

# This is a good practice to prevent code from running when the module is imported.
if __name__ == "__main__":
    # Example 1: Valid input
    rect_area = calculate_rectangle_area(10, 5)
    if rect_area is not None:
        # Good practice: use f-strings for clear, readable output.
        print(f"The area of the rectangle is: {rect_area}")

    # Example 2: Invalid input (negative width)
    invalid_area = calculate_rectangle_area(10, -5)
    # The function prints an error message, but we still check the return value.
    if invalid_area is None:
        print("Could not calculate area due to invalid input.")

    # Example 3: Invalid input (zero length)
    zero_area = calculate_rectangle_area(0, 5)
    if zero_area is None:
        print("Could not calculate area due to invalid input.")

Explanation of production-grade practices

• Modularization: The code is organized into a single file (rectangle.py) with a clear purpose. For larger projects, code would be split across multiple modules and packages, a key principle of the “Don’t Repeat Yourself” (DRY) philosophy.
• Documentation (Docstrings): The code includes a docstring that explains what the module does. The calculate_rectangle_area function also has a docstring explaining its purpose, arguments (Args), and return values (Returns), following the PEP 257 convention.
• Type Hinting: The code uses type hints (->, :) to indicate the expected types for function parameters and return values. This makes the code easier to understand and can be used by linters and IDEs to catch potential errors.
• Error Handling and Input Validation: The calculate_rectangle_area function explicitly checks for invalid input (non-positive numbers) and handles it gracefully by printing an error and returning None. This prevents the program from crashing and helps with debugging.
• Clear and Consistent Naming: The code follows PEP 8 naming conventions, such as snake_case for function and variable names, which makes the code easy to read.
• Safe Entry Point (if __name__ == "__main__":): The example usage code is placed within an if __name__ == "__main__": block. This is a standard practice that ensures the code inside the block only runs when the script is executed directly, not when it is imported as a module by another script.

Object-Oriented Programming

Classes and Objects

classDiagram
    class Person {
        <<class>>
        - species : str = "Homo sapiens"
        - name : str
        - age : int
        - email : str
        + __init__(name: str, age: int, email: str)
        + introduce() str
        + have_birthday() void
        + __str__() str
        + __repr__() str
    }

    class person1 {
        <<instance>>
        name = "Alice"
        age = 25
        email = "alice@email.com"
    }

    class person2 {
        <<instance>>
        name = "Bob"
        age = 30
        email = "bob@email.com"
    }

    Person <|-- person1 : instantiates
    Person <|-- person2 : instantiates

# Basic class definition
class Person:
    """A class to represent a person."""

    # Class variable
    species = "Homo sapiens"

    def __init__(self, name, age, email):
        """Initialize a Person object."""
        # Instance variables
        self.name = name
        self.age = age
        self.email = email

    def introduce(self):
        """Return an introduction string."""
        return f"Hi, I'm {self.name}, {self.age} years old."

    def have_birthday(self):
        """Increment age by 1."""
        self.age += 1
        print(f"Happy birthday! {self.name} is now {self.age}")

    def __str__(self):
        """String representation of the person."""
        return f"Person(name='{self.name}', age={self.age})"

    def __repr__(self):
        """Developer representation of the person."""
        return f"Person('{self.name}', {self.age}, '{self.email}')"

# Creating objects
person1 = Person("Alice", 25, "alice@email.com")
person2 = Person("Bob", 30, "bob@email.com")

print(person1.introduce())
print(person2.introduce())

person1.have_birthday()
print(f"Alice's new age: {person1.age}")

# Basic class definition
class Person:
    """A class to represent a person."""

    # Class variable
    species = "Homo sapiens"

    def __init__(self, name, age, email):
        """Initialize a Person object."""
        # Instance variables
        self.name = name
        self.age = age
        self.email = email

    def introduce(self):
        """Return an introduction string."""
        return f"Hi, I'm {self.name}, {self.age} years old."

    def have_birthday(self):
        """Increment age by 1."""
        self.age += 1
        print(f"Happy birthday! {self.name} is now {self.age}")

    def __str__(self):
        """String representation of the person."""
        return f"Person(name='{self.name}', age={self.age})"

    def __repr__(self):
        """Developer representation of the person."""
        return f"Person('{self.name}', {self.age}, '{self.email}')"

# Creating objects
person1 = Person("Alice", 25, "alice@email.com")
person2 = Person("Bob", 30, "bob@email.com")

print(person1.introduce())
print(person2.introduce())

person1.have_birthday()
print(f"Alice's new age: {person1.age}")

Class Person

This code defines a class named Person which acts as a blueprint for creating objects that represent people. 

Attributes

• Class variable (species):species = "Homo sapiens"
  • This variable is defined at the class level and is shared by all instances (objects) of the Person class.
  • It holds a value that is constant for all people created from this blueprint.
• Instance variables (self.name, self.age, self.email):
  • These are unique to each instance of the class and are initialized within the special __init__ method.
  • Each Person object you create will have its own name, age, and email with potentially different values.
• self parameter:
  • The self parameter in method definitions refers to the instance of the class that the method is being called on.
  • It allows instance methods to access and modify the instance’s unique attributes. 

Methods

• __init__(self, name, age, email):
  • This is the constructor method, or “initializer,” and is automatically called whenever a new Person object is created.
  • It sets up the initial state of the object by assigning the passed name, age, and email arguments to the instance variables.
• introduce(self):
  • This is a custom instance method that returns a string introducing the person, using their unique name and age instance variables.
• have_birthday(self):
  • This method modifies the state of the object by incrementing the age instance variable by 1.
  • It shows that instance methods can change an object’s internal data.
• __str__(self):
  • This magic or “dunder” method is used to provide a user-friendly string representation of the object.
  • It is automatically called by the print() and str() functions.
  • Output is meant for the end-user.
• __repr__(self):
  • This magic method returns an official, unambiguous string representation of the object, typically used for debugging.
  • Ideally, the string could be used to recreate the object.
  • Output is meant for the developer. 

Creating and using objects

• person1 = Person("Alice", 25, "alice@email.com"): This line creates an instance of the Person class named person1. The arguments "Alice", 25, and "alice@email.com" are passed to the __init__ method to initialize the object’s instance variables.
• person2 = Person("Bob", 30, "bob@email.com"): A second, separate instance named person2 is created.
• person1.introduce(): This calls the introduce method on the person1 object. The method uses person1‘s unique data ("Alice", 25) to produce the output.
• person1.have_birthday(): This calls the have_birthday method on person1, modifying only that object’s age. person2‘s age remains unchanged.
• print(person1): This would implicitly call the person1 object’s __str__ method and print Person(name='Alice', age=26) (after the birthday).

Inheritance

classDiagram
    class Person {
        <<class>>
        - species : str = "Homo sapiens"
        - name : str
        - age : int
        - email : str
        + __init__(name: str, age: int, email: str)
        + introduce() str
        + have_birthday() void
        + __str__() str
        + __repr__() str
    }

    class Student {
        <<subclass>>
        - student_id : str
        - grades : list
        + __init__(name: str, age: int, email: str, student_id: str)
        + add_grade(grade: int) void
        + get_average() float
        + is_passing(passing_grade: int=60) bool
        + introduce() str
    }

    class Teacher {
        <<subclass>>
        - subject : str
        - salary : float
        + __init__(name: str, age: int, email: str, subject: str, salary: float)
        + teach() str
        + grade_student(student: Student, grade: int) void
    }

    %% Inheritance
    Person <|-- Student
    Person <|-- Teacher

    %% Instances
    class student {
        <<instance>>
        name = "Carol"
        age = 20
        email = "carol@email.com"
        student_id = "S12345"
        grades = [85, 92, 78, 88]
    }

    class teacher {
        <<instance>>
        name = "Dr. Smith"
        age = 45
        email = "smith@email.com"
        subject = "Mathematics"
        salary = 75000
    }

    Student <|-- student : instantiates
    Teacher <|-- teacher : instantiates
    Teacher --> Student : grades

# Inheritance example
class Student(Person):
    """A class to represent a student, inheriting from Person."""

    def __init__(self, name, age, email, student_id):
        """Initialize a Student object."""
        super().__init__(name, age, email)  # Call parent constructor
        self.student_id = student_id
        self.grades = []

    def add_grade(self, grade):
        """Add a grade to the student's record."""
        if 0 <= grade <= 100:
            self.grades.append(grade)
        else:
            print("Grade must be between 0 and 100")

    def get_average(self):
        """Calculate and return the average grade."""
        if self.grades:
            return sum(self.grades) / len(self.grades)
        return 0

    def is_passing(self, passing_grade=60):
        """Check if student is passing."""
        return self.get_average() >= passing_grade

    def introduce(self):
        """Override parent method."""
        return f"Hi, I'm {self.name}, a student with ID {self.student_id}."

class Teacher(Person):
    """A class to represent a teacher."""

    def __init__(self, name, age, email, subject, salary):
        """Initialize a Teacher object."""
        super().__init__(name, age, email)
        self.subject = subject
        self.salary = salary

    def teach(self):
        """Return a teaching message."""
        return f"{self.name} is teaching {self.subject}"

    def grade_student(self, student, grade):
        """Grade a student."""
        student.add_grade(grade)
        print(f"{self.name} gave {student.name} a grade of {grade}")

# Using inheritance
student = Student("Carol", 20, "carol@email.com", "S12345")
teacher = Teacher("Dr. Smith", 45, "smith@email.com", "Mathematics", 75000)

print(student.introduce())
print(teacher.introduce())

student.add_grade(85)
student.add_grade(92)
student.add_grade(78)

teacher.grade_student(student, 88)

print(f"Student average: {student.get_average():.2f}")
print(f"Is passing: {student.is_passing()}")

# Inheritance example
class Student(Person):
    """A class to represent a student, inheriting from Person."""

    def __init__(self, name, age, email, student_id):
        """Initialize a Student object."""
        super().__init__(name, age, email)  # Call parent constructor
        self.student_id = student_id
        self.grades = []

    def add_grade(self, grade):
        """Add a grade to the student's record."""
        if 0 <= grade <= 100:
            self.grades.append(grade)
        else:
            print("Grade must be between 0 and 100")

    def get_average(self):
        """Calculate and return the average grade."""
        if self.grades:
            return sum(self.grades) / len(self.grades)
        return 0

    def is_passing(self, passing_grade=60):
        """Check if student is passing."""
        return self.get_average() >= passing_grade

    def introduce(self):
        """Override parent method."""
        return f"Hi, I'm {self.name}, a student with ID {self.student_id}."

class Teacher(Person):
    """A class to represent a teacher."""

    def __init__(self, name, age, email, subject, salary):
        """Initialize a Teacher object."""
        super().__init__(name, age, email)
        self.subject = subject
        self.salary = salary

    def teach(self):
        """Return a teaching message."""
        return f"{self.name} is teaching {self.subject}"

    def grade_student(self, student, grade):
        """Grade a student."""
        student.add_grade(grade)
        print(f"{self.name} gave {student.name} a grade of {grade}")

# Using inheritance
student = Student("Carol", 20, "carol@email.com", "S12345")
teacher = Teacher("Dr. Smith", 45, "smith@email.com", "Mathematics", 75000)

print(student.introduce())
print(teacher.introduce())

student.add_grade(85)
student.add_grade(92)
student.add_grade(78)

teacher.grade_student(student, 88)

print(f"Student average: {student.get_average():.2f}")
print(f"Is passing: {student.is_passing()}")

Explanation of inheritance

Inheritance is a fundamental concept in Object-Oriented Programming (OOP) that allows a new class (the child or subclass) to adopt the attributes and methods of an existing class (the parent or base class). This promotes code reuse and creates a logical, hierarchical relationship between classes. 

Parent class (Person)

The Person class, from the previous example, serves as the base class for Student and Teacher. Both students and teachers are people and share common attributes like name, age, and email, which are defined in Person. 

Subclass: Student(Person)

The Student class inherits from Person, indicated by class Student(Person):.

• __init__(...): The constructor for Student takes its own specific parameters (student_id), but it also needs to initialize the inherited attributes from Person.
  • super().__init__(name, age, email): The super() function is used to call the __init__ method of the parent class (Person). This efficiently handles the initialization of attributes inherited from the parent without duplicating code.
• self.student_id, self.grades: These are new instance variables specific to the Student class.
• add_grade(), get_average(), is_passing(): These are new methods that extend the functionality of the Student class beyond what the Person class offers.
• introduce(): This method overrides the introduce() method from the Person class. When introduce() is called on a Student object, Python executes the Student version, not the Person version. This allows Student objects to provide a more specific introduction. 

Subclass: Teacher(Person)

The Teacher class also inherits from Person, and its methods and attributes extend the Person class in a different way.

• __init__(...): It uses super().__init__(...) to initialize the Person attributes and adds its own specific attributes like subject and salary.
• teach(): A method specific to teachers.
• grade_student(self, student, grade):
  • This method demonstrates polymorphism, where a Teacher object interacts with a Student object.
  • It uses a method from another class (student.add_grade(grade)) to perform a task. 

How inheritance is used in the example

• Object Creation: When student = Student(...) is called, a Student object is created. Python first calls the Person constructor via super() to set the name, age, and email, and then it sets the student_id and grades specific to the student.
• Method Overriding: print(student.introduce()) calls the introduce method from the Student class, while print(teacher.introduce()) calls the introduce method from the Person class, which Teacher inherited without modifying.
• Interaction between objects: The teacher object calls the add_grade method on the student object, demonstrating how different parts of a program can work together.
• Polymorphism: Both student and teacher objects are fundamentally Person objects, so they share the common characteristics of Person but also have their own specific methods and behaviors.

Advanced OOP Concepts

classDiagram
    class Shape {
        <>        + area()*        + perimeter()*    }    class Rectangle {        - width : float        - height : float        + __init__(width: float, height: float)        + area() float        + perimeter() float    }    class Circle {        - radius : float        + __init__(radius: float)        + area() float        + perimeter() float    }    class BankAccount {        - _balance : float        + __init__(initial_balance: float=0)        + balance : float <>        + deposit(amount: float) void        + withdraw(amount: float) void    }    %% Inheritance    Shape <|-- Rectangle    Shape <|-- Circle    %% Instances    class rectangle {        <>        width = 5        height = 10    }    class circle {        <>        radius = 3    }    class account {        <>        _balance = 1000    }    Rectangle <|-- rectangle : instantiates    Circle <|-- circle : instantiates    BankAccount <|-- account : instantiates

classDiagram
    class Shape {
        <<abstract>>
        + area()*
        + perimeter()*
    }

    class Rectangle {
        - width : float
        - height : float
        + __init__(width: float, height: float)
        + area() float
        + perimeter() float
    }

    class Circle {
        - radius : float
        + __init__(radius: float)
        + area() float
        + perimeter() float
    }

    class BankAccount {
        - _balance : float
        + __init__(initial_balance: float=0)
        + balance : float <<property>>
        + deposit(amount: float) void
        + withdraw(amount: float) void
    }

    %% Inheritance
    Shape <|-- Rectangle
    Shape <|-- Circle

    %% Instances
    class rectangle {
        <<instance>>
        width = 5
        height = 10
    }

    class circle {
        <<instance>>
        radius = 3
    }

    class account {
        <<instance>>
        _balance = 1000
    }

    Rectangle <|-- rectangle : instantiates
    Circle <|-- circle : instantiates
    BankAccount <|-- account : instantiates

# Abstract classes and methods
from abc import ABC, abstractmethod

class Shape(ABC):
    """Abstract base class for shapes."""

    @abstractmethod
    def area(self):
        """Calculate the area of the shape."""
        pass

    @abstractmethod
    def perimeter(self):
        """Calculate the perimeter of the shape."""
        pass

class Rectangle(Shape):
    """Rectangle class inheriting from Shape."""

    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    """Circle class inheriting from Shape."""

    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self.radius

# Property decorators
class BankAccount:
    """Bank account with property decorators."""

    def __init__(self, initial_balance=0):
        self._balance = initial_balance

    @property
    def balance(self):
        """Get the current balance."""
        return self._balance

    @balance.setter
    def balance(self, amount):
        """Set the balance with validation."""
        if amount < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = amount

    def deposit(self, amount):
        """Deposit money to the account."""
        if amount > 0:
            self._balance += amount
        else:
            raise ValueError("Deposit amount must be positive")

    def withdraw(self, amount):
        """Withdraw money from the account."""
        if amount > self._balance:
            raise ValueError("Insufficient funds")
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        self._balance -= amount

# Using the classes
rectangle = Rectangle(5, 10)
circle = Circle(3)

print(f"Rectangle area: {rectangle.area()}")
print(f"Circle area: {circle.area():.2f}")

account = BankAccount(1000)
print(f"Initial balance: ${account.balance}")

account.deposit(500)
print(f"After deposit: ${account.balance}")

account.withdraw(200)
print(f"After withdrawal: ${account.balance}")

# Abstract classes and methods
from abc import ABC, abstractmethod

class Shape(ABC):
    """Abstract base class for shapes."""

    @abstractmethod
    def area(self):
        """Calculate the area of the shape."""
        pass

    @abstractmethod
    def perimeter(self):
        """Calculate the perimeter of the shape."""
        pass

class Rectangle(Shape):
    """Rectangle class inheriting from Shape."""

    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    """Circle class inheriting from Shape."""

    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self.radius

# Property decorators
class BankAccount:
    """Bank account with property decorators."""

    def __init__(self, initial_balance=0):
        self._balance = initial_balance

    @property
    def balance(self):
        """Get the current balance."""
        return self._balance

    @balance.setter
    def balance(self, amount):
        """Set the balance with validation."""
        if amount < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = amount

    def deposit(self, amount):
        """Deposit money to the account."""
        if amount > 0:
            self._balance += amount
        else:
            raise ValueError("Deposit amount must be positive")

    def withdraw(self, amount):
        """Withdraw money from the account."""
        if amount > self._balance:
            raise ValueError("Insufficient funds")
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        self._balance -= amount

# Using the classes
rectangle = Rectangle(5, 10)
circle = Circle(3)

print(f"Rectangle area: {rectangle.area()}")
print(f"Circle area: {circle.area():.2f}")

account = BankAccount(1000)
print(f"Initial balance: ${account.balance}")

account.deposit(500)
print(f"After deposit: ${account.balance}")

account.withdraw(200)
print(f"After withdrawal: ${account.balance}")

Abstract classes and methods

• from abc import ABC, abstractmethod: The abc (Abstract Base Classes) module provides the tools for defining abstract classes in Python. ABC is the base class for abstract classes, and @abstractmethod is a decorator used to declare an abstract method.
• class Shape(ABC):: This defines Shape as an abstract base class. An abstract class cannot be instantiated directly. Its purpose is to define a common interface for its subclasses.
• @abstractmethod: This decorator marks the area() and perimeter() methods as abstract. Any non-abstract subclass of Shape must provide its own implementation for all abstract methods. If a subclass (e.g., Rectangle) fails to implement all abstract methods, Python will prevent you from creating an instance of that subclass.
• pass: The pass statement is a null operation. It is used here as a placeholder for the abstract method’s body, indicating that the method is intended to be implemented by a subclass.
• class Rectangle(Shape): and class Circle(Shape):: These are concrete subclasses that inherit from Shape. They are “concrete” because they provide implementations for all of Shape‘s abstract methods (area() and perimeter()).

Property decorators

Property decorators provide a way to create “managed” attributes in a class. They let you implement getter, setter, and deleter methods for an attribute, allowing you to add validation, logging, or other logic without changing the public interface.

• class BankAccount:: A class that models a bank account.
• _balance: The private instance variable _balance is created with a leading underscore _ by convention to indicate that it is intended for internal use only and should not be accessed directly by code outside the class.
• @property: This decorator is used on the balance() method. It turns this method into a “getter” method. Now, when you access account.balance (without parentheses), Python implicitly calls this balance() method.
• @balance.setter: This decorator is used on the setter method. It is the “setter” for the balance property.
  • Validation: It includes a check to ensure that the amount is not negative. If an invalid value is provided (e.g., account.balance = -100), it raises a ValueError.
• Direct method calls (deposit and withdraw): These methods show the standard way of performing actions on the account. They include input validation and logic to ensure the account state remains consistent.

Using the classes

• rectangle = Rectangle(5, 10): An instance of Rectangle is created. Since it has implemented the area() and perimeter() methods, it can be instantiated.
• circle = Circle(3): An instance of Circle is created.
• account = BankAccount(1000): A BankAccount object is created with an initial balance.
• print(f"Initial balance: ${account.balance}"): This line accesses the balance using the @property getter method. It is read as if it were a normal attribute.
• account.deposit(500): This line calls the deposit method to add funds.
• account.withdraw(200): This line calls the withdraw method to remove funds.

Note: If you tried to create an instance of the abstract Shape class, you would get a TypeError because it is an abstract class.

Error Handling

Exception Handling Flow

flowchart TD
    A[Start] --> B[Try Block]
    B --> C{Exception Occurs?}
    C -->|No| D[Continue Execution]
    C -->|Yes| E{Matching Except Block?}
    E -->|Yes| F[Execute Except Block]
    E -->|No| G[Unhandled Exception]
    F --> H[Finally Block]
    D --> H
    H --> I[End]
    G --> J[Program Crashes]

flowchart TD
    A["Start divide_numbers(a, b)"] --> B["Try: result = a / b"]
    B -->|Success| C[Return result]
    B -->|ZeroDivisionError| D["Print Error: Cannot divide by zero!"]
    D --> E[Return None]
    B -->|TypeError| F["Print Error: Please provide numeric values!"]
    F --> E
    C --> G[End]
    E --> G

flowchart TD
    A["Start process_data(data)"] --> B[Try block]
    B --> C["Convert data to int -> number = int(data)"]
    C --> D["result = 100 / number"]
    D --> E["index = [1,2,3][number]"]
    E -->|Success| F["Return (result, index)"]

    C -->|ValueError| G["Print Error: not a valid integer"]
    D -->|ZeroDivisionError| H["Print Error: Cannot divide by zero"]
    E -->|IndexError| I["Print Error: Index out of range"]
    B -->|Other Exception| J["Print Unexpected error: e"]

    G --> K["Finally: Print Processing completed"]
    H --> K
    I --> K
    J --> K
    F --> K
    K --> L[End]

# Basic exception handling
def divide_numbers(a, b):
    """Divide two numbers with error handling."""
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Error: Cannot divide by zero!")
        return None
    except TypeError:
        print("Error: Please provide numeric values!")
        return None

# Test the function
print(divide_numbers(10, 2))    # 5.0
print(divide_numbers(10, 0))    # Error message, returns None
print(divide_numbers(10, "2"))  # Error message, returns None

# Multiple exception handling
def process_data(data):
    """Process data with comprehensive error handling."""
    try:
        # Try to convert to integer and perform operations
        number = int(data)
        result = 100 / number
        index = [1, 2, 3][number]  # This might raise IndexError
        return result, index

    except ValueError:
        print(f"Error: '{data}' is not a valid integer")
    except ZeroDivisionError:
        print("Error: Cannot divide by zero")
    except IndexError:
        print("Error: Index out of range")
    except Exception as e:
        print(f"Unexpected error: {e}")
    finally:
        print("Processing completed")

# Test different scenarios
process_data("5")      # Normal case
process_data("abc")    # ValueError
process_data("0")      # ZeroDivisionError
process_data("10")     # IndexError

# Basic exception handling
def divide_numbers(a, b):
    """Divide two numbers with error handling."""
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Error: Cannot divide by zero!")
        return None
    except TypeError:
        print("Error: Please provide numeric values!")
        return None

# Test the function
print(divide_numbers(10, 2))    # 5.0
print(divide_numbers(10, 0))    # Error message, returns None
print(divide_numbers(10, "2"))  # Error message, returns None

# Multiple exception handling
def process_data(data):
    """Process data with comprehensive error handling."""
    try:
        # Try to convert to integer and perform operations
        number = int(data)
        result = 100 / number
        index = [1, 2, 3][number]  # This might raise IndexError
        return result, index

    except ValueError:
        print(f"Error: '{data}' is not a valid integer")
    except ZeroDivisionError:
        print("Error: Cannot divide by zero")
    except IndexError:
        print("Error: Index out of range")
    except Exception as e:
        print(f"Unexpected error: {e}")
    finally:
        print("Processing completed")

# Test different scenarios
process_data("5")      # Normal case
process_data("abc")    # ValueError
process_data("0")      # ZeroDivisionError
process_data("10")     # IndexError

Basic exception handling (try-except)

This block of code is a fundamental mechanism for anticipating and handling potential errors at runtime. 

• try block: This block contains the code that might raise an exception. If an error occurs during execution of this code, Python stops and immediately jumps to the appropriate except block.
• except ZeroDivisionError: This is an exception handler that specifically catches a ZeroDivisionError. If the try block attempts to divide by zero, this code is executed, printing a user-friendly error message instead of crashing the program. The function then returns None.
• except TypeError: This handler catches a TypeError, which occurs when an operation is performed on an inappropriate data type (e.g., trying to divide a number by a string). This block also prints an error and returns None. 

Example function calls

• divide_numbers(10, 2): This call executes the try block successfully, calculates 10 / 2, and returns 5.0.
• divide_numbers(10, 0): This call raises a ZeroDivisionError in the try block. Python catches it with the except ZeroDivisionError block, prints the error message, and returns None.
• divide_numbers(10, "2"): This call raises a TypeError in the try block. Python catches it with the except TypeError block, prints the error message, and returns None. 

Comprehensive exception handling (try-except-finally)

This example shows a more robust approach to handling different types of exceptions and introduces the finally block.

• try block: Contains multiple operations that could raise different exceptions:
  • int(data): Could raise a ValueError if data is not a valid number string.
  • 100 / number: Could raise a ZeroDivisionError if number is 0.
  • [1, 2, 3][number]: Could raise an IndexError if number is outside the valid index range (0, 1, or 2).
• Specific except blocks: The code provides separate except blocks for ValueError, ZeroDivisionError, and IndexError. When an exception is raised, Python looks for the first matching except block.
• General except block (except Exception as e): This acts as a catch-all for any other unforeseen exceptions that might occur. The exception object is assigned to the variable e, allowing you to inspect its details, such as the error message.
• finally block: This block is guaranteed to execute, regardless of whether an exception occurred or was handled. It is typically used for cleanup actions, like closing files or releasing resources. 

Example function calls

• process_data("5"): The try block runs without any exceptions. The finally block is executed afterward.
• process_data("abc"): int("abc") raises a ValueError, which is caught by the corresponding except block. The finally block then executes.
• process_data("0"): 100 / 0 raises a ZeroDivisionError, which is caught. The finally block executes.
• process_data("10"): The number is converted to 10, but [1, 2, 3][10] raises an IndexError, which is caught. The finally block executes.

Custom Exceptions

classDiagram
    class Exception {
    }

    class InsufficientFundsError {
        - balance : float
        - amount : float
        + __init__(balance: float, amount: float)
    }

    class InvalidAccountError {
    }

    class BankAccount {
        - account_number : str
        - balance : float
        + __init__(account_number: str, initial_balance: float=0)
        + withdraw(amount: float) void
    }

    %% Inheritance
    Exception <|-- InsufficientFundsError
    Exception <|-- InvalidAccountError

    %% Relationships
    BankAccount --> InsufficientFundsError : raises
    BankAccount --> InvalidAccountError : raises

flowchart TD
    A["Start withdraw(amount)"] --> B{"amount <= 0?"}
    B -->|Yes| C["Raise ValueError: 'Invalid amount'"]
    B -->|No| D{"amount > balance?"}
    D -->|Yes| E["Raise InsufficientFundsError(balance, amount)"]
    D -->|No| F[balance -= amount]
    F --> G[Return success]
    C --> H[Exception handling outside]
    E --> H
    G --> I[End]

sequenceDiagram
    participant U as User
    participant BA as BankAccount
    participant E as InsufficientFundsError

    U->>BA: withdraw(600)
    BA->>BA: Check amount > balance
    BA-->>E: raise InsufficientFundsError(500, 600)
    E-->>U: Exception caught
    U->>U: Print "Transaction failed: Insufficient funds..."

# Custom exception classes
class InsufficientFundsError(Exception):
    """Exception raised when account has insufficient funds."""

    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Insufficient funds: ${balance} available, ${amount} requested")

class InvalidAccountError(Exception):
    """Exception raised for invalid account operations."""
    pass

class BankAccount:
    """Bank account with custom exception handling."""

    def __init__(self, account_number, initial_balance=0):
        if not account_number:
            raise InvalidAccountError("Account number cannot be empty")
        self.account_number = account_number
        self.balance = initial_balance

    def withdraw(self, amount):
        """Withdraw money with custom exception handling."""
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")

        if amount > self.balance:
            raise InsufficientFundsError(self.balance, amount)

        self.balance -= amount
        return self.balance

    def deposit(self, amount):
        """Deposit money to the account."""
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")

        self.balance += amount
        return self.balance

# Using custom exceptions
try:
    account = BankAccount("ACC123", 1000)
    print(f"Initial balance: ${account.balance}")

    account.withdraw(500)
    print(f"After withdrawal: ${account.balance}")

    account.withdraw(600)  # This will raise InsufficientFundsError

except InsufficientFundsError as e:
    print(f"Transaction failed: {e}")
except InvalidAccountError as e:
    print(f"Account error: {e}")
except ValueError as e:
    print(f"Value error: {e}")

# Custom exception classes
class InsufficientFundsError(Exception):
    """Exception raised when account has insufficient funds."""

    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Insufficient funds: ${balance} available, ${amount} requested")

class InvalidAccountError(Exception):
    """Exception raised for invalid account operations."""
    pass

class BankAccount:
    """Bank account with custom exception handling."""

    def __init__(self, account_number, initial_balance=0):
        if not account_number:
            raise InvalidAccountError("Account number cannot be empty")
        self.account_number = account_number
        self.balance = initial_balance

    def withdraw(self, amount):
        """Withdraw money with custom exception handling."""
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")

        if amount > self.balance:
            raise InsufficientFundsError(self.balance, amount)

        self.balance -= amount
        return self.balance

    def deposit(self, amount):
        """Deposit money to the account."""
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")

        self.balance += amount
        return self.balance

# Using custom exceptions
try:
    account = BankAccount("ACC123", 1000)
    print(f"Initial balance: ${account.balance}")

    account.withdraw(500)
    print(f"After withdrawal: ${account.balance}")

    account.withdraw(600)  # This will raise InsufficientFundsError

except InsufficientFundsError as e:
    print(f"Transaction failed: {e}")
except InvalidAccountError as e:
    print(f"Account error: {e}")
except ValueError as e:
    print(f"Value error: {e}")

Custom exception classes

This code demonstrates how to create and use custom exceptions, which are user-defined classes that inherit from Python’s built-in Exception class. Using custom exceptions provides clearer, domain-specific error handling and improves code readability. 

InsufficientFundsError

• class InsufficientFundsError(Exception):: This defines a new exception class that inherits from the base Exception class. By convention, custom exception class names end with Error.
• def __init__(self, balance, amount):: The constructor of the custom exception accepts specific parameters (balance, amount) related to the error. This allows the exception to carry meaningful context about what went wrong.
• super().__init__(...): This line calls the constructor of the parent Exception class, passing it a formatted error message. This ensures that the message is stored correctly within the exception object. 

InvalidAccountError

• class InvalidAccountError(Exception):: Another custom exception class is defined for a different type of application-specific error.
• pass: This simple exception class does not require a custom constructor. It inherits everything from the base Exception class and serves as a specific type marker for catching this particular kind of error. 

BankAccount class

This class uses the custom exceptions to handle business logic errors.

• __init__(self, account_number, initial_balance=0):: The constructor for the BankAccount validates the account_number. If it’s empty, it raises the InvalidAccountError custom exception, which is more specific than a generic ValueError.
• withdraw(self, amount)::
  • Built-in ValueError: Used for an invalid input value (amount <= 0), which aligns with Python’s convention for parameter validation.
  • Custom InsufficientFundsError: Used for a domain-specific error condition (amount > self.balance). The raise statement creates and throws an instance of the custom exception, passing the current balance and the requested amount to its constructor. 

Using and catching custom exceptions

The try-except block demonstrates how to use and handle the different types of exceptions.

• account = BankAccount("ACC123", 1000): A new BankAccount object is created successfully.
• account.withdraw(500): This line executes without an error, and the balance is updated.
• account.withdraw(600):
  • The withdraw method detects that 600 is greater than the current balance (500).
  • It raises an InsufficientFundsError with contextual information.
  • The execution of the try block immediately stops.
• except InsufficientFundsError as e:: The raised InsufficientFundsError is caught by this specific except block. The exception object is assigned to the variable e.
  • The message printed includes the custom message created in the exception’s __init__ method: “Transaction failed: Insufficient funds: 500 available, 600 requested”.
• except InvalidAccountError as e:: This block would catch an InvalidAccountError, for example, if BankAccount("", 1000) was called.
• except ValueError as e:: This block would catch the ValueError, for example, if account.withdraw(0) was called.

Context Managers

classDiagram
    class FileManager {
        - filename : str
        - mode : str
        - file : File
        + __init__(filename: str, mode: str)
        + __enter__() File
        + __exit__(exc_type, exc_val, exc_tb) bool
    }

    class File {
        + write(str) void
        + read() str
        + close() void
    }

    FileManager --> File : manages

sequenceDiagram
    participant U as User
    participant CM as FileManager
    participant F as File

    U->>CM: with FileManager("test.txt", "w")
    CM->>CM: __enter__()
    CM-->>U: file object (F)

    U->>F: write("Hello, World!")
    U->>F: write("This is a test file.")

    U->>CM: Exit 'with' block
    CM->>CM: __exit__(exc_type=None)
    CM->>F: close()

    U->>CM: with FileManager("test.txt", "r")
    CM->>CM: __enter__()
    CM-->>U: file object (F)

    U->>F: read()
    F-->>U: "Hello, World!\nThis is a test file."

    U->>CM: Exit 'with' block
    CM->>CM: __exit__(exc_type=None)
    CM->>F: close()

# Using context managers for resource management
class FileManager:
    """Custom context manager for file operations."""

    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        print(f"Opening file: {self.filename}")
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Closing file: {self.filename}")
        if self.file:
            self.file.close()
        if exc_type:
            print(f"Exception occurred: {exc_val}")
        return False  # Don't suppress exceptions

# Using the context manager
try:
    with FileManager("test.txt", "w") as file:
        file.write("Hello, World!")
        file.write("\nThis is a test file.")
        # File will be automatically closed even if an exception occurs

    with FileManager("test.txt", "r") as file:
        content = file.read()
        print(f"File content:\n{content}")

except FileNotFoundError:
    print("File not found!")
except PermissionError:
    print("Permission denied!")

# Using context managers for resource management
class FileManager:
    """Custom context manager for file operations."""

    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        print(f"Opening file: {self.filename}")
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Closing file: {self.filename}")
        if self.file:
            self.file.close()
        if exc_type:
            print(f"Exception occurred: {exc_val}")
        return False  # Don't suppress exceptions

# Using the context manager
try:
    with FileManager("test.txt", "w") as file:
        file.write("Hello, World!")
        file.write("\nThis is a test file.")
        # File will be automatically closed even if an exception occurs

    with FileManager("test.txt", "r") as file:
        content = file.read()
        print(f"File content:\n{content}")

except FileNotFoundError:
    print("File not found!")
except PermissionError:
    print("Permission denied!")

This code defines a custom context manager called FileManager, which ensures that files are properly opened and, most importantly, closed, even if errors occur during file operations. This prevents resource leaks and results in cleaner, more robust code. 

FileManager class

To function as a context manager, a class must implement the __enter__() and __exit__() special methods. 

• __init__(self, filename, mode): The constructor initializes the FileManager instance with the filename and mode (e.g., 'w' for write, 'r' for read) for the file. It also sets self.file to None initially.
• __enter__(self): This method is called when the with statement is entered.
  • It prints a message indicating the file is being opened.
  • It opens the specified file and stores the file object in self.file.
  • It returns the file object, which is then assigned to the variable after the as keyword in the with statement (file in this case).
• __exit__(self, exc_type, exc_val, exc_tb): This method is called when the with block is exited, whether it completes successfully or an exception occurs.
  • It prints a message indicating the file is being closed.
  • Resource Cleanup: It checks if self.file exists and, if so, calls its close() method, ensuring the file is always closed.
  • Exception Handling: The parameters exc_type, exc_val, and exc_tb contain information about any exception that was raised in the with block.
    • If an exception occurred (exc_type is not None), it prints a message about the exception.
  • Exception Suppression: Returning False (the default return value if a function has no return statement) from __exit__ causes any exception that occurred inside the with block to be re-raised. Returning a True value would suppress the exception. 

Using the context manager

• with FileManager("test.txt", "w") as file:: This with statement creates an instance of FileManager and calls its __enter__ method. The returned file object is assigned to the file variable. The code within the indented block is then executed.
• file.write(...): The file object is used to write data.
• Exiting the block: After the writing is complete, the __exit__ method is automatically called. It closes the file, ensuring the changes are saved and the resource is released.
• Second with statement: A new instance of FileManager is created to read from the file.
• try...except block: Wrapping the with statements in a try...except block is a good practice for handling errors like FileNotFoundError or PermissionError that might occur during the initial open() call.

File Operations

File Handling Flow

flowchart TD
    A[File Operations] --> B[Open File]
    B --> C{File Opened?}
    C -->|Yes| D[Perform Operations]
    C -->|No| E[Handle Error]
    D --> F[Read/Write/Append]
    F --> G[Close File]
    G --> H[End]
    E --> H

    I[File Modes] --> J[r - Read]
    I --> K[w - Write]
    I --> L[a - Append]
    I --> M[r+ - Read/Write]
    I --> N[x - Exclusive Create]

classDiagram
    class FileOperations {
        +write_to_file(filename, content) void
        +read_from_file(filename) str | None
        +append_to_file(filename, content) void
    }

    class File {
        +write(str) void
        +read() str
        +close() void
    }

    FileOperations --> File : uses

flowchart TD
    A[Start] --> B[Open file in 'w' mode]
    B --> C{Error?}
    C -- No --> D[Write content]
    D --> E[Close file]
    E --> F[Print success message]
    C -- Yes --> G[Catch Exception]
    G --> H[Print error message]
    H --> I[End]
    F --> I[End]

# Basic file operations
def write_to_file(filename, content):
    """Write content to a file."""
    try:
        with open(filename, 'w') as file:
            file.write(content)
        print(f"Successfully wrote to {filename}")
    except Exception as e:
        print(f"Error writing to file: {e}")

def read_from_file(filename):
    """Read content from a file."""
    try:
        with open(filename, 'r') as file:
            content = file.read()
        return content
    except FileNotFoundError:
        print(f"File {filename} not found")
        return None
    except Exception as e:
        print(f"Error reading file: {e}")
        return None

def append_to_file(filename, content):
    """Append content to a file."""
    try:
        with open(filename, 'a') as file:
            file.write(content)
        print(f"Successfully appended to {filename}")
    except Exception as e:
        print(f"Error appending to file: {e}")

# Example usage
sample_text = """Python File Handling
This is a sample text file.
It contains multiple lines.
Each line demonstrates file operations."""

# Write to file
write_to_file("sample.txt", sample_text)

# Read from file
content = read_from_file("sample.txt")
if content:
    print("File content:")
    print(content)

# Append to file
append_to_file("sample.txt", "\nThis line was appended.")

# Read updated content
updated_content = read_from_file("sample.txt")
if updated_content:
    print("\nUpdated file content:")
    print(updated_content)

# Basic file operations
def write_to_file(filename, content):
    """Write content to a file."""
    try:
        with open(filename, 'w') as file:
            file.write(content)
        print(f"Successfully wrote to {filename}")
    except Exception as e:
        print(f"Error writing to file: {e}")

def read_from_file(filename):
    """Read content from a file."""
    try:
        with open(filename, 'r') as file:
            content = file.read()
        return content
    except FileNotFoundError:
        print(f"File {filename} not found")
        return None
    except Exception as e:
        print(f"Error reading file: {e}")
        return None

def append_to_file(filename, content):
    """Append content to a file."""
    try:
        with open(filename, 'a') as file:
            file.write(content)
        print(f"Successfully appended to {filename}")
    except Exception as e:
        print(f"Error appending to file: {e}")

# Example usage
sample_text = """Python File Handling
This is a sample text file.
It contains multiple lines.
Each line demonstrates file operations."""

# Write to file
write_to_file("sample.txt", sample_text)

# Read from file
content = read_from_file("sample.txt")
if content:
    print("File content:")
    print(content)

# Append to file
append_to_file("sample.txt", "\nThis line was appended.")

# Read updated content
updated_content = read_from_file("sample.txt")
if updated_content:
    print("\nUpdated file content:")
    print(updated_content)

File handling functions and the with statement

This code demonstrates the three fundamental file operations: writing, reading, and appending. It also effectively utilizes the with statement and try...except blocks for robust and safe file management. 

• File Modes: The open() function takes a file mode as an argument to specify the intended operation.
  • 'w' (Write): Opens a file for writing. If the file already exists, its contents are erased and replaced with the new data. If the file does not exist, a new one is created.
  • 'r' (Read): Opens a file for reading. If the file does not exist, a FileNotFoundError is raised.
  • 'a' (Append): Opens a file for writing. New content is added to the end of the existing file. If the file does not exist, a new one is created.
• with open(...) as file:: The with statement creates a context manager that ensures files are properly closed automatically, even if errors occur. This eliminates the risk of resource leaks and is the recommended practice for file handling.
• try...except: Wrapping the file operations in a try...except block is a standard practice for anticipating and handling potential exceptions gracefully.
  • except FileNotFoundError: Catches the specific error that occurs when a file is opened in a read mode ('r') and does not exist. 

write_to_file(filename, content)

• This function opens filename in 'w' (write) mode.
• The content from the sample_text variable is written to the file, overwriting any previous content.
• A try...except block is included to catch potential errors during the file-writing process. 

read_from_file(filename)

• This function opens filename in 'r' (read) mode.
• The file.read() method is used to read the entire content of the file into a string.
• A try...except block handles the case where the file might not exist (FileNotFoundError), returning None instead of crashing the program. 

append_to_file(filename, content)

• This function opens filename in 'a' (append) mode.
• The new content string, starting with a newline character \n, is added to the end of the file, preserving the original content.
• A try...except block catches any potential errors during the append operation. 

Example usage

The script demonstrates a full cycle of file operations:

1. Writing: sample.txt is created with the initial text.
2. Reading: The content is read back and printed to the console.
3. Appending: A new line is added to the end of sample.txt.
4. Re-reading: The updated content of sample.txt is read back and printed, showing the original text plus the new, appended line.

Advanced File Operations

flowchart TD
    A[Start] --> B{"Save JSON?"}
    B -- Yes --> C["save_json()"]
    C --> D["students.json created"]
    B -- No --> E{"Save CSV?"}
    E -- Yes --> F["save_csv()"]
    F --> G["students.csv created"]
    E -- No --> H["Skip file ops"]
    D --> I["Move to data/"]
    G --> I
    I --> J["explore_directory()"]
    J --> K[End]

project/
│── main.py
│── data/
│   ├── students.json
│   ├── students.csv

project/
│── main.py
│── data/
│   ├── students.json
│   ├── students.csv

sequenceDiagram
    participant U as User
    participant S as save_json()
    participant F as File (students.json)

    U->>S: save_json(student_data, "students.json")
    S->>F: open("students.json", "w")
    S->>F: json.dump(data, indent=4)
    F-->>S: Success
    S-->>U: "Data saved to students.json"

    U->>S: load_json("students.json")
    S->>F: open("students.json", "r")
    F-->>S: file content
    S->>U: parsed dict

import os
import json
import csv
from pathlib import Path

# Working with different file formats

# JSON files
def save_json(data, filename):
    """Save data to JSON file."""
    try:
        with open(filename, 'w') as file:
            json.dump(data, file, indent=4)
        print(f"Data saved to {filename}")
    except Exception as e:
        print(f"Error saving JSON: {e}")

def load_json(filename):
    """Load data from JSON file."""
    try:
        with open(filename, 'r') as file:
            return json.load(file)
    except FileNotFoundError:
        print(f"JSON file {filename} not found")
        return None
    except json.JSONDecodeError:
        print(f"Invalid JSON in {filename}")
        return None

# CSV files
def save_csv(data, filename, headers):
    """Save data to CSV file."""
    try:
        with open(filename, 'w', newline='') as file:
            writer = csv.writer(file)
            writer.writerow(headers)
            writer.writerows(data)
        print(f"CSV data saved to {filename}")
    except Exception as e:
        print(f"Error saving CSV: {e}")

def load_csv(filename):
    """Load data from CSV file."""
    try:
        with open(filename, 'r') as file:
            reader = csv.reader(file)
            data = list(reader)
        return data
    except FileNotFoundError:
        print(f"CSV file {filename} not found")
        return None
    except Exception as e:
        print(f"Error loading CSV: {e}")
        return None

# Example data
student_data = {
    "students": [
        {"name": "Alice", "age": 20, "grade": 85},
        {"name": "Bob", "age": 22, "grade": 90},
        {"name": "Carol", "age": 19, "grade": 78}
    ],
    "course": "Python Programming",
    "semester": "Fall 2024"
}

# Save to JSON
save_json(student_data, "students.json")

# Load from JSON
loaded_data = load_json("students.json")
if loaded_data:
    print("Loaded JSON data:")
    print(f"Course: {loaded_data['course']}")
    for student in loaded_data['students']:
        print(f"  {student['name']}: {student['grade']}")

# Save to CSV
csv_data = [[s['name'], s['age'], s['grade']] for s in student_data['students']]
csv_headers = ['Name', 'Age', 'Grade']
save_csv(csv_data, "students.csv", csv_headers)

# Load from CSV
loaded_csv = load_csv("students.csv")
if loaded_csv:
    print("\nLoaded CSV data:")
    for row in loaded_csv:
        print(row)

# File and directory operations using pathlib
def explore_directory(path):
    """Explore directory contents."""
    directory = Path(path)

    if not directory.exists():
        print(f"Directory {path} does not exist")
        return

    print(f"Contents of {path}:")
    for item in directory.iterdir():
        if item.is_file():
            size = item.stat().st_size
            print(f"  📄 {item.name} ({size} bytes)")
        elif item.is_dir():
            print(f"  📁 {item.name}/")

# Create directory if it doesn't exist
data_dir = Path("data")
data_dir.mkdir(exist_ok=True)

# Move files to the data directory
if Path("students.json").exists():
    Path("students.json").rename(data_dir / "students.json")
if Path("students.csv").exists():
    Path("students.csv").rename(data_dir / "students.csv")

explore_directory("data")

import os
import json
import csv
from pathlib import Path

# Working with different file formats

# JSON files
def save_json(data, filename):
    """Save data to JSON file."""
    try:
        with open(filename, 'w') as file:
            json.dump(data, file, indent=4)
        print(f"Data saved to {filename}")
    except Exception as e:
        print(f"Error saving JSON: {e}")

def load_json(filename):
    """Load data from JSON file."""
    try:
        with open(filename, 'r') as file:
            return json.load(file)
    except FileNotFoundError:
        print(f"JSON file {filename} not found")
        return None
    except json.JSONDecodeError:
        print(f"Invalid JSON in {filename}")
        return None

# CSV files
def save_csv(data, filename, headers):
    """Save data to CSV file."""
    try:
        with open(filename, 'w', newline='') as file:
            writer = csv.writer(file)
            writer.writerow(headers)
            writer.writerows(data)
        print(f"CSV data saved to {filename}")
    except Exception as e:
        print(f"Error saving CSV: {e}")

def load_csv(filename):
    """Load data from CSV file."""
    try:
        with open(filename, 'r') as file:
            reader = csv.reader(file)
            data = list(reader)
        return data
    except FileNotFoundError:
        print(f"CSV file {filename} not found")
        return None
    except Exception as e:
        print(f"Error loading CSV: {e}")
        return None

# Example data
student_data = {
    "students": [
        {"name": "Alice", "age": 20, "grade": 85},
        {"name": "Bob", "age": 22, "grade": 90},
        {"name": "Carol", "age": 19, "grade": 78}
    ],
    "course": "Python Programming",
    "semester": "Fall 2024"
}

# Save to JSON
save_json(student_data, "students.json")

# Load from JSON
loaded_data = load_json("students.json")
if loaded_data:
    print("Loaded JSON data:")
    print(f"Course: {loaded_data['course']}")
    for student in loaded_data['students']:
        print(f"  {student['name']}: {student['grade']}")

# Save to CSV
csv_data = [[s['name'], s['age'], s['grade']] for s in student_data['students']]
csv_headers = ['Name', 'Age', 'Grade']
save_csv(csv_data, "students.csv", csv_headers)

# Load from CSV
loaded_csv = load_csv("students.csv")
if loaded_csv:
    print("\nLoaded CSV data:")
    for row in loaded_csv:
        print(row)

# File and directory operations using pathlib
def explore_directory(path):
    """Explore directory contents."""
    directory = Path(path)

    if not directory.exists():
        print(f"Directory {path} does not exist")
        return

    print(f"Contents of {path}:")
    for item in directory.iterdir():
        if item.is_file():
            size = item.stat().st_size
            print(f"  📄 {item.name} ({size} bytes)")
        elif item.is_dir():
            print(f"  📁 {item.name}/")

# Create directory if it doesn't exist
data_dir = Path("data")
data_dir.mkdir(exist_ok=True)

# Move files to the data directory
if Path("students.json").exists():
    Path("students.json").rename(data_dir / "students.json")
if Path("students.csv").exists():
    Path("students.csv").rename(data_dir / "students.csv")

explore_directory("data")