# This is a basic Python script
name = input("Enter your name: ")
age = 30
print(f"Hello, {name}! You are {age} years old.")
print("Python is fun!")

# A simple script to calculate the area of a rectangle
# This simulates a small utility application

print("--- Rectangle Area Calculator ---")
length_str = input("Enter the length: ")
width_str = input("Enter the width: ")

try:
    length = float(length_str)
    width = float(width_str)
    if length <= 0 or width <= 0:
        print("Length and width must be positive values.")
    else:
        area = length * width
        print(f"The area of the rectangle is: {area:.2f}")
except ValueError:
    print("Invalid input. Please enter numeric values.")

# Using Python's built-in 'math' module and f-strings for advanced output
import math

def calculate_circle_properties(radius):
    """Calculates circumference and area of a circle."""
    if radius <= 0:
        raise ValueError("Radius must be positive.")
    circumference = 2 * math.pi * radius
    area = math.pi * (radius ** 2)
    return circumference, area

try:
    user_radius_str = input("Enter the radius of the circle: ")
    user_radius = float(user_radius_str)
    
    circ, ar = calculate_circle_properties(user_radius)
    print(f"For a circle with radius {user_radius:.2f}:")
    print(f"  Circumference: {circ:.4f}")
    print(f"  Area: {ar:.4f}")
except ValueError as e:
    print(f"Error: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

How Python Works

Python is an interpreted, high-level, general-purpose programming language. Understanding how it works under the hood is crucial for writing efficient and robust code. When you write a Python program, you're essentially creating a text file containing Python statements. Unlike compiled languages like C++ or Java, Python doesn't directly convert your source code into machine-executable binary code before runtime. Instead, it uses an interpreter.

The Python interpreter is a program that reads your Python code line by line and executes it. This process involves several steps: lexical analysis, parsing, compilation to bytecode, and execution by the Python Virtual Machine (PVM). Python's design philosophy emphasizes code readability with its use of significant indentation. It supports multiple programming paradigms, including object-oriented, imperative, and functional programming. Its extensive standard library and vast ecosystem of third-party modules make it suitable for a wide range of applications, from web development and data science to artificial intelligence and scientific computing. Developers choose Python for its rapid development capabilities, clear syntax, and strong community support.

Step-by-Step Explanation

When you run a Python script (e.g., `python your_script.py`), the following sequence of events typically occurs:

1. Source Code (.py file)

Your Python program starts as a plain text file ending with the .py extension. This file contains human-readable Python code.

2. Lexical Analysis (Scanning)

The interpreter's first step is to break down the source code into a stream of tokens. Tokens are the smallest meaningful units in the language, such as keywords (if, for), identifiers (variable names), operators (+, =), and literals (numbers, strings). This phase ignores whitespace and comments.

3. Parsing

The parser takes the stream of tokens and organizes them into a hierarchical structure called an Abstract Syntax Tree (AST). The AST represents the syntactic structure of the program, ensuring that the code follows Python's grammar rules. If there are syntax errors, the parser will detect them here.

4. Compilation to Bytecode

The AST is then compiled into Python bytecode. Bytecode is a low-level, platform-independent representation of your source code. It's not machine code, but rather a set of instructions for the Python Virtual Machine (PVM). This bytecode is often saved in .pyc files (Python compiled files) alongside your .py files for faster loading on subsequent runs. If the source file hasn't changed, Python can skip the lexical analysis and parsing steps and directly load the .pyc file.

5. Execution by the Python Virtual Machine (PVM)

The PVM is the runtime engine of Python. It takes the bytecode instructions and executes them. The PVM is essentially a loop that iterates through the bytecode instructions, performing the operations specified by each instruction. This includes managing memory, handling objects, and interacting with the operating system. It's important to note that while Python is interpreted, the compilation to bytecode step is a form of compilation, making it a 'compiled-interpreted' language. The PVM itself is typically implemented in C (for CPython, the most common interpreter), which is a compiled language, allowing for efficient execution of the bytecode.

Comprehensive Code Examples

Basic Example: A Simple Python Script

This illustrates the most basic interaction with the Python interpreter.

# my_first_script.py
print("Hello, Python World!")
x = 10
y = 20
result = x + y
print(f"The sum of {x} and {y} is {result}")

To run this:
python my_first_script.py
Output:
Hello, Python World!
The sum of 10 and 20 is 30

When you execute this, Python performs the steps described: reads the .py file, converts it to bytecode, and the PVM executes the bytecode instructions to print the messages.

Real-world Example: Module Import and Execution

This shows how Python handles importing external modules, which are essentially other Python scripts.

# utils.py
def greet(name):
    return f"Greetings, {name}!"

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

# main_app.py
import utils

user_name = "Alice"
message = utils.greet(user_name)
print(message)

num1 = 5
num2 = 7
sum_val = utils.add(num1, num2)
print(f"The sum is: {sum_val}")

When main_app.py runs, Python first processes main_app.py. When it encounters import utils, it locates utils.py, processes it (compiles to bytecode if not already), and makes its definitions available to main_app.py. The PVM then executes the calls to utils.greet and utils.add.

Advanced Usage: Inspecting Bytecode

Python's dis module allows you to disassemble Python bytecode, providing a deeper insight into how your code is executed.

import dis

def my_function(a, b):
    c = a + b
    return c * 2

dis.dis(my_function)

Output will be a detailed list of bytecode instructions, for example (simplified):
2 0 LOAD_FAST 0 (a)
2 LOAD_FAST 1 (b)
4 BINARY_ADD
6 STORE_FAST 2 (c)
3 8 LOAD_FAST 2 (c)
10 LOAD_CONST 1 (2)
12 BINARY_MULTIPLY
14 RETURN_VALUE
This output shows the PVM instructions generated for the function, like loading variables, performing arithmetic operations, and returning a value.

Common Mistakes

• Misunderstanding .pyc files: Many beginners manually delete .pyc files, thinking they are temporary junk. While they can be regenerated, they serve to speed up module loading. Deleting them doesn't harm your code but might slightly slow down subsequent runs of the same modules. Fix: Understand that .pyc files are a caching mechanism for bytecode.


• Assuming direct machine code compilation: Expecting Python to behave like C++ or Java where code is fully compiled to an executable before runtime. This leads to confusion about execution speed or deployment. Fix: Remember Python is interpreted (via PVM and bytecode), which offers flexibility but often comes with a performance trade-off compared to truly compiled languages.


• Ignoring the Global Interpreter Lock (GIL): For CPython (the most common interpreter), the GIL ensures that only one thread can execute Python bytecode at a time, even on multi-core processors. This is a common point of confusion for concurrency. Fix: For CPU-bound tasks, use multiprocessing (separate processes) instead of multithreading to leverage multiple cores effectively. For I/O-bound tasks, multithreading or asynchronous programming (asyncio) can still provide benefits.

Best Practices

• Use Virtual Environments: Always use tools like venv or conda to create isolated environments for your projects. This prevents dependency conflicts and keeps your project's dependencies separate from your system's Python installation.


• Understand Module Resolution: Be aware of how Python finds modules (sys.path). This helps in organizing your project structure and debugging import errors. Avoid naming your files the same as standard library modules.


• Write Readable Code: Python's design emphasizes readability. Stick to PEP 8 style guidelines for consistent formatting, naming conventions, and code structure. This makes your code easier to understand for yourself and others, which is crucial given Python's interpreted nature.


• Profile Your Code: If performance is critical, don't guess where bottlenecks are. Use Python's built-in profile or cProfile modules to identify the parts of your code that consume the most time.

Practice Exercises

• Exercise 1 (Beginner): Create a Python script named my_info.py that defines two variables, name and age, and then prints a sentence combining these variables. Run the script from your terminal.


• Exercise 2: Write a simple function in a file called calculations.py that takes two numbers and returns their product. In a separate file, main.py, import this function and use it to multiply two numbers, printing the result.


• Exercise 3: Using the dis module, inspect the bytecode of a simple for loop and a while loop. Observe the differences in the generated instructions.

Mini Project / Task

Create a small Python program that simulates a simple command-line calculator. The program should prompt the user for two numbers and an operation (+, -, *, /), then perform the calculation and print the result. Organize your code into at least two files: one for the core calculation logic (e.g., calculator_logic.py) and another for handling user input and output (e.g., app.py). This will reinforce understanding of module imports and basic program flow.

Challenge (Optional)

Research and explain in your own words the concept of the Global Interpreter Lock (GIL) in CPython. Discuss why it exists, its implications for multi-threaded Python programs, and common strategies to work around its limitations for CPU-bound tasks. Provide a small code example that demonstrates how the GIL can impact performance in a multi-threaded scenario versus a multi-process scenario.

Installing Python

Python is a widely-used, high-level programming language known for its simplicity and readability, making it an excellent choice for beginners and experienced developers alike. It was created by Guido van Rossum and first released in 1991. Python is used extensively in web development (Django, Flask), data science and machine learning (NumPy, Pandas, TensorFlow), artificial intelligence, automation, scripting, scientific computing, and even game development. Its vast ecosystem of libraries and frameworks allows developers to tackle almost any programming task efficiently. Installing Python is the first step towards leveraging its power for various applications, from simple scripts to complex enterprise systems.

Python offers several installation methods, primarily through its official installer or package managers. For most users, downloading the official installer from python.org is the most straightforward approach. Alternatively, advanced users or those on specific operating systems might prefer package managers like Homebrew for macOS or apt for Debian/Ubuntu-based Linux distributions, as they can simplify managing Python versions and dependencies. Virtual environments are also a critical concept, allowing you to create isolated environments for different projects, preventing conflicts between package versions.

Step-by-Step Explanation

To get started with Python, you'll need to install it on your operating system. This guide covers the installation process for Windows, macOS, and Linux.

1. Download the Installer:
- Open your web browser and navigate to the official Python website: https://www.python.org/downloads/
- The website usually detects your operating system and suggests the latest stable version of Python. Click on the 'Download Python X.Y.Z' button (where X.Y.Z is the version number, e.g., 3.10.0).

2. Installation on Windows:
- Once the installer (an .exe file) is downloaded, double-click it to run.
- Crucially, check the box that says 'Add Python X.Y to PATH' during installation. This step ensures that you can run Python from the command prompt/PowerShell.
- Select 'Install Now' for a typical installation, or 'Customize installation' if you need specific options (though 'Install Now' is usually sufficient for beginners).
- Follow the on-screen prompts. Once the installation completes, you will see a 'Setup was successful' message.

3. Installation on macOS:
- Download the macOS installer (.pkg file) from the Python website.
- Double-click the .pkg file to start the installer.
- Follow the instructions, clicking 'Continue' and 'Agree' as prompted. You might be asked for your administrator password.
- Python is often pre-installed on macOS, but it's usually an older version (Python 2.x). Installing from python.org gives you the latest Python 3.x, which is recommended.

4. Installation on Linux:
- Python 3 is typically pre-installed on most modern Linux distributions. You can check by opening a terminal and typing: python3 --version
- If it's not installed or you want a newer version, you can install it using your distribution's package manager.
- For Debian/Ubuntu-based systems:

sudo apt update
sudo apt install python3
sudo apt install python3-pip # Install pip for package management

- For Fedora/CentOS-based systems:

sudo dnf update
sudo dnf install python3
sudo dnf install python3-pip

5. Verify Installation:
- After installation, open your command prompt (Windows), Terminal (macOS), or a new terminal (Linux).
- Type the following command and press Enter:

python --version

- Or, specifically for Python 3:

python3 --version

- You should see the installed Python version printed, confirming a successful installation.

Comprehensive Code Examples

Basic example (Verifying Python Installation):
This isn't 'code' in the traditional sense, but rather commands to confirm your setup.

# Command Prompt / Terminal
python --version
python3 --version
pip --version
pip3 --version
# Expected output will show the installed versions, e.g., Python 3.10.0, pip 21.2.4

Real-world example (Running a simple Python script):
Create a file named hello.py with the following content. This demonstrates that Python is correctly configured to execute scripts.

# hello.py
print("Hello, Python World!")
print("Python is now installed and ready.")

To run this script, open your terminal/command prompt, navigate to the directory where you saved hello.py, and type:

python hello.py

You should see the output: "Hello, Python World!" and "Python is now installed and ready."

Advanced usage (Using a virtual environment):
Virtual environments are crucial for managing dependencies for different projects.

# 1. Create a new project directory
mkdir my_project
cd my_project

# 2. Create a virtual environment (named 'venv' by convention)
python3 -m venv venv

# 3. Activate the virtual environment
# On Windows:
# .\venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate

# 4. Install a package inside the virtual environment
(venv) pip install requests

# 5. Deactivate the virtual environment when done
(venv) deactivate

After activating, your terminal prompt will typically show (venv) indicating you are in the virtual environment. Any packages installed here will only affect this specific environment.

Common Mistakes

• Not adding Python to PATH (Windows): This is the most common mistake. If you don't check 'Add Python X.Y to PATH' during installation, you won't be able to run python or pip commands directly from the command prompt.
  Fix: Re-run the installer and ensure the PATH option is checked, or manually add Python to your system's PATH environment variables.


• Using 'python' instead of 'python3' on Linux/macOS: On many Unix-like systems, python might refer to an older Python 2 installation.
  Fix: Always use python3 and pip3 to explicitly invoke Python 3 and its package manager.


• Installing packages globally without virtual environments: Installing packages directly with pip install package_name outside a virtual environment can lead to dependency conflicts between different projects.
  Fix: Always create and activate a virtual environment for each project before installing packages. This isolates dependencies.

Best Practices

• Always use the latest stable Python 3 version: Python 2 is deprecated. Stick to Python 3.x for all new development.


• Use virtual environments for every project: This is non-negotiable. It keeps your project dependencies clean and isolated, avoiding 'dependency hell'.


• Keep Python and pip updated: Regularly update your Python installation and pip to benefit from bug fixes and new features. python3 -m pip install --upgrade pip


• Understand your OS's package manager: On Linux, using apt, dnf, pacman, etc., to install Python might be more integrated with your system.

Practice Exercises

• Verify your Python installation by running python3 --version in your terminal. If it fails, troubleshoot the PATH environment variable or re-install.


• Create a new directory named my_first_script. Inside it, create a file greet.py that prints your name. Run this script from your terminal.


• Create a virtual environment named my_env within a new project directory. Activate it, then deactivate it. Observe how your terminal prompt changes.

Mini Project / Task

Create a project directory for a simple 'To-Do List' application. Initialize a virtual environment within this directory. Write a Python script named todo.py that simply prints the message "Welcome to your To-Do List!". Make sure you can activate the virtual environment and run todo.py successfully from within it.

Challenge (Optional)

After successfully setting up your 'To-Do List' project with a virtual environment, try to install a simple third-party package like colorama (for colored terminal output) into your virtual environment. Then, modify your todo.py script to use colorama to print "Welcome to your To-Do List!" in a different color. Ensure this package is only available when your virtual environment is active.

Running Python Scripts

Running a Python script means asking the Python interpreter to read and execute instructions stored in a .py file. This is one of the most important beginner skills because writing code is only half the job; you also need to know how to launch, test, and repeat it reliably. In real life, Python scripts are used to automate file organization, process data, call web APIs, run backend tasks, execute tests, and schedule maintenance jobs. You can run Python scripts in several ways, including from a terminal, through an IDE like VS Code or PyCharm, or by double-clicking a file in some operating systems. The most common approach is command-line execution because it works across platforms and gives you control over arguments, paths, and environments.

At a basic level, a script is a text file containing Python code. When you run python file_name.py, the interpreter loads the file and executes it from top to bottom. Depending on your system, the command may be python or python3. You should also understand the difference between interactive mode and script mode. Interactive mode lets you type commands one by one in the Python shell, while script mode executes saved code from a file. Script execution may also involve command-line arguments, the current working directory, executable permissions on Unix-like systems, and the special __name__ == '__main__' check, which helps control what runs when a file is executed directly.

Step-by-Step Explanation

First, create a file with the .py extension, such as hello.py. Add Python code inside it. Second, open your terminal or command prompt and navigate to the folder containing the file using cd. Third, run the script with python hello.py or python3 hello.py. If Python is installed correctly, the interpreter will execute the file and print the output. If your script needs inputs from the command line, you can pass extra values after the filename. Inside Python, these values can be read with the sys.argv list. On macOS and Linux, you may also make a script directly executable with a shebang like #!/usr/bin/env python3 and permission changes using chmod +x.

If you are using an IDE, the editor usually provides a Run button. Under the hood, it still launches the Python interpreter for your script. Beginners should always confirm which Python version the IDE is using, especially if multiple versions are installed.

Comprehensive Code Examples

print("Hello from a Python script!")

# save as greet.py
name = input("Enter your name: ")
print(f"Welcome, {name}!")

# save as app.py
import sys

def main():
    if len(sys.argv) < 2:
        print("Usage: python app.py ")
        return
    filename = sys.argv[1]
    print(f"Processing file: {filename}")

if __name__ == "__main__":
    main()

The first example shows the simplest runnable script. The second is a real-world interactive script that collects user input. The third demonstrates a more professional structure using a main() function and command-line arguments.

Common Mistakes

• Using the wrong command: Some systems require python3 instead of python. Fix this by checking your installed version with python --version or python3 --version.
• Running from the wrong folder: If the terminal is not in the script directory, Python may say the file cannot be found. Fix it by using cd to move to the correct folder.
• Saving without the .py extension: A plain text file will not behave like a Python script. Fix it by renaming the file correctly, such as program.py.
• Forgetting imports: If you use modules like sys without importing them, errors will occur. Add the required import statement at the top.

Best Practices

• Use clear file names like backup_report.py instead of vague names like test.py.
• Place executable code inside a main() function for cleaner organization.
• Use if __name__ == "__main__": to prevent code from running unintentionally when imported.
• Test scripts from the terminal even if you use an IDE, because this builds practical workflow skills.
• Keep your Python version consistent across tools and environments.

Practice Exercises

• Create a script named message.py that prints a custom message when run.
• Write a script that asks the user for their favorite color and prints a sentence using that value.
• Create a script that accepts one command-line argument and prints it back to the screen.

Mini Project / Task

Build a script called file_greeter.py that accepts a user name as a command-line argument and prints a personalized greeting along with the script name.

Challenge (Optional)

Create a script that accepts multiple command-line arguments and prints how many arguments were passed, followed by each value on a separate line.

Python Syntax

Python syntax is the set of rules that defines how Python programs are written and understood by the interpreter. It exists to make code readable, consistent, and easy to maintain. Unlike many other languages that rely heavily on braces and semicolons, Python uses indentation and clear keywords to express structure. This makes it popular in education, automation, backend systems, data science, and scripting tasks. In real life, Python syntax is used when writing small automation scripts, building web APIs, processing files, and creating machine learning pipelines. The most important ideas in Python syntax include statements, indentation, comments, variables, expressions, function calls, and blocks of code. Python is case-sensitive, so name and Name are different. Statements usually appear one per line, though short statements can sometimes be combined. Indentation is especially important because it defines code blocks inside functions, loops, and conditionals. Comments begin with # and are ignored by Python, helping developers explain logic. Python also supports single and double quotes for strings, simple assignment with =, and expression evaluation using operators like +, -, and *.

Step-by-Step Explanation

Start a Python statement on its own line. To store data, assign a value to a variable using =. To display output, use the print() function. When creating blocks after statements like if, for, while, or def, end the line with a colon, then indent the next lines consistently, usually with 4 spaces. Use comments to document what the code does. Strings must be wrapped in quotes, and parentheses are used for function calls. Good syntax also means writing code that is visually clean and logically grouped. Python emphasizes readability, so avoid unnecessary symbols and keep naming meaningful.

Comprehensive Code Examples

# Basic example
message = "Hello, Python"
print(message)

# Real-world example
user_name = "Asha"
age = 22

if age >= 18:
    print(user_name + " can register for the event.")

# Advanced usage
def format_invoice(customer, amount):
    tax = amount * 0.18
    total = amount + tax
    print("Customer:", customer)
    print("Amount:", amount)
    print("Tax:", tax)
    print("Total:", total)

format_invoice("Ravi", 2500)

Common Mistakes

• Wrong indentation: Mixing tabs and spaces or forgetting indentation after a colon causes errors. Use 4 spaces consistently.
• Missing quotes around text: Writing plain text without quotes makes Python treat it like a variable. Wrap strings in single or double quotes.
• Case mistakes: Print() is not the same as print(). Python keywords and functions must use correct casing.
• Forgetting the colon: Statements like if and def need a colon at the end of the line.

Best Practices

• Use meaningful variable names such as student_name instead of x.
• Follow consistent indentation with 4 spaces per block.
• Keep one statement per line unless there is a strong readability reason not to.
• Add comments only when they clarify intent, not when they repeat obvious code.
• Write simple, readable syntax before trying shortcuts.

Practice Exercises

• Create a variable called city, store your city name in it, and print the value.
• Write an if statement that checks whether a number is greater than 10 and prints a message.
• Define a function named greet that prints a welcome message when called.

Mini Project / Task

Build a small student introduction script that stores a student name, course name, and age in variables, then prints a formatted summary using correct Python syntax and indentation.

Challenge (Optional)

Write a function that accepts a product name and price, calculates a 10 percent discount, and prints a neatly formatted final bill using correct Python syntax rules.

Comments and Documentation

Comments and documentation help developers explain what code does, why it exists, and how it should be used. In real projects, code is rarely written once and forgotten; it is updated, reviewed, debugged, and shared with others. That is why readable explanations are just as important as correct syntax. In Python, comments are usually written with the # symbol, while documentation often appears as docstrings using triple quotes inside modules, functions, classes, and methods. Comments are useful for quick notes, warnings, and clarifications. Docstrings are more structured and are commonly used by IDEs, documentation tools, and team members who need to understand how a piece of code should behave.

In real life, comments and documentation are used everywhere: explaining business rules in finance software, documenting API behavior in web applications, describing data-cleaning logic in analytics scripts, and guiding other engineers in shared codebases. Python encourages readability, so good comments and documentation support that philosophy. The key idea is simple: explain intent, not obvious syntax. For example, a comment like “increase x by 1” is usually unnecessary, but explaining that “retry count increases after a failed API request” adds valuable context.

Python supports several documentation styles. Single-line comments begin with #. Inline comments can appear after code, though they should be used sparingly. Multi-line explanations are often written as multiple comment lines, each starting with #. Docstrings are string literals placed as the first statement inside a module, function, class, or method. They are typically written with triple double quotes and can describe purpose, parameters, return values, and usage. Module docstrings describe an entire file, function docstrings explain behavior, and class docstrings describe object responsibility.

Step-by-Step Explanation

To write a single-line comment, place # before your text. Python ignores everything after that symbol on the same line. Use this for short explanations. For multi-line notes, write multiple lines beginning with # instead of using a special block comment syntax, because Python does not have one. For documentation, place triple quotes directly under a function or class definition. That first string becomes the docstring and can be accessed with tools or with help() and .__doc__.

A strong docstring usually states what the code does, describes inputs, mentions outputs, and optionally notes errors or side effects. Keep wording clear and direct. Comments should support understanding, not overwhelm the file with noise.

Comprehensive Code Examples

# Basic comment example
name = "Ava"  # Store the user's name
print(name)

def calculate_total(price, tax_rate):
    """Return the total price after applying tax.

    Args:
        price: Original item price.
        tax_rate: Tax percentage as a decimal.

    Returns:
        Final price including tax.
    """
    return price + (price * tax_rate)

print(calculate_total(100, 0.15))

"""Utility tools for processing log files.
This module contains helpers for filtering and summarizing logs.
"""

class LogAnalyzer:
    """Analyze application log entries.

    This class stores log messages and provides summary methods.
    """

    def __init__(self, entries):
        """Create a new analyzer with a list of log entries."""
        self.entries = entries

    def count_errors(self):
        """Return the number of log entries containing ERROR."""
        return sum(1 for entry in self.entries if "ERROR" in entry)

Common Mistakes

• Writing obvious comments: Avoid comments like “set x to 5.” Explain why the value matters instead.
• Using outdated comments: If code changes, update the comment immediately so it stays accurate.
• Forgetting docstrings in reusable code: Add docstrings to functions, classes, and modules others will use.
• Using triple-quoted strings as random comments: Prefer real comments unless the string is a proper docstring.

Best Practices

• Write comments that explain intent, assumptions, or business rules.
• Use docstrings for public functions, classes, and modules.
• Keep comments short, specific, and updated.
• Follow a consistent docstring style across the project.
• Let clean variable names reduce the need for excessive comments.

Practice Exercises

• Write a small Python script with at least five lines of code and add useful single-line comments explaining the important parts.
• Create a function that converts Celsius to Fahrenheit and add a docstring describing its parameter and return value.
• Write a class called Book and add docstrings for the class and its initializer method.

Mini Project / Task

Build a simple expense calculator script and document it properly. Add a module docstring, comments for important business rules, and docstrings for each function used to total and categorize expenses.

Challenge (Optional)

Take an older Python script you have written, remove unnecessary comments, improve variable names, and add professional docstrings to every reusable function and class.

Variables and Data Types

Variables are names that store data so a program can reuse and manipulate it later. Instead of repeating values directly in code, you assign them to variables such as name, age, or price. Data types describe what kind of value a variable holds, such as text, numbers, or true/false values. Python uses variables and data types in almost every real-life application: storing user names in a login system, tracking quantities in inventory software, calculating totals in billing apps, and recording measurements in scientific tools.

Python is dynamically typed, which means you do not need to declare a variable type before assigning a value. The interpreter figures it out automatically. Common built-in data types include int for whole numbers, float for decimal numbers, str for text, bool for True and False, and NoneType for the special value None. Python also has collection types such as list, tuple, set, and dict, which group multiple values together. Choosing the correct type matters because it affects memory usage, operations, and program logic.

Step-by-Step Explanation

To create a variable, write a name, the assignment operator =, and a value. Example: age = 25. Python stores the value and links it to the variable name.

Variable naming rules are simple: names can contain letters, numbers, and underscores, but cannot start with a number. They are case-sensitive, so userName and username are different variables. Use meaningful names like total_price instead of vague names like x.

You can check a value's type with type(). For example, type(age) returns int. Strings are written inside quotes, numbers are written without quotes, and booleans use capitalized True or False. Python also supports type conversion, such as int("5") or str(100), when you need to change one type into another safely.

Comprehensive Code Examples

Basic example

name = "Ava"
age = 21
height = 5.6
is_student = True

print(name)
print(type(age))
print(type(height))
print(type(is_student))

Real-world example

product_name = "Wireless Mouse"
price = 24.99
quantity = 3
in_stock = True

total_cost = price * quantity

print("Product:", product_name)
print("Total:", total_cost)
print("Available:", in_stock)

Advanced usage

user_input = "42"
converted_number = int(user_input)
tax_rate = 0.08
final_amount = converted_number + (converted_number * tax_rate)
status = final_amount > 45

print("Converted:", converted_number)
print("Final amount:", final_amount)
print("Is over limit:", status)

Common Mistakes

• Putting numbers in quotes by accident: age = "25" creates a string, not an integer. Fix it by using age = 25 or converting with int(age).
• Using invalid variable names: 2name = "Sam" is invalid because names cannot start with a number. Use name2 instead.
• Mixing incompatible types: "Age: " + 20 causes an error. Convert the number first with str(20).
• Confusing = with comparison: = assigns a value; it does not compare values. Use == for comparison.

Best Practices

• Use descriptive variable names such as customer_name and account_balance.
• Follow Python naming style with lowercase letters and underscores.
• Keep data types consistent so calculations and conditions work correctly.
• Use type() during learning and debugging to inspect stored values.
• Convert user input carefully because input is usually received as text.

Practice Exercises

• Create variables for your name, age, and favorite number, then print each one and its type.
• Store the price and quantity of an item in variables, then calculate and print the total cost.
• Create a variable with the string value "100", convert it to an integer, add 50, and print the result.

Mini Project / Task

Build a simple student profile script that stores a student's name, grade level, GPA, and enrollment status in variables, then prints a formatted summary.

Challenge (Optional)

Create a small billing script that stores an item price as a string, converts it to a numeric type, applies a tax rate, and prints whether the final amount is greater than a chosen budget limit.

Numbers and Type Conversion

Python, like most programming languages, uses numbers to represent numerical values. Understanding how to work with different types of numbers and how to convert between them is fundamental for any programmer. This knowledge is crucial for performing calculations, handling user input, and interacting with various data sources. In real-life applications, numbers are everywhere: calculating prices in an e-commerce application, tracking sensor data in IoT devices, performing scientific simulations, managing financial transactions, or even simply counting items. Python's flexibility in handling numbers makes it a powerful tool for these diverse applications. Type conversion, also known as type casting, allows you to change the data type of a value. This is often necessary when you receive data in one format (e.g., a string from user input) but need to perform operations that require a different format (e.g., mathematical calculations requiring integers or floats). Without proper type conversion, you'd encounter errors or unexpected behavior in your programs.

Python primarily deals with three numerical types: integers, floating-point numbers, and complex numbers. Integers (int) are whole numbers, positive or negative, without a decimal point (e.g., 5, -100, 0). Python 3 integers have arbitrary precision, meaning they can be as large as your system's memory allows, unlike some other languages with fixed-size integers. Floating-point numbers (float) are real numbers that have a decimal point (e.g., 3.14, -0.5, 2.0). They are used to represent approximations of real numbers. Complex numbers (complex) are numbers with a real and an imaginary part (e.g., 3 + 4j). While less common in general programming, they are essential in scientific and engineering computations. Type conversion involves functions like int(), float(), and str(). The int() function converts a value to an integer, truncating the decimal part if it's a float (e.g., int(3.9) becomes 3). It can also convert a string containing a whole number. The float() function converts a value to a floating-point number. It can take integers or strings representing numbers. The str() function converts any value into its string representation. Other less common conversions include bool() for boolean conversion and complex() for complex numbers.

Step-by-Step Explanation

Let's look at how to work with numbers and perform type conversions.

1. Declaring Numbers:
To declare an integer, simply assign a whole number to a variable:

my_integer = 100
print(type(my_integer)) # Output: 

To declare a float, assign a number with a decimal point:

my_float = 3.14159
print(type(my_float)) # Output: 

2. Basic Arithmetic Operations:
Python supports standard arithmetic: addition (+), subtraction (-), multiplication (*), division (/), floor division (//), modulus (%), and exponentiation (**).

result_add = 5 + 3
result_sub = 10 - 4
result_mul = 7 * 2
result_div = 15 / 4 # Always returns a float
result_floor_div = 15 // 4 # Returns an integer (floor value)
result_mod = 15 % 4 # Remainder
result_exp = 2 ** 3 # 2 to the power of 3

3. Type Conversion using Built-in Functions:

• int(value): Converts to integer. Floats are truncated. Strings must be valid integer representations.
• float(value): Converts to float. Integers become floats (e.g., 5 becomes 5.0). Strings must be valid float or integer representations.
• str(value): Converts to string.

Comprehensive Code Examples

Basic Example - Number Declaration and Simple Operations:

# Integer and Float declaration
age = 30
temperature = 25.5

print(f"My age is: {age}, type: {type(age)}")
print(f"Current temperature: {temperature}, type: {type(temperature)}")

# Basic arithmetic
sum_ages = age + 5 # 35
half_temp = temperature / 2 # 12.75
product = age * temperature # 765.0

print(f"Age after 5 years: {sum_ages}")
print(f"Half temperature: {half_temp}")
print(f"Product of age and temperature: {product}")

Real-world Example - Calculating a Bill with User Input:

# Get item price and quantity from user (input returns string)
item_price_str = input("Enter the price of the item: ")
quantity_str = input("Enter the quantity: ")

# Convert strings to appropriate numerical types
item_price = float(item_price_str)
quantity = int(quantity_str)

# Calculate total and add tax
subtotal = item_price * quantity
tax_rate = 0.08 # 8% tax
tax_amount = subtotal * tax_rate
total_bill = subtotal + tax_amount

# Display results, rounding to 2 decimal places for currency
print(f"Subtotal: ${subtotal:.2f}")
print(f"Tax (8%): ${tax_amount:.2f}")
print(f"Total bill: ${total_bill:.2f}")

Advanced Usage - Type Conversion with Error Handling:

def safe_int_conversion(value):
    try:
        return int(value)
    except ValueError:
        print(f"Warning: Could not convert '{value}' to integer. Returning 0.")
        return 0

def safe_float_conversion(value):
    try:
        return float(value)
    except ValueError:
        print(f"Warning: Could not convert '{value}' to float. Returning 0.0.")
        return 0.0

num1_str = "123"
num2_str = "3.14"
num3_str = "hello"

int_val1 = safe_int_conversion(num1_str) # 123
int_val2 = safe_int_conversion(num2_str) # Warning, returns 0
int_val3 = safe_int_conversion(num3_str) # Warning, returns 0

float_val1 = safe_float_conversion(num1_str) # 123.0
float_val2 = safe_float_conversion(num2_str) # 3.14
float_val3 = safe_float_conversion(num3_str) # Warning, returns 0.0

print(f"Converted integers: {int_val1}, {int_val2}, {int_val3}")
print(f"Converted floats: {float_val1}, {float_val2}, {float_val3}")

Common Mistakes

• Forgetting to Convert User Input: The input() function always returns a string. Many beginners forget to convert this string to an int or float before performing numerical operations, leading to TypeError or unexpected string concatenation.
  Fix: Always explicitly convert user input using int() or float() when numerical operations are intended.
• Incorrect Integer Conversion of Floats: Using int() on a float truncates the decimal part (e.g., int(3.9) becomes 3, not 4). If you need rounding, use round().
  Fix: Understand that int() truncates. If you need standard rounding, use round(number), which rounds to the nearest even integer for .5 values (e.g., round(2.5) is 2, round(3.5) is 4). For always rounding up or down, use `math.ceil()` or `math.floor()`.
• Attempting to Convert Non-Numeric Strings: Trying to convert a string like "hello" or "3.14.1" directly to an int or float will result in a ValueError.
  Fix: Always validate user input or use try-except blocks to gracefully handle potential ValueError exceptions when converting strings to numbers, as shown in the advanced example.

Best Practices

• Be Explicit with Type Conversions: Don't rely on implicit conversions if clarity is needed. Explicitly use int(), float(), or str() to make your code's intent clear.
• Validate User Input: When accepting numerical input from users, always validate that the input is indeed a valid number before attempting conversion. Use try-except blocks to catch ValueError for robust applications.
• Choose the Right Number Type: Use integers for whole numbers (counts, IDs) and floats for numbers that might have decimal places (measurements, prices). Avoid using floats for precise monetary calculations if possible, as floating-point arithmetic can introduce small inaccuracies; consider using the decimal module for high precision.
• Use f-strings for Formatting: When displaying numerical output, especially floats, use f-strings to format them nicely (e.g., f"{value:.2f}" for two decimal places).

Practice Exercises

• Exercise 1: Basic Conversion
  Ask the user to enter their favorite whole number and their favorite decimal number. Convert both inputs to their respective numerical types and then print their sum.
• Exercise 2: Area Calculation
  Prompt the user to enter the length and width of a rectangle. Convert these inputs to floats and calculate the area. Print the area formatted to two decimal places.
• Exercise 3: Temperature Converter
  Ask the user to enter a temperature in Celsius. Convert this input to a float and then convert it to Fahrenheit using the formula: F = (C * 9/5) + 32. Print the result.

Mini Project / Task

Create a simple tip calculator. Ask the user for the total bill amount and the desired tip percentage (e.g., 15 for 15%). Calculate the tip amount and the total bill including tip. Display both amounts, formatted to two decimal places.

Challenge (Optional)

Build a program that calculates the Body Mass Index (BMI). Ask the user for their weight in kilograms and height in meters. Calculate BMI using the formula: BMI = weight / (height * height). After calculating, use conditional statements (if/elif/else - which you may need to briefly research if unfamiliar) to categorize the BMI (e.g., Underweight < 18.5, Normal 18.5-24.9, Overweight 25-29.9, Obese >= 30). Print the BMI and its category.

Strings and String Methods

Strings are fundamental data types in Python, used to represent sequences of characters. They are immutable, meaning once a string is created, it cannot be changed. This immutability is an important characteristic that affects how strings are handled in Python. Strings are incredibly versatile and are used everywhere in programming, from storing user input like names and addresses to manipulating text data, parsing files, and formatting output. In real-life applications, strings are essential for web development (handling URLs, HTML content), data analysis (processing text data, cleaning datasets), natural language processing (text classification, sentiment analysis), and even simple command-line interfaces.

Python treats strings as sequences, which means each character within a string has an order and an index. This allows for powerful operations like indexing, slicing, and iteration. The rich set of built-in string methods further enhances their utility, providing easy ways to modify, search, and format text without needing to write complex custom functions. Understanding strings and their methods is crucial for any Python developer, as it forms the basis for interacting with and manipulating textual information, which is a significant part of most software applications.

Python strings can be defined using single quotes ('hello'), double quotes ("world"), or triple quotes ('''multiline''' or """multiline""") for multiline strings. Each character in a string occupies a specific position, identified by an index, starting from 0 for the first character. Negative indices can be used to access characters from the end of the string, with -1 referring to the last character. Python's string methods are functions that are called on string objects to perform specific operations. These methods do not change the original string (due to immutability) but instead return a new string with the modifications. Common string methods include .lower(), .upper(), .strip(), .replace(), .split(), .join(), .find(), and .startswith(), among many others. These methods allow for a wide range of text manipulation tasks.

Step-by-Step Explanation

1. Creating Strings: Enclose text in single, double, or triple quotes. For example: my_string = "Hello, Python!"
2. Accessing Characters (Indexing): Use square brackets [] with an index. my_string[0] gives 'H'. my_string[-1] gives '!'.
3. Extracting Substrings (Slicing): Use [start:end:step]. my_string[0:5] gives 'Hello'. my_string[7:] gives 'Python!'. my_string[::-1] reverses the string.
4. String Concatenation: Use the + operator to combine strings. 'Hello' + ' ' + 'World' results in 'Hello World'.
5. String Length: Use the len() function. len(my_string) returns the number of characters.
6. Common String Methods:
- .lower() / .upper(): Convert to lowercase/uppercase.
- .strip(): Remove leading/trailing whitespace.
- .replace('old', 'new'): Replace occurrences of a substring.
- .split('delimiter'): Split string into a list of substrings.
- .join(list_of_strings): Concatenate elements of an iterable into a string.
- .find('substring') / .index('substring'): Find the first occurrence of a substring (find returns -1 if not found, index raises an error).
- .startswith('prefix') / .endswith('suffix'): Check if a string starts/ends with a specified substring.
- .count('char'): Count occurrences of a character or substring.
- .isdigit(), .isalpha(), .isalnum(): Check if string contains only digits, alphabets, or alphanumeric characters, respectively.

Comprehensive Code Examples

Basic example:

my_message = "  Hello, Python World!  "
print(f"Original: '{my_message}'")

# Basic methods
print(f"Uppercase: '{my_message.upper()}'")
print(f"Lowercase: '{my_message.lower()}'")
print(f"Stripped: '{my_message.strip()}'")

# Slicing
clean_message = my_message.strip()
print(f"First 5 chars: '{clean_message[0:5]}' ")
print(f"Last char: '{clean_message[-1]}' ")

# Replacement
replaced_message = clean_message.replace("Python", "AI")
print(f"Replaced: '{replaced_message}'")

Real-world example (Parsing User Input):

user_input = "  [email protected]  "

email = user_input.strip().lower()
print(f"Cleaned email: {email}")

if "@" in email and email.endswith(".com"):
    username = email.split('@')[0]
    domain = email.split('@')[1]
    print(f"Username: {username}")
    print(f"Domain: {domain}")
else:
    print("Invalid email format.")

Advanced usage (Text Formatting and Joining):

tags = ["python", "programming", "webdev", "learning"]
formatted_tags = "#" + " #".join(tags)
print(f"Formatted tags: {formatted_tags}")

data_string = "Item1:100|Item2:250|Item3:120"
items = data_string.split('|')
print("Parsed items:")
for item in items:
    name, price = item.split(':')
    print(f"  - {name} costs ${price}")

Common Mistakes

• Mistake 1: Modifying strings directly. Strings are immutable. Methods like .upper() or .replace() return a new string; they don't change the original.
  Fix: Always assign the result of a string method back to a variable. my_string = "hello"; my_string.upper() will not change my_string. You need my_string = my_string.upper().


• Mistake 2: Incorrect indexing/slicing. Forgetting that indices start at 0, or misunderstanding how slice end points work (exclusive).
  Fix: Remember that my_string[start:end] includes characters from start up to (but not including) end. Use negative indices for easier access from the end. Practice with small examples to solidify understanding.


• Mistake 3: Using + for many concatenations in a loop. Repeatedly concatenating strings with + in a loop creates many intermediate string objects, which is inefficient.
  Fix: For combining many strings, use .join(). It's significantly more efficient as it builds the final string in one go. Example: " ".join(word_list) is better than a loop with result += word + " ".

Best Practices

• Use f-strings for formatting: For embedding variables or expressions into strings, f-strings (formatted string literals) are generally the most readable and efficient method in modern Python (3.6+). name = "Alice"; age = 30; print(f"Name: {name}, Age: {age}").


• Be mindful of whitespace: Always consider stripping whitespace from user inputs using .strip() to prevent unexpected behavior or errors in comparisons and processing.


• Choose the right method for the job: Python's extensive string methods cover most use cases. Familiarize yourself with methods like .startswith(), .endswith(), .find(), .count(), .isdigit(), etc., to avoid reinventing the wheel with manual loops or regex when not necessary.


• Use raw strings for regular expressions and file paths: Prefix strings with r (e.g., r"C: ew ext.txt") to treat backslashes as literal characters, avoiding issues with escape sequences, especially useful in regular expressions or Windows file paths.

Practice Exercises

• Exercise 1 (Beginner): Create a string my_sentence = "Python programming is fun". Convert it to all uppercase, then count how many times the letter 'P' (case-insensitive) appears in the original sentence. Print both results.


• Exercise 2: Given the string data = " apple,banana,cherry ", remove any leading/trailing whitespace, then split the string into a list of fruits using the comma as a delimiter. Finally, join the list of fruits back into a single string with a semicolon and a space (e.g., "apple; banana; cherry"). Print the final string.


• Exercise 3: Write a program that takes a user's full name as input (e.g., "Alice Wonderland"). It should then print their initials (e.g., "A.W."). Make sure it handles extra spaces gracefully.

Mini Project / Task

Build a simple text analyzer. Ask the user to input a sentence. Your program should then:
1. Print the total number of characters in the sentence (excluding leading/trailing whitespace).
2. Print the number of words in the sentence.
3. Print the sentence with all occurrences of the word "the" (case-insensitive) replaced with "a".

Challenge (Optional)

Create a function that takes a string as input and determines if it is a palindrome (reads the same forwards and backward, ignoring case and non-alphanumeric characters). For example, "A man, a plan, a canal: Panama" is a palindrome.

Boolean Values

Boolean values are one of the most important ideas in Python because they represent logic: something is either True or False. They exist so programs can make decisions, compare values, and control behavior. In real life, many decisions are boolean in nature: a door is locked or unlocked, a user is logged in or not, an age is above a required limit or not. In Python, booleans are used in conditions, loops, validation rules, filtering, and application logic. The Boolean type in Python is written as bool, and it has only two possible values: True and False.

Booleans are often created in two ways. First, you can assign them directly, such as is_online = True. Second, and more commonly, booleans are produced by comparisons like 5 > 3 or username == "admin". Python also uses boolean logic operators: and, or, and not. These help combine or reverse conditions. For example, a person might be allowed into a system only if they are logged in and have permission.

Another key concept is truthy and falsy values. Although booleans are strictly True and False, Python treats some non-boolean values as false in conditions, such as 0, None, empty strings, empty lists, and empty dictionaries. Most other values are treated as true. This allows concise code, but beginners should still understand when a value is an actual boolean and when it only behaves like one in a condition.

Step-by-Step Explanation

To create a boolean directly, assign either True or False to a variable. These must begin with capital letters because they are special Python keywords.

Comparisons produce booleans. Common comparison operators are == for equality, != for not equal, > greater than, < less than, >= greater than or equal to, and <= less than or equal to. Logical operators combine results. and returns true only if both conditions are true. or returns true if at least one condition is true. not flips a boolean value.

Comprehensive Code Examples

is_active = True
print(is_active)
print(type(is_active))

print(10 > 5)
print(10 == 5)

age = 20
has_id = True
can_enter = age >= 18 and has_id
print(can_enter)

username = "python_student"
password = "secure123"
is_valid_user = username != "" and len(password) >= 8
print(is_valid_user)

items = []
if not items:
    print("The list is empty")

Common Mistakes

• Using lowercase booleans: writing true or false causes errors. Use True and False.
• Confusing = with ==: = assigns a value, while == compares values.
• Misunderstanding truthy and falsy values: an empty string or empty list behaves like false even though it is not the boolean False itself.
• Overcomplicating comparisons: instead of if is_ready == True:, simply write if is_ready:.

Best Practices

• Use clear variable names like is_logged_in, has_access, and can_save.
• Keep conditions readable by breaking complex logic into smaller variables.
• Use parentheses when combining multiple conditions to improve clarity.
• Prefer direct boolean checks instead of comparing explicitly to True or False unless needed.

Practice Exercises

• Create two variables named is_student and has_discount, assign boolean values, and print them.
• Write three comparison expressions using numbers and print whether each result is True or False.
• Create variables for age and membership status, then write a boolean expression that checks whether a person can enter a club.

Mini Project / Task

Build a simple eligibility checker that stores a person's age and whether they have an ID, then calculates and prints whether they are allowed to enter an event.

Challenge (Optional)

Create a small program that checks whether a user can reset a password only if their email is not empty and the account is marked as active.

Operators

Operators in Python are symbols and keywords used to perform actions on values and variables. They exist so programmers can write clear instructions for calculation, comparison, decision-making, and data handling without manually describing every low-level step. In real life, operators are used everywhere in software: calculating totals in billing systems, comparing passwords during login, checking whether a user has permission, combining conditions in filtering logic, and updating counters in analytics. Python includes arithmetic operators such as +, -, *, /, //, %, and **; comparison operators such as ==, !=, >, <, >=, and <=; assignment operators like =, +=, and *=; logical operators and, or, and not; membership operators in and not in; and identity operators is and is not. Each type solves a different problem. Arithmetic operators work with numbers, comparison operators return True or False, logical operators combine boolean conditions, membership operators test whether a value exists in a collection, and identity operators check whether two references point to the same object. Understanding the difference between these categories is important because Python programs often mix them together in a single expression. Operator precedence also matters: for example, multiplication happens before addition unless parentheses are used. Beginners should treat parentheses as a tool for clarity, not just correctness.

Step-by-Step Explanation

Start by placing values or variables on both sides of an operator. For example, a + b adds two values, while age >= 18 checks a condition. Assignment stores a value in a variable using =. Augmented assignment such as x += 1 updates the existing value more compactly. Comparison expressions produce boolean results that are commonly used inside if statements. Logical operators combine those boolean results, such as score > 50 and passed_exam. Membership operators are useful with strings, lists, tuples, sets, and dictionaries. Identity operators should be used carefully: == checks equal value, while is checks whether two names refer to the same object in memory. In most beginner cases, use == for value comparison.

Comprehensive Code Examples

Basic example

a = 10
b = 3
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)
print(a % b)
print(a ** b)

Real-world example

price = 1200
discount = 0.15
final_price = price - (price * discount)
is_affordable = final_price <= 1000
print(final_price)
print(is_affordable)

Advanced usage

username = "admin_user"
allowed_users = ["admin_user", "manager", "editor"]
is_active = True
has_access = username in allowed_users and is_active
print(has_access)

x = [1, 2, 3]
y = x
z = [1, 2, 3]
print(x == z)
print(x is y)
print(x is z)

Common Mistakes

• Using = instead of ==: = assigns a value, but == compares values.
• Confusing / and //: / returns normal division, while // returns floor division.
• Using is for value comparison: use == when comparing numbers, strings, or lists by content.
• Forgetting precedence: use parentheses to make expressions clear and avoid unexpected results.

Best Practices

• Use parentheses to improve readability in complex expressions.
• Prefer meaningful variable names so operations are easy to understand.
• Use comparison and logical operators to create clear conditions, not overly long expressions.
• Choose == for value checks and reserve is mainly for None checks, such as value is None.

Practice Exercises

• Create two variables and print the result of all arithmetic operators on them.
• Write a program that checks whether a number is between 1 and 100 using comparison and logical operators.
• Create a list of fruits and test whether a user-provided fruit name exists in the list using a membership operator.

Mini Project / Task

Build a simple shopping calculator that stores an item price, quantity, and discount percentage, then calculates subtotal, discount amount, final total, and whether the total qualifies for free shipping based on a condition.

Challenge (Optional)

Write a program that takes three numbers and prints the largest one using comparison and logical operators only.

Conditional Statements

Conditional statements allow a Python program to make decisions. Instead of running every line in the same order every time, the program can choose different paths based on whether a condition is true or false. This is essential in real applications such as checking login credentials, deciding whether a user can access a feature, validating age for registration, calculating discounts, or responding to sensor readings in automation systems. In Python, conditional logic is mainly built with if, elif, and else. An if statement runs code only when its condition evaluates to true. The elif keyword lets you test another condition if the previous one failed. The else block provides a default action when none of the earlier conditions match. Conditions are usually created with comparison operators such as ==, !=, >, <, >=, and <=, often combined with logical operators like and, or, and not. Python also uses indentation to define the body of each condition block, so spacing is not optional. This makes structure easy to read but requires careful formatting.

Step-by-Step Explanation

Start with the simplest form: if condition:. If the condition is true, the indented block underneath runs. If it is false, Python skips that block. To handle two outcomes, add else:. To test multiple possibilities in order, insert one or more elif blocks between them. Python checks from top to bottom and stops at the first true condition. That means order matters. You can also nest conditionals, placing one if inside another, though this should be kept readable. Many conditions use boolean values directly, but any expression that resolves to true or false can be used. For example, an empty string is falsey, while a non-empty string is truthy. Beginners should focus first on clear comparisons and straightforward branching before using compact expressions.

Comprehensive Code Examples

age = 20
if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

score = 82
if score >= 90:
    print("Grade A")
elif score >= 75:
    print("Grade B")
elif score >= 60:
    print("Grade C")
else:
    print("Needs improvement")

username = "admin"
password = "secure123"
if username == "admin" and password == "secure123":
    print("Login successful")
else:
    print("Invalid credentials")

temperature = 32
raining = False
if temperature > 30:
    if raining:
        print("Hot and wet weather")
    else:
        print("Hot and dry weather")
else:
    print("Temperature is moderate or low")

Common Mistakes

• Using = instead of ==: = assigns a value, while == compares values.
• Forgetting the colon: Every if, elif, and else line must end with :.
• Incorrect indentation: The code block under each condition must be indented consistently.
• Misordered conditions: Placing broad conditions before specific ones can prevent later checks from ever running.

Best Practices

• Write conditions that are simple and readable rather than overly clever.
• Order checks from most specific to most general when needed.
• Use logical operators carefully and add parentheses if clarity helps.
• Avoid deep nesting when possible; break complex logic into separate variables or functions later.
• Test both true and false cases to confirm all branches behave correctly.

Practice Exercises

• Write a program that checks whether a number is positive, negative, or zero.
• Create a program that takes a score variable and prints Pass if it is 50 or higher, otherwise Fail.
• Write a program that checks whether a person is eligible to vote using an age variable.

Mini Project / Task

Build a simple discount checker that prints the discount rate for a customer based on purchase amount, such as no discount, 10% discount, or 20% discount.

Challenge (Optional)

Create a small program that classifies a triangle as equilateral, isosceles, or scalene based on three side lengths, while also checking whether the sides can form a valid triangle.

If and Else Statements

If and else statements are decision-making tools in Python. They allow a program to choose between different actions based on whether a condition is true or false. In real life, people make decisions constantly: if it is raining, carry an umbrella; else, wear sunglasses. Python uses the same idea to control program flow. These statements are used everywhere, such as checking login credentials, validating user input, deciding discounts in shopping carts, grading exam scores, and handling app behavior based on settings or data.

The main forms are if, if-else, and if-elif-else. A simple if runs code only when a condition is true. An if-else chooses between two paths. An if-elif-else checks multiple conditions in order until one matches. Conditions usually compare values using operators like ==, !=, >, <, >=, and <=. You can also combine conditions with and, or, and not.

Step-by-Step Explanation

Python checks a condition after the if keyword. If the condition is true, the indented block below it runs. If it is false, Python skips that block. For an alternative path, use else. For multiple checks, use one or more elif blocks between if and else.

Basic syntax uses a colon at the end of each condition line, followed by indentation for the code block. Indentation is not optional in Python; it defines structure. Example pattern: test a value, choose the matching branch, then continue with the rest of the program.

age = 18
if age >= 18:
    print("Adult")
else:
    print("Minor")

Comprehensive Code Examples

Basic example

temperature = 30
if temperature > 25:
    print("It is a hot day")
else:
    print("It is not very hot")

Real-world example

username = "admin"
password = "python123"

if username == "admin" and password == "python123":
    print("Login successful")
else:
    print("Invalid credentials")

Advanced usage

score = 82

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print("Grade:", grade)

Common Mistakes

• Using = instead of ==: = assigns a value, while == compares values.
• Forgetting the colon: Every if, elif, and else line must end with :.
• Incorrect indentation: The code inside each branch must be indented consistently.
• Writing conditions in the wrong order: In an if-elif chain, broader conditions placed first can block more specific ones.

Best Practices

• Keep conditions simple and readable.
• Use meaningful variable names like is_logged_in or user_age.
• Order elif conditions from most specific to most general when needed.
• Avoid deeply nested if blocks when a clearer structure is possible.
• Test both true and false outcomes while practicing.

Practice Exercises

• Write a program that checks whether a number is positive or negative.
• Create a program that asks for a user age and prints whether the person can vote.
• Write a grading program using if-elif-else for score ranges.

Mini Project / Task

Build a simple ticket pricing program that checks a customer age and prints whether the ticket is child, adult, or senior pricing.

Challenge (Optional)

Create a password strength checker that prints different messages if a password is too short, acceptable, or strong based on length and whether it includes digits.

Elif and Nested Conditions

Conditional statements are fundamental to programming, allowing a program to make decisions and execute different blocks of code based on whether certain conditions are met. In Python, the primary conditional statements are if, elif (short for 'else if'), and else. While if and else provide a binary choice, elif allows for checking multiple conditions sequentially, making your code more efficient and readable than a series of independent if statements. Nested conditions, on the other hand, involve placing one conditional statement inside another, enabling more complex decision-making logic.

These constructs are crucial for creating dynamic and responsive applications. For instance, in a video game, an elif chain might determine a character's action based on different health levels (e.g., if health > 80% then full attack, elif health > 50% then cautious attack, else then retreat). Nested conditions could be used in a login system: an outer if checks if the username is correct, and if it is, an inner if checks the password. If both are correct, access is granted. In real-world scenarios, from web application routing to data validation and even controlling industrial machinery, elif and nested conditions are indispensable for directing program flow based on various inputs and states.

Python's elif statement is used when you have more than two possible outcomes and want to test multiple conditions in a specific order. The interpreter checks conditions from top to bottom. As soon as a condition evaluates to True, its corresponding block of code is executed, and the rest of the elif/else chain is skipped. If none of the if or elif conditions are met, the else block (if present) is executed as a fallback. Nested conditions mean an if, elif, or else statement can contain another complete if/elif/else structure within its code block. This allows for hierarchical decision-making, where one decision leads to another set of decisions.

Step-by-Step Explanation

The basic syntax for elif involves an initial if statement, followed by one or more elif statements, and optionally ending with an else statement.

if condition1:
    # code to execute if condition1 is True
elif condition2:
    # code to execute if condition2 is True
elif condition3:
    # code to execute if condition3 is True
else:
    # code to execute if none of the above conditions are True

For nested conditions, the structure is simply placing a conditional statement inside another's indented block:

if outer_condition:
    # code for outer_condition being True
    if inner_condition:
        # code for inner_condition being True (and outer_condition also True)
    else:
        # code for inner_condition being False (and outer_condition True)
else:
    # code for outer_condition being False

The key is proper indentation; Python uses indentation to define code blocks. Each level of nesting requires an additional level of indentation (typically 4 spaces).

Comprehensive Code Examples

Basic Elif Example: Grading System

score = 85

if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
elif score >= 60:
    print("Grade: D")
else:
    print("Grade: F")

Real-world Example: Weather-based Activity Suggestion

weather = "rainy"
temperature = 22 # Celsius

if weather == "sunny":
    if temperature > 25:
        print("It's hot and sunny! Go swimming.")
    else:
        print("It's sunny and pleasant. Go for a walk.")
elif weather == "cloudy":
    print("It's cloudy. Maybe read a book or visit a museum.")
elif weather == "rainy":
    if temperature < 10:
        print("It's cold and rainy. Stay home, drink hot chocolate!")
    else:
        print("It's rainy but mild. Watch a movie or play board games.")
else:
    print("Unusual weather. Check conditions and decide.")

Advanced Usage: Discount Calculator with Multiple Criteria

total_purchase = 120
is_member = True
has_coupon = False

if total_purchase >= 100:
    if is_member:
        print("Eligible for 15% member discount on large purchase.")
        discount = 0.15
    elif has_coupon:
        print("Eligible for 10% coupon discount on large purchase.")
        discount = 0.10
    else:
        print("Eligible for 5% general discount on large purchase.")
        discount = 0.05
elif total_purchase >= 50:
    if is_member:
        print("Eligible for 10% member discount on medium purchase.")
        discount = 0.10
    else:
        print("No special discount for medium purchase.")
        discount = 0.0
else:
    print("No discount applied.")
    discount = 0.0

final_price = total_purchase * (1 - discount)
print(f"Final price: ${final_price:.2f}")

Common Mistakes

• Incorrect Indentation: Python relies heavily on indentation. Misplacing a line of code can lead to IndentationError or incorrect logic. Ensure consistent indentation (e.g., 4 spaces) for each block.


• Putting Multiple Conditions in Separate if Statements Instead of elif: If you use multiple if statements instead of elif, Python will evaluate every single if condition, even if a previous one was true. This can lead to inefficient code or unintended multiple actions being triggered. Use elif when conditions are mutually exclusive.


• Confusing Logical Operators (and, or) with Nested Ifs: Sometimes, a complex nested if can be simplified using and or or operators in a single condition. For example, if x > 0: if y < 10: can often be written as if x > 0 and y < 10:. Choose the clearer and more efficient option.

Best Practices

• Keep it Readable: While nesting is powerful, excessive nesting (more than 2-3 levels deep) can make code hard to read and debug. If your code is too deeply nested, consider refactoring it into separate functions or using logical operators.


• Order elif Conditions Logically: Place the most specific or most likely conditions first in an elif chain. Since Python stops at the first true condition, this can improve performance.


• Use else for Default Cases: Always consider adding an else block to handle cases where none of your explicit if or elif conditions are met. This prevents unexpected behavior and makes your code more robust.


• Break Down Complex Logic: For very complex decision trees, break them down into smaller, manageable functions. Each function can handle a part of the decision, returning a result that the main logic then uses.

Practice Exercises

• Exercise 1 (Beginner-friendly): Write a Python program that asks the user for a number (1-7) and prints the corresponding day of the week (e.g., 1 for Monday, 7 for Sunday) using elif. If the number is outside the range, print an error message.


• Exercise 2: Create a program that determines the type of a triangle based on the lengths of its three sides (entered by the user). It should classify it as 'Equilateral' (all sides equal), 'Isosceles' (two sides equal), or 'Scalene' (no sides equal). Use nested conditions to also check if the given side lengths can actually form a triangle (the sum of any two sides must be greater than the third side).


• Exercise 3: Write a script that simulates a simple traffic light. Ask the user for the current light color ('red', 'yellow', 'green') and whether there's an emergency vehicle ('yes' or 'no'). Predict the action: 'Stop' if red or emergency, 'Prepare to stop' if yellow, 'Go' if green and no emergency.

Mini Project / Task

Build a simple text-based adventure game segment where the player makes a choice. Present the player with a scenario (e.g., "You are at a crossroads. Do you go 'left', 'right', or 'straight'?"). Use elif to handle each choice and print a different outcome. Inside at least one of these choices, use a nested condition to ask another question (e.g., if they go 'right', ask if they want to 'run' or 'walk') and provide further branching outcomes.

Challenge (Optional)

Expand the traffic light simulation from Exercise 3. Add a condition for pedestrian presence ('yes' or 'no'). If the light is green and there are pedestrians, the car should 'Yield to pedestrians' before 'Go'. If red, it's still 'Stop'. If yellow, it's 'Prepare to stop' regardless of pedestrians. Integrate this new condition with careful use of elif and nested logic.

Match Case Statement

The match...case statement in Python is a control-flow feature introduced in Python 3.10 for structural pattern matching. It lets you compare a value against multiple patterns and execute the matching block. It exists to make complex decision-making clearer than long chains of if/elif/else, especially when checking specific values, data shapes, or grouped conditions. In real life, it is useful in menu systems, command parsers, API response handling, event processing, and applications that must react differently based on the structure of incoming data.

At a basic level, match works like a cleaner switch-style statement, but it is more powerful because Python can match literals, multiple options, variables, sequences, mappings, and guarded conditions. Common pattern forms include literal patterns such as numbers or strings, OR patterns using |, wildcard patterns using _, sequence patterns for lists and tuples, and guarded cases with if conditions. The subject expression is written after match, and each case is tested from top to bottom. The first successful match runs, so order matters.

Step-by-Step Explanation

The syntax starts with a value to inspect: match value:. Under it, you define cases such as case 1: or case "start":. If the subject equals that pattern, Python executes that block. Use case _: as a default catch-all. You can combine patterns with |, for example case "y" | "yes":. For sequences, Python can unpack while matching, such as a two-item tuple. Guards add extra checks, like case n if n > 0:. Keep in mind that the statement compares patterns in order, stops at the first match, and works best when the possibilities are known and structured clearly.

Comprehensive Code Examples

Basic example

day = 3

match day:
    case 1:
        print("Monday")
    case 2:
        print("Tuesday")
    case 3:
        print("Wednesday")
    case _:
        print("Invalid day")

Real-world example

command = "delete"

match command:
    case "create":
        print("Creating record")
    case "update":
        print("Updating record")
    case "delete":
        print("Deleting record")
    case "help" | "?":
        print("Showing help menu")
    case _:
        print("Unknown command")

Advanced usage

response = ("error", 404)

match response:
    case ("success", data):
        print(f"Success: {data}")
    case ("error", 404):
        print("Page not found")
    case ("error", code) if code >= 500:
        print(f"Server error: {code}")
    case ("error", code):
        print(f"Other error: {code}")
    case _:
        print("Unexpected response")

Common Mistakes

• Using Python older than 3.10: match will fail. Fix: run the code in Python 3.10 or newer.
• Placing the default case too early: case _: matches everything. Fix: keep it last.
• Expecting all cases to run: only the first matching case executes. Fix: order cases from most specific to most general.
• Confusing pattern matching with simple equality only: patterns can unpack structures. Fix: learn sequence and guarded patterns gradually.

Best Practices

• Use match when many structured cases make if/elif harder to read.
• Keep case order intentional, with specific patterns first.
• Always include case _: when unexpected input is possible.
• Use meaningful variable names in captured patterns for readability.
• Avoid overly clever nesting; choose clarity over compactness.

Practice Exercises

• Write a match statement that prints the name of a month for numbers 1 to 4 and prints "Unknown" for anything else.
• Create a simple text menu that handles add, edit, and remove commands using match.
• Match a tuple representing coordinates like (0, 5), (3, 0), or (2, 4) and print whether the point is on an axis or not.

Mini Project / Task

Build a small command dispatcher for a console app that accepts a user command such as login, logout, profile, or help and prints the correct action using a match statement.

Challenge (Optional)

Create a program that matches a tuple in the form (operation, a, b) and performs calculator actions for add, subtract, multiply, and divide, including a guarded case to prevent division by zero.

While Loops

A while loop is a control structure that repeatedly runs a block of code as long as a condition remains true. It exists because many programming tasks do not have a fixed number of repetitions in advance. Instead of saying “repeat exactly 10 times,” you often need logic like “keep asking until the user enters a valid value” or “continue processing until the file is empty.” In real life, while loops are used in login systems, menu-driven applications, game loops, background processing, and validation tasks. Python mainly provides the while loop for condition-based repetition. Unlike some other languages, Python does not have a built-in do-while loop, but similar behavior can be simulated by running code once before checking the condition.

The core idea is simple: Python checks a condition before each iteration. If the condition is true, the loop body runs. When it becomes false, the loop stops. This means the loop may run many times or not at all. While loops are useful when the stopping point depends on changing values such as user input, counters, flags, or external events. Important related concepts include infinite loops, loop control with break and continue, and optional else blocks. A loop becomes infinite if its condition never turns false. The break statement exits the loop immediately, while continue skips the rest of the current iteration and moves to the next check. The else block runs only if the loop finishes normally without hitting break.

Step-by-Step Explanation

Basic syntax:

while condition:
    # code to repeat

Start by defining the value that controls the loop, such as a counter. Next, write a condition after while. Then indent the code that should repeat. Finally, make sure something inside the loop changes the condition; otherwise, the loop may never stop.

You can also use:

while condition:
    if something:
        break
    if another_thing:
        continue
else:
    print("Loop ended normally")

Comprehensive Code Examples

Basic example

count = 1
while count <= 5:
    print(count)
    count += 1

This prints numbers 1 through 5. The counter increases each time, so the condition eventually becomes false.

Real-world example

password = ""
while password != "python123":
    password = input("Enter password: ")
print("Access granted")

This is a common input-validation pattern. The loop continues until the correct value is entered.

Advanced usage

attempts = 0
while attempts < 3:
    code = input("Enter verification code: ")
    if code == "9999":
        print("Verified")
        break
    attempts += 1
    print("Incorrect")
else:
    print("Too many failed attempts")

Here, break exits early on success. If all attempts fail, the else block runs.

Common Mistakes

• Forgetting to update the loop variable: If you never change the value in the condition, the loop may run forever. Fix it by updating counters or state inside the loop.
• Using the wrong condition: Writing count < 5 instead of count <= 5 changes how many times the loop runs. Test boundary values carefully.
• Bad indentation: Python depends on indentation to define the loop body. Keep indentation consistent.
• Misusing continue: If the update happens after continue, the loop may never progress. Update important variables before continuing.

Best Practices

• Write loop conditions that are easy to read and clearly connected to the stopping rule.
• Prefer meaningful variable names like attempts, is_running, or items_left.
• Use break carefully for clear exit points, especially in input-driven programs.
• Avoid unnecessary infinite loops unless you intentionally manage them with exit conditions.
• If the number of iterations is fixed, consider using a for loop instead.

Practice Exercises

• Write a while loop that prints numbers from 10 down to 1.
• Create a loop that keeps asking for a positive number until the user enters one.
• Write a while loop that adds numbers from 1 to 50 and prints the final total.

Mini Project / Task

Build a simple menu loop that repeatedly asks the user to choose: 1 for greeting, 2 for current status message, and 0 to exit. Keep showing the menu until the user chooses to quit.

Challenge (Optional)

Create a number guessing game where the program keeps asking the user to guess a secret number until they get it right, while also counting how many attempts were needed.

For Loops

The for loop is a fundamental control flow statement in Python, used for iterating over a sequence (like a list, tuple, string, or range) or other iterable objects. It allows you to execute a block of code repeatedly for each item in the sequence. In essence, it's a way to automate repetitive tasks, making your code more efficient and readable. Imagine you have a list of items and you need to perform the same operation on each item – a for loop is the perfect tool for this. For example, if you're processing a list of customer names, calculating grades for a class of students, or iterating through characters in a word, for loops provide a concise and powerful mechanism. They are extensively used in data processing, file handling, web scraping, and any scenario where you need to access elements within a collection one by one.

While Python primarily features for and while loops, the for loop is specifically designed for definite iteration, meaning you know in advance how many times the loop will run (or at least, you're iterating over a finite collection). Unlike some other languages that have a traditional C-style for loop (with initialization, condition, and increment), Python's for loop directly iterates over the elements of an iterable, making it very Pythonic and often more readable.

Step-by-Step Explanation

The basic syntax of a for loop in Python is as follows:

for item in iterable:
    # code to be executed for each item

Let's break down each part:

• for: This is the keyword that initiates the loop.
• item: This is a temporary variable that takes on the value of each element in the iterable during each iteration. You can name this variable anything you like (e.g., number, char, element).
• in: This keyword signifies that the loop will iterate 'in' the specified iterable.
• iterable: This is any object that can be iterated over, such as a list, tuple, string, dictionary, or a range() object.
• : (colon): This marks the end of the for statement header.
• Indented Block: The lines of code that are indented after the colon form the 'loop body'. These lines will be executed once for each item in the iterable. Indentation is crucial in Python to define code blocks.

The loop continues until all items in the iterable have been processed. Once the loop finishes, the program execution continues with the first statement after the loop's indented block.

Comprehensive Code Examples

Basic example: Iterating through a list

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

Real-world example: Calculating the sum of numbers in a list

expenses = [25.50, 12.75, 50.00, 3.20, 10.00]
total_expense = 0

for expense in expenses:
    total_expense += expense  # Add each expense to the total

print(f"Total monthly expenses: ${total_expense:.2f}")

Advanced usage: Iterating with range() and enumerate()

# Using range() to iterate a specific number of times
print("Counting from 0 to 4:")
for i in range(5): # range(5) generates numbers 0, 1, 2, 3, 4
    print(i)

print("\nCounting from 2 to 6 (step of 2):")
for j in range(2, 7, 2): # range(start, stop, step)
    print(j)

# Using enumerate() to get both index and value
words = ["hello", "world", "python"]
print("\nWords with their indices:")
for index, word in enumerate(words):
    print(f"Index {index}: {word}")

Common Mistakes

• Forgetting to indent the loop body: Python uses indentation to define code blocks. Incorrect indentation will lead to IndentationError or logical errors.
  Fix: Ensure all statements meant to be inside the loop are consistently indented (usually 4 spaces).
• Modifying the list being iterated over: Adding or removing items from a list while iterating over it can lead to unexpected behavior or an infinite loop if not handled carefully.
  Fix: If you need to modify a list, iterate over a copy of it (e.g., for item in list_name[:]) or create a new list for the modified items.
• Forgetting the colon (:) at the end of the for statement: This is a common syntax error that will result in a SyntaxError.
  Fix: Always include the colon at the end of the for line.

Best Practices

• Use descriptive variable names: Instead of for x in my_list:, use for item in my_list: or for user_name in user_names: for better readability.
• Keep loop bodies concise: If the code inside your loop becomes too long or complex, consider refactoring it into a separate function.
• Leverage built-in functions: Python offers many powerful built-in functions like enumerate(), zip(), and range() that enhance the functionality and readability of for loops.
• Avoid unnecessary loops: Sometimes, list comprehensions or other built-in functions can achieve the same result more efficiently and concisely than a traditional for loop.

Practice Exercises

• Beginner-friendly: Write a for loop that prints every character in the string "Python is fun!".
• Based ONLY on this topic: Create a list of five different numbers. Use a for loop to iterate through the list and print only the numbers that are even.
• Clear instructions: Given a list of names: ['Alice', 'Bob', 'Charlie', 'David'], use a for loop to print each name followed by " is a great programmer!".

Mini Project / Task

Write a Python program that takes a list of temperatures in Celsius (e.g., [0, 10, 20, 30, 40]) and uses a for loop to convert each temperature to Fahrenheit using the formula F = C * 9/5 + 32. Print both the Celsius and Fahrenheit temperatures for each entry.

Challenge (Optional)

Given a list of words: ['apple', 'banana', 'grape', 'kiwi', 'orange', 'strawberry']. Use a for loop along with conditional statements to print only the words that have an odd number of characters.

Break and Continue

In Python, break and continue are loop control statements used to change the normal flow of repetition. They exist because not every loop should always run until its natural end. Sometimes you want to stop a loop immediately when a condition is met, and sometimes you want to skip only the current iteration and move to the next one. These statements are commonly used in searching, input validation, menu systems, filtering records, and processing large datasets efficiently.

break completely exits the nearest enclosing loop. It is useful when the goal has already been achieved, such as finding a target item in a list or ending a program menu when the user chooses quit. continue, on the other hand, does not stop the loop; it skips the remaining code in the current iteration and jumps to the next cycle. This is useful when some values should be ignored, such as skipping invalid input, empty lines, or unwanted records.

These statements work with both for and while loops. In real-life software, they help reduce unnecessary work and make intent clearer when used carefully. However, overusing them can make logic harder to follow, so it is important to understand their behavior precisely.

Step-by-Step Explanation

Use break inside a loop when a condition means the loop should end immediately.

Basic syntax with a for loop:

for item in items:
    if condition:
        break

When Python reaches break, it leaves the loop entirely and continues with the first statement after the loop.

Use continue when you want to skip the rest of the current iteration but keep looping.

for item in items:
    if condition:
        continue
    # remaining code runs only when condition is False

With a while loop, both statements behave the same way, but you must be careful to update loop variables correctly so the loop does not become infinite.

while condition:
    if stop_condition:
        break
    if skip_condition:
        continue

Comprehensive Code Examples

Basic example

numbers = [3, 7, 9, 12, 15]

for num in numbers:
    if num == 12:
        break
    print(num)

This prints 3, 7, and 9, then stops before printing 12.

Real-world example

emails = ["[email protected]", "", "[email protected]", "[email protected]"]

for email in emails:
    if email == "":
        continue
    print(f"Sending message to {email}")

Empty entries are skipped, but the loop continues processing valid addresses.

Advanced usage

secret_pin = "2486"
attempts = 0

while attempts < 3:
    pin = input("Enter PIN: ")
    attempts += 1

    if not pin.isdigit():
        print("PIN must contain only digits.")
        continue

    if pin == secret_pin:
        print("Access granted")
        break

    print("Incorrect PIN")
else:
    print("Too many failed attempts")

Here, continue skips invalid-format handling, while break exits when access is granted.

Common Mistakes

• Using break when you only want to skip one item: Fix by using continue instead.
• Forgetting loop updates in while loops: If continue runs before incrementing, you may create an infinite loop. Update control variables before continuing.
• Placing code after continue expecting it to run: Any statements below continue in that iteration are skipped.

Best Practices

• Use break only when exiting early makes the program clearer or more efficient.
• Use continue to handle invalid or unwanted data cleanly at the top of the loop.
• Keep loop conditions readable so the purpose of skipping or stopping is obvious.
• In while loops, always ensure the loop can still progress after a continue.

Practice Exercises

• Write a loop that prints numbers from 1 to 10 but stops completely when it reaches 7.
• Write a loop that prints numbers from 1 to 10 but skips printing 5.
• Create a list of words and write a loop that ignores empty strings using continue.

Mini Project / Task

Build a simple search program that scans a list of product names and stops with break when the target product is found. If an empty product name appears, skip it using continue.

Challenge (Optional)

Create a number-processing loop from 1 to 30 that skips multiples of 3, stops entirely when it reaches the first multiple of 11, and prints all other numbers.

Functions Introduction

Functions are reusable blocks of code designed to perform a specific task. Instead of writing the same logic again and again, you place that logic inside a function and call it whenever needed. This makes programs shorter, cleaner, easier to test, and easier to maintain. In real-life software, functions are used everywhere: calculating totals in billing systems, validating login data in websites, formatting reports, processing files, and handling API responses. In Python, functions help organize code into meaningful units, making large applications manageable. A function can take input values called parameters, process them, and optionally return a result. Some functions only perform an action, while others compute and send back data. Python provides built-in functions such as print(), len(), and sum(), but developers often create custom functions using the def keyword. Understanding functions is important because they support modular programming, code reuse, debugging, teamwork, and scalability. Common function-related ideas include function definition, function call, parameters, arguments, return values, default parameters, and variable scope. A parameter is the variable listed in the function definition, while an argument is the actual value passed during a call. Some functions return one value, some return multiple values, and some return nothing explicitly. Python also supports positional arguments and keyword arguments, which make function calls flexible and readable.

Step-by-Step Explanation

To create a function, start with def, then write the function name, parentheses, and a colon. Inside the function body, write indented code. If needed, use return to send a value back. Example structure: def greet(name):
    return "Hello " + name
When you call greet("Ava"), Python assigns "Ava" to name, runs the function body, and returns the final string. If a function does not use return, Python returns None automatically. You can also define default values, such as def greet(name="Guest"):, which allows the function to work even if no argument is passed. Functions should usually do one clear job, and their names should describe that job.

Comprehensive Code Examples

def say_hello():
    print("Hello, world!")

say_hello()

def calculate_total(price, tax_rate):
    tax = price * tax_rate
    return price + tax

total = calculate_total(100, 0.18)
print("Final total:", total)

def format_student_result(name, marks, passed_mark=40):
    status = "Passed" if marks >= passed_mark else "Failed"
    message = f"Student: {name}, Marks: {marks}, Status: {status}"
    return message, status

report, result = format_student_result("Lina", 72)
print(report)
print(result)

Common Mistakes

• Forgetting parentheses when calling a function: writing say_hello instead of say_hello(). Fix: always include parentheses to execute it.
• Using incorrect indentation: Python requires the function body to be indented consistently. Fix: use four spaces for each block.
• Confusing print() with return: print() displays output, but return sends data back to the caller. Fix: use return when another part of the program needs the result.
• Passing the wrong number of arguments: Fix: match the function definition or use default values where appropriate.

Best Practices

• Use clear, descriptive names like calculate_discount or send_email.
• Keep each function focused on one task.
• Prefer returning values instead of printing inside reusable functions.
• Use default parameters carefully to make functions flexible.
• Write small functions that are easier to test and debug.

Practice Exercises

• Create a function named square_number that takes one number and returns its square.
• Write a function called greet_user that accepts a name and prints a welcome message.
• Create a function is_even that takes an integer and returns whether it is even.

Mini Project / Task

Build a simple bill calculator function that accepts item price and tax rate, then returns the final amount to pay.

Challenge (Optional)

Create a function that accepts a student name and a list of marks, then returns the average score and whether the student passed.

Function Arguments and Parameters

Functions are fundamental building blocks in Python, allowing you to encapsulate reusable blocks of code. To make functions flexible and powerful, they often need to accept input. This input is handled through parameters and arguments. Understanding the distinction and various types is crucial for writing robust and maintainable Python code. Parameters are the names defined in the function signature, acting as placeholders for the data the function expects. Arguments are the actual values passed to the function when it is called. This mechanism enables functions to operate on different data without being rewritten, promoting code reusability and modularity. In real-world applications, this is used everywhere from simple utility functions that calculate values (e.g., a function to calculate the area of a circle that takes 'radius' as a parameter) to complex web frameworks where functions handle user input (e.g., a function processing a form submission might take 'username' and 'password' as arguments). Without arguments and parameters, functions would be static and less versatile, severely limiting Python's capabilities for dynamic and interactive programming.

Python supports several types of arguments, each providing different levels of flexibility and control over how data is passed to functions. The main types are Positional Arguments, Keyword Arguments, Default Arguments, Arbitrary Positional Arguments (*args), and Arbitrary Keyword Arguments (**kwargs). Positional arguments are the simplest; their order matters. Keyword arguments allow you to pass values by explicitly naming the parameter, making the order irrelevant and improving readability. Default arguments provide a fallback value if an argument is not provided during the function call, making functions more flexible. Arbitrary positional arguments (`*args`) allow a function to accept an arbitrary number of positional arguments, collected into a tuple. Similarly, arbitrary keyword arguments (`**kwargs`) allow a function to accept an arbitrary number of keyword arguments, collected into a dictionary. Mastering these different argument types empowers you to design highly adaptable and expressive functions, crucial for any complex Python project.

Step-by-Step Explanation

Let's break down the syntax for each argument type.

1. Positional Arguments: Defined by listing parameter names in the function definition. When calling, arguments are matched to parameters by their position.
def greet(name, message):
# ...
greet("Alice", "Hello")

2. Keyword Arguments: Passed by explicitly naming the parameter in the function call.
def greet(name, message):
# ...
greet(message="Hi", name="Bob")

3. Default Arguments: Parameters assigned a default value in the function definition. If an argument is omitted, the default is used.
def greet(name, message="Hello"):
# ...
greet("Charlie")
greet("David", "Greetings")

4. Arbitrary Positional Arguments (*args): Use *parameter_name in the function definition. It collects all extra positional arguments into a tuple.
def sum_all(*numbers):
# numbers will be a tuple
# ...

5. Arbitrary Keyword Arguments (**kwargs): Use **parameter_name in the function definition. It collects all extra keyword arguments into a dictionary.
def display_info(**details):
# details will be a dictionary
# ...

Comprehensive Code Examples

Basic Example: Positional and Keyword Arguments

def describe_car(make, model, year):
    print(f"This is a {year} {make} {model}.")

# Positional arguments
describe_car("Toyota", "Camry", 2022)

# Keyword arguments
describe_car(year=2023, make="Honda", model="Civic")

# Mixing positional and keyword (positional first!)
describe_car("Ford", model="Mustang", year=2024)

Real-world Example: Default Arguments and *args

def send_email(recipient, subject="No Subject", body="", *attachments):
    print(f"Sending email to: {recipient}")
    print(f"Subject: {subject}")
    print(f"Body: {body}")
    if attachments:
        print(f"Attachments: {', '.join(attachments)}")
    print("---------------------")

send_email("[email protected]", "Meeting Reminder", "Don't forget the meeting.")
send_email("[email protected]", body="Please find the report attached.", attachments="report.pdf")
send_email("[email protected]", "Project Update", "See updates below.", "doc1.docx", "image.png", "data.xlsx")

Advanced Usage: **kwargs for flexible configuration

def create_user_profile(username, email, **profile_details):
    user_profile = {
        "username": username,
        "email": email
    }
    user_profile.update(profile_details)
    print("User Profile Created:")
    for key, value in user_profile.items():
        print(f"  {key}: {value}")
    print("---------------------")

create_user_profile("alice_dev", "[email protected]", age=30, city="New York", occupation="Software Engineer")
create_user_profile("bob_tester", "[email protected]", department="QA")

Common Mistakes

• Incorrect Order of Positional and Keyword Arguments: A common error is placing positional arguments after keyword arguments. Python requires all positional arguments to come before any keyword arguments.
  def func(a, b): pass
func(b=2, 1) # This will raise a SyntaxError
  Fix: Always pass positional arguments first: func(1, b=2).


• Modifying Mutable Default Arguments: Using mutable objects (like lists or dictionaries) as default argument values can lead to unexpected behavior because the default object is created only once, when the function is defined.
  def add_item(item, my_list=[]):
my_list.append(item)
print(my_list)
add_item(1) # prints [1]
add_item(2) # prints [1, 2] - unexpected!
  Fix: Use None as a default and initialize the mutable object inside the function if None is passed:
  def add_item(item, my_list=None):
if my_list is None:
my_list = []
my_list.append(item)
print(my_list)


• Confusing *args with **kwargs: Misunderstanding that *args captures positional arguments as a tuple and **kwargs captures keyword arguments as a dictionary.
  def process_data(*data, **options):
print(data) # expects tuple
print(options) # expects dict
process_data(1, 2, key='value') # Correct
process_data(key='value', 1, 2) # SyntaxError: positional argument follows keyword argument
  Fix: Remember that *args always comes before **kwargs in the function definition and call, and they capture different types of arguments.

Best Practices

• Use Keyword Arguments for Clarity: For functions with many parameters, especially boolean flags or parameters with non-obvious meanings, use keyword arguments to improve readability of function calls.


• Limit Positional Arguments: Functions with more than 3-4 positional arguments can be hard to remember and use correctly. Consider refactoring to use keyword arguments, group related parameters into an object, or split the function.


• Default Arguments for Optional Parameters: Use default arguments for parameters that frequently have the same value or are optional, making the function more flexible and reducing boilerplate code.


• Avoid Mutable Defaults: As discussed in common mistakes, never use mutable objects (lists, dictionaries, sets) directly as default argument values. Use None and initialize inside the function.


• Document Function Signatures: Use docstrings to clearly explain what each parameter expects, its type, and its purpose. This is especially important for functions using *args and **kwargs.

Practice Exercises

• Exercise 1 (Beginner-friendly): Write a function calculate_area(length, width) that takes two positional arguments, length and width, and returns the area of a rectangle. Call it with example values.


• Exercise 2: Create a function greet_user(name, greeting="Hello") that uses a default argument for the greeting. Call it once with a custom greeting and once with the default greeting.


• Exercise 3: Define a function print_items(*items) that accepts an arbitrary number of positional arguments and prints each item on a new line.

Mini Project / Task

Build a simple contact management function. Create a function called add_contact(name, phone_number, **details). This function should take a contact's name and phone_number as required arguments, and then accept any additional contact details (like email, address, company) as keyword arguments. The function should print all the contact's information in a readable format.

Challenge (Optional)

Expand on the contact management function. Create a global list called contacts = []. Modify the add_contact function to store the contact details as a dictionary in this contacts list. Then, create a new function find_contact(name_to_find, *search_fields). This function should search the contacts list for a contact whose name matches name_to_find. If search_fields are provided (e.g., "email", "company"), it should only print those specific fields for the found contact. If no search_fields are given, print all available details for the contact. Handle cases where the contact is not found.

Return Values

A return value is the result a function sends back after it finishes its work. In Python, functions are used to group logic into reusable blocks, and return values allow one part of a program to pass computed data back to another part. This makes programs modular, easier to test, and easier to reuse. In real life, return values are used everywhere: a login function may return True or False, a pricing function may return a final total, and a data-processing function may return a cleaned list or dictionary. Without return values, functions could only print information, which is not enough when later code needs to store, compare, or transform results.

In Python, a function can return many kinds of values: numbers, strings, booleans, lists, dictionaries, objects, or even multiple values at once. If no explicit return statement is used, Python automatically returns None. Another important idea is the difference between printing and returning. Printing shows something to the user, but returning sends a value back to the caller so it can be reused. A function may also return early, which means it stops immediately when a condition is met. This is useful in validation, searching, and error handling.

Step-by-Step Explanation

The basic syntax is simple: define a function with def, perform some work, then use return followed by the result. When Python reaches return, the function ends and the value is sent back. You can store that value in a variable, pass it into another function, or use it inside an expression. You can also return multiple values separated by commas; Python packages them into a tuple automatically.

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

result = add(3, 4)
print(result)

Comprehensive Code Examples

# Basic example
def square(number):
    return number * number

value = square(5)
print(value)

# Real-world example
def calculate_discount(price, percent):
    discount = price * (percent / 100)
    return price - discount

final_price = calculate_discount(120, 15)
print("Final price:", final_price)

# Advanced usage
def analyze_score(score):
    if score < 0 or score > 100:
        return "Invalid", False
    if score >= 50:
        return "Pass", True
    return "Fail", False

status, passed = analyze_score(78)
print(status)
print(passed)

Notice that the advanced example returns two values. Python treats them as a tuple, and you can unpack them into separate variables. This is common when a function needs to return both a result and extra status information.

Common Mistakes

• Using print() instead of return: Printing displays output but does not make it reusable. Fix: return the value if later code needs it.
• Forgetting that code after return will not run: Any statements below it in the same block are skipped. Fix: place return after all required logic.
• Not handling None: If a function has no explicit return, Python returns None. Fix: always define what the function should return.
• Returning inconsistent types: Returning a number in one case and a string in another can confuse later code. Fix: keep return types predictable when possible.

Best Practices

• Design functions to return useful data instead of only printing messages.
• Use clear function names that suggest what value is returned, such as get_total() or is_valid().
• Keep return values consistent so other developers know what to expect.
• Use early returns to simplify validation and reduce deep nesting.
• Document special return cases like None or tuples with multiple values.

Practice Exercises

• Write a function named double_number() that takes one number and returns twice its value.
• Write a function named is_even() that returns True if a number is even and False otherwise.
• Write a function named full_name() that takes a first name and last name and returns them as one formatted string.

Mini Project / Task

Create a function called calculate_total_bill() that accepts meal cost, tax percentage, and tip percentage, then returns the final bill amount. Store the returned value and print a receipt message using it.

Challenge (Optional)

Build a function called find_first_positive() that takes a list of numbers and returns the first positive value. If no positive value exists, return None.

Lambda Functions

Lambda functions in Python are small anonymous functions created in a single line. They exist to let developers define quick, lightweight behavior without writing a full def block. In real projects, they are often used when passing a function as an argument to tools like map(), filter(), sorted(), and event handlers. For example, you might sort a list of products by price, transform raw data before analysis, or filter records based on a condition. A lambda is useful when the logic is short and only needed once.

Unlike regular functions, lambda functions do not usually have a name, although they can be assigned to a variable. Their main purpose is convenience. The basic syntax is lambda parameters: expression. A lambda can take zero, one, or many arguments, but it can contain only one expression. That expression is automatically returned. This makes lambdas compact, but also means they are not suited for multi-step business logic. If the logic becomes difficult to read, a normal function is the better choice.

Common uses include one-argument lambdas such as doubling a number, multi-argument lambdas such as adding two values, and key-function lambdas used in sorting and grouping. Python programmers often use them with collections because they make short transformations easier to express.

Step-by-Step Explanation

Start with the structure: lambda x: x * 2.
Here, lambda begins the function definition.
x is the parameter.
The colon separates the parameters from the expression.
x * 2 is the expression, and Python returns its result automatically.

A regular function and a lambda can do the same work. For example, def square(x): return x * x is similar to lambda x: x * x. The difference is readability and purpose. Use lambda for short, simple actions. Use def for reusable or more complex logic.

You can also pass lambdas directly into functions. For sorting tuples by their second item, use a key function like lambda item: item[1]. This tells Python exactly what value should be used during sorting.

Comprehensive Code Examples

Basic example

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

Real-world example

products = [
    {"name": "Laptop", "price": 900},
    {"name": "Mouse", "price": 25},
    {"name": "Keyboard", "price": 75}
]

sorted_products = sorted(products, key=lambda product: product["price"])
print(sorted_products)

Advanced usage

numbers = [1, 2, 3, 4, 5, 6]

evens = list(filter(lambda n: n % 2 == 0, numbers))
squares = list(map(lambda n: n ** 2, numbers))

print(evens)
print(squares)

This advanced example shows lambdas working with higher-order functions. filter() keeps items that match a condition, while map() transforms each item into a new value.

Common Mistakes

• Putting too much logic inside a lambda: If the expression becomes hard to read, replace it with a regular function.
• Forgetting that lambda returns one expression only: You cannot write multiple statements such as loops or assignments inside it.
• Using lambda when a named function is clearer: If you need reuse, testing, or documentation, use def.
• Misunderstanding sorting keys: In sorted(), the lambda should return the value to sort by, not a true/false condition unless that is intentional.

Best Practices

• Use lambda for short, simple operations that are easy to understand at a glance.
• Prefer regular functions for complex business logic or repeated behavior.
• Use lambdas most often with map(), filter(), sorted(), and similar tools.
• Keep parameter names meaningful, such as student or product, instead of vague names when possible.
• Prioritize readability over clever one-line code.

Practice Exercises

• Create a lambda that multiplies a number by 10 and test it with three different inputs.
• Use sorted() with a lambda to sort a list of tuples by the second value.
• Use filter() with a lambda to keep only numbers greater than 20 from a list.

Mini Project / Task

Create a small contact list where each contact has a name and age, then use sorted() with a lambda to display the contacts ordered by age from youngest to oldest.

Challenge (Optional)

Given a list of dictionaries containing employee names, departments, and salaries, sort the list first by department and then by salary using a lambda as the sorting key.

Variable Scope

Variable scope defines where a variable can be accessed inside a Python program. It exists so programs remain organized, predictable, and easier to debug. Without scope rules, every variable would be visible everywhere, causing accidental overwrites and confusing behavior. In real applications, scope matters when writing functions, processing user input, tracking configuration values, building reusable modules, and avoiding conflicts between local data and global settings.

In Python, the main scope types are local, enclosing, global, and built-in. This is often remembered as LEGB. Local scope refers to variables created inside a function and usable only there. Enclosing scope appears in nested functions, where an inner function can read variables from its outer function. Global scope includes variables defined at the top level of a file. Built-in scope contains names Python already provides, such as len and print. Understanding how Python searches these scopes helps you predict which value is used when the same variable name appears in multiple places.

Step-by-Step Explanation

When Python sees a variable name, it searches in order: local, enclosing, global, then built-in.

1. If the variable is created inside a function, it belongs to that function unless declared otherwise.
2. If the function is nested, Python may use a variable from the outer function.
3. If no match is found, Python checks the global level.
4. Finally, Python checks built-in names.

A key rule for beginners: assigning to a variable inside a function creates a local variable by default. If you want to modify a global variable, use global. If you want to modify a variable from an enclosing function, use nonlocal.

Comprehensive Code Examples

Basic example

name = "Global Python"

def show_name():
    name = "Local Python"
    print(name)

show_name()
print(name)

This prints the local value inside the function and the global value outside it.

Real-world example

tax_rate = 0.18

def calculate_total(price):
    total = price + (price * tax_rate)
    return total

print(calculate_total(100))

Here, total is local, while tax_rate is global and readable inside the function.

Advanced usage

def counter():
    count = 0

    def increment():
        nonlocal count
        count += 1
        return count

    return increment

click = counter()
print(click())
print(click())

This uses enclosing scope. The inner function updates count with nonlocal.

score = 10

def update_score():
    global score
    score += 5

update_score()
print(score)

This modifies a global variable directly. It works, but should be used carefully.

Common Mistakes

• Assuming a function can modify globals automatically: assigning inside a function creates a local variable unless global is used.
• Using the same variable name everywhere: this causes confusion. Use descriptive names to avoid shadowing.
• Forgetting nonlocal in nested functions: without it, reassignment creates a new local variable in the inner function.
• Overwriting built-ins: naming a variable list or print can break expected behavior.

Best Practices

• Prefer local variables whenever possible because they are safer and easier to test.
• Use global variables sparingly, mainly for constants or configuration values.
• Use nonlocal only when nested state is truly needed.
• Choose clear variable names to reduce scope-related bugs.
• Keep functions small so scope stays easy to understand.

Practice Exercises

• Create a global variable called language and print it inside and outside a function.
• Write a nested function where the inner function reads a variable from the outer function.
• Build a counter function that uses nonlocal to increase a value each time it is called.

Mini Project / Task

Create a simple visitor tracker. Use a function that returns another function, and each time the inner function runs, it should increase and display the visitor count using enclosing scope.

Challenge (Optional)

Write a program with a global setting, a nested function, and a local variable that all use different names. Then modify the program so one version reads values only, and another version updates the enclosing value with nonlocal. Observe how Python resolves each name.

Lists

A list in Python is an ordered, changeable collection that can store multiple values in a single variable. Lists exist because programs often need to manage groups of related items, such as product names, user scores, messages, or task items. In real applications, lists are used for shopping carts, search results, report data, API responses, and batches of records pulled from databases. Python lists are flexible because they can hold strings, numbers, booleans, and even other lists. They are also dynamic, which means you can add, remove, and update items after creation.

Lists are written with square brackets. Each value inside a list is called an element, and every element has an index position starting at 0. This indexing system makes it easy to retrieve or replace specific items. Lists also support negative indexing, so -1 refers to the last item. Another useful feature is slicing, which allows you to extract a range of items. Python developers rely on lists heavily because they are simple for beginners yet powerful enough for professional software development.

A list may contain mixed data types, but in well-designed programs, lists usually store related values of the same kind for clarity. Common operations include creating a list, checking its length, looping through items, appending new values, inserting values at a position, removing values, and sorting content. Python also provides useful list methods such as append(), insert(), remove(), pop(), sort(), and reverse().

Conceptually, lists can be understood in a few common forms: empty lists for collecting future data, flat lists for simple sequences, nested lists for grouped data, and lists used as stacks or queues in simple algorithms. Knowing these patterns helps learners understand why lists are one of the first tools taught in Python. Once you understand lists, you can model collections of data far more effectively and prepare for topics like loops, functions, file handling, and data structures.

Step-by-Step Explanation

To create a list, place values inside square brackets separated by commas, such as fruits = ['apple', 'banana', 'mango']. Access items by index using square brackets, for example fruits[0] gives the first item. Update an item by assigning a new value to an index, like fruits[1] = 'orange'. Add an item to the end with append() and insert at a specific position with insert(). Remove items using remove() for a value or pop() for an index. Use len(list_name) to get the number of items. To loop through a list, use a for loop. To get part of a list, use slicing like fruits[0:2].

Comprehensive Code Examples

Basic example

numbers = [10, 20, 30, 40]
print(numbers)
print(numbers[0])
numbers.append(50)
print(numbers)

Real-world example

tasks = ['reply to email', 'write report', 'join meeting']
print('Today\'s tasks:')
for task in tasks:
    print('-', task)

tasks.append('review code')
tasks.remove('join meeting')
print(tasks)

Advanced usage

grades = [88, 95, 70, 100, 82]
highest = max(grades)
lowest = min(grades)
average = sum(grades) / len(grades)
passed = [grade for grade in grades if grade >= 75]
print(highest, lowest, average)
print(passed)

Common Mistakes

• Using index 1 for the first item: Python starts indexing at 0. Use my_list[0] for the first element.
• Accessing an index that does not exist: Check list length with len() before using an index.
• Confusing remove() and pop(): remove() deletes by value, while pop() deletes by index and can return the removed item.
• Forgetting lists are mutable: Changes affect the original list, so be careful when passing lists between functions.

Best Practices

• Use meaningful variable names such as student_scores or cart_items.
• Store similar data types together whenever possible for readability and easier processing.
• Use loops and built-in functions like len(), sum(), and max() instead of manual repetition.
• Use slicing carefully to avoid off-by-one errors.
• When copying a list, use methods like copy() if you do not want to modify the original.

Practice Exercises

• Create a list of five favorite movies and print the first and last items.
• Make a list of numbers, add two new numbers, remove one number, and print the final list.
• Create a list of student names and use a loop to print each name on a separate line.

Mini Project / Task

Build a simple shopping list manager that starts with three grocery items, allows adding one new item, removing one purchased item, and then prints the updated list and total number of remaining items.

Challenge (Optional)

Create a program that stores a list of numbers and prints a new list containing only the even values, without changing the original list.

Tuples

A tuple in Python is an ordered collection of items that is usually used when you want related values to stay together without being changed accidentally. Unlike lists, tuples are immutable, which means their contents cannot be modified after creation. This makes them useful for storing fixed data such as geographic coordinates, RGB color values, database records, days of the week, and function return values. In real applications, tuples are often used when data should remain stable, when you want to return multiple values from a function, or when you need a hashable collection that can be used as a dictionary key. Python tuples can store different data types in the same structure, such as strings, numbers, and even other tuples. A tuple is created by separating values with commas, usually inside parentheses. There are several common forms to understand: an empty tuple, a single-item tuple, and tuples with multiple items. A single-item tuple is a frequent beginner trap because it requires a trailing comma, such as (5,). Without the comma, Python treats it as a normal value inside parentheses. Tuples also support indexing, slicing, iteration, packing, and unpacking. Packing means placing multiple values into one tuple, while unpacking means assigning tuple items into separate variables. This is widely used in clean Python code because it makes assignments short and readable. Tuples also allow nested structures, so you can have tuples inside tuples for grouped records. Although tuples are immutable, they may contain mutable objects like lists, which can still change internally. That detail is important when reasoning about program behavior.

Step-by-Step Explanation

To create a tuple, write values separated by commas, such as (1, 2, 3). Access items using indexes starting from 0. For example, index 0 gives the first item. Negative indexes work from the end, so -1 gives the last item. You can extract part of a tuple using slicing, such as numbers[1:3]. Since tuples cannot be changed, methods like append or remove do not exist. However, you can combine tuples using + and repeat them using *. Packing happens automatically when you write point = 10, 20. Unpacking works like x, y = point. The number of variables must match the number of items unless you use starred unpacking like a, *middle, b = values.

Comprehensive Code Examples

# Basic example
colors = ("red", "green", "blue")
print(colors)
print(colors[0])
print(colors[-1])

# Real-world example
location = ("New York", 40.7128, -74.0060)
city, latitude, longitude = location
print(f"City: {city}")
print(f"Latitude: {latitude}, Longitude: {longitude}")

# Advanced usage
students = (
    ("Ava", 85, 90),
    ("Liam", 78, 88),
    ("Noah", 92, 95)
)

for name, test1, test2 in students:
    average = (test1 + test2) / 2
    print(name, average)

data = (1, 2, 3, 4, 5)
first, *middle, last = data
print(first)
print(middle)
print(last)

Common Mistakes

• Forgetting the comma in a single-item tuple: (5) is not a tuple. Use (5,).
• Trying to modify a tuple directly: values[0] = 10 causes an error. Create a new tuple instead.
• Using list methods on tuples: Tuples do not support append() or remove(). Convert to a list if changes are needed.
• Unpacking into the wrong number of variables: Make sure variable count matches tuple items, or use starred unpacking.

Best Practices

• Use tuples for fixed collections that should not change during program execution.
• Choose tuples for coordinates, settings, and records that have a consistent structure.
• Use unpacking to make code cleaner and easier to read.
• Prefer meaningful variable names when unpacking tuple values.
• If data must change often, use a list instead of forcing tuple workarounds.

Practice Exercises

• Create a tuple with five favorite foods and print the first and last items.
• Make a tuple containing a city name, country, and population, then unpack and print each value.
• Create a tuple of numbers and print a slice containing the middle three items.

Mini Project / Task

Build a small program that stores three student records as tuples. Each record should contain the student name and two marks. Loop through the records, calculate each student's average, and print the results clearly.

Challenge (Optional)

Create a program that stores coordinate tuples for several points and finds which point has the largest x-value without modifying the original tuple collection.

Sets

A set in Python is an unordered collection of unique items. It exists to help developers store values without duplicates and perform fast membership testing such as checking whether an item already exists. Sets are widely used in real applications like removing duplicate email addresses, tracking unique website visitors, comparing lists of permissions, filtering repeated tags, and finding common values between datasets. Unlike lists, sets do not keep insertion order as a feature you should rely on for logic, and they do not allow duplicate elements. Python provides the built-in set type and also frozenset, which is an immutable version of a set. A regular set can be changed after creation by adding or removing items, while a frozenset cannot be modified and is useful when you need a hashable set-like object, such as using it as a dictionary key. Sets support mathematical operations including union, intersection, difference, and symmetric difference. These operations make them powerful for comparing groups of values in a clear and efficient way. Because sets are implemented for fast lookup, checking item in my_set is usually much faster than searching in a long list. Sets can contain immutable values like integers, strings, and tuples, but not mutable items like lists or dictionaries. Understanding sets is important because they solve common data-cleaning and comparison problems with very little code.

Step-by-Step Explanation

You can create a set using curly braces like {1, 2, 3} or by calling set(). Use set() for an empty set because {} creates an empty dictionary. Add one item with add(), add many items with update(), remove an item with remove() or discard(), and clear everything with clear(). Use remove() when the item must exist because it raises an error if missing. Use discard() when you want safer removal without an error. To combine sets, use | for union. To get common items, use & for intersection. To get items in one set but not another, use -. To get items that appear in either set but not both, use ^. You can also test subset and superset relationships with methods like issubset() and issuperset().

Comprehensive Code Examples

numbers = {1, 2, 2, 3, 4}
print(numbers)  # duplicates are removed
numbers.add(5)
print(3 in numbers)

emails = ['[email protected]', '[email protected]', '[email protected]', '[email protected]']
unique_emails = set(emails)
print(unique_emails)

team_a = {'Ana', 'Ben', 'Cara'}
team_b = {'Ben', 'Cara', 'Dan'}

print(team_a | team_b)   # union
print(team_a & team_b)   # intersection
print(team_a - team_b)   # difference
print(team_a ^ team_b)   # symmetric difference

frozen = frozenset(['read', 'write'])
print(frozen)

Common Mistakes

• Using {} for an empty set. Fix: use set().

• Trying to store lists inside a set. Fix: use tuples or other immutable values.

• Using remove() when the item may not exist. Fix: use discard() for safer code.

• Expecting a set to preserve display order for program logic. Fix: treat sets as unordered collections.

Best Practices

• Use sets when uniqueness matters more than order.

• Convert lists to sets for fast duplicate removal and membership checks.

• Use set operators like & and | to write clearer comparison logic.

• Choose frozenset when you need an immutable set.

Practice Exercises

• Create a set of five numbers and add two more values to it.

• Given a list with repeated names, convert it into a set and print only the unique names.

• Create two sets of favorite fruits and print their union, intersection, and difference.

Mini Project / Task

Build a small program that receives a list of website visitor usernames and prints the unique visitors along with the total number of unique accounts.

Challenge (Optional)

Create a program that compares two course enrollment lists and shows students who are in both courses, only in the first course, and only in the second course.

Dictionaries

A dictionary in Python is a built-in data structure that stores data as key-value pairs. Instead of using numeric positions like lists, dictionaries let you access values by meaningful names such as name, price, or email. This makes them ideal for representing structured information such as user profiles, product records, configuration settings, API responses, and counters. In real applications, dictionaries are everywhere: a web app may store request data in a dictionary, a game may track player stats with named fields, and a data script may group values by category. Python dictionaries are mutable, which means you can add, update, or remove entries after creation. They are also optimized for fast lookup by key, which is one reason they are so popular. A dictionary is written with curly braces and uses a colon between each key and value. Keys must be unique and should be immutable types such as strings, integers, or tuples. Values can be almost any Python object, including lists, other dictionaries, numbers, and strings. Common operations include reading a value with a key, checking whether a key exists, looping through keys and values, and safely retrieving missing keys with methods like get(). You will also use methods such as keys(), values(), items(), update(), and pop(). Dictionaries can act like simple records, lookup tables, frequency maps, and nested data containers. For example, one dictionary may represent a student, while a larger dictionary maps student IDs to student records. Understanding dictionaries is essential because they bridge simple variables and more realistic data modeling. They allow your programs to become more expressive, maintainable, and closer to how information is organized in the real world.

Step-by-Step Explanation

Create a dictionary using curly braces: student = {"name": "Ava", "age": 20}. Access a value by key using square brackets: student["name"]. Add or update a value by assignment: student["grade"] = "A" or student["age"] = 21. To avoid errors when a key might not exist, use student.get("email"). Check for existence with "name" in student. Loop through keys with for key in student:, through values with student.values(), and through pairs with student.items(). Remove entries with pop() or del. Nested dictionaries let you organize complex data, such as a user dictionary containing an address dictionary.

Comprehensive Code Examples

# Basic example
person = {"name": "Lina", "city": "Cairo", "age": 28}
print(person["name"])
person["age"] = 29
person["job"] = "Developer"
print(person)

# Real-world example: inventory item
product = {
    "id": 101,
    "name": "Keyboard",
    "price": 49.99,
    "stock": 12
}

if product["stock"] > 0:
    print(product["name"], "is available")

product["stock"] -= 1
print(product)

# Advanced usage: counting word frequency
text = ["python", "code", "python", "data", "code", "python"]
counts = {}

for word in text:
    counts[word] = counts.get(word, 0) + 1

for word, total in counts.items():
    print(word, total)

# Nested dictionary example
user = {
    "username": "sam_dev",
    "contact": {
        "email": "[email protected]",
        "phone": "123-456"
    }
}

print(user["contact"]["email"])

Common Mistakes

• Using a missing key with square brackets: data["email"] raises an error if the key does not exist. Fix: use data.get("email") when unsure.
• Assuming keys can repeat: duplicate keys overwrite earlier values. Fix: ensure each key is unique.
• Using mutable objects as keys: lists cannot be dictionary keys. Fix: use strings, integers, or tuples instead.
• Confusing keys and values in loops: looping over a dictionary returns keys by default. Fix: use items() when you need both.

Best Practices

• Use clear, descriptive string keys such as "first_name" instead of vague names.
• Use get() for safer reads when keys may be optional.
• Keep dictionary structures consistent across similar records.
• Use nested dictionaries carefully and document expected structure in larger projects.
• Choose dictionaries when named lookup matters more than order by position.

Practice Exercises

• Create a dictionary for a book with keys for title, author, and year. Print each value.
• Write a program that adds a new key called price to an existing product dictionary, then updates it.
• Count how many times each number appears in a list using a dictionary.

Mini Project / Task

Build a simple contact book using a dictionary where the key is a person's name and the value is their phone number. Allow adding contacts, updating a number, and printing all contacts.

Challenge (Optional)

Create a nested dictionary for three students, each with marks in three subjects, then calculate and print the average mark for each student.

List Comprehensions

List comprehensions in Python provide a concise and elegant way to create lists. They offer a more readable and often faster alternative to traditional loops for generating lists based on existing iterables. The core idea is to combine the loop and the conditional logic (if any) that defines the list elements into a single line of code. This powerful feature was introduced in Python 2.0 and has since become a fundamental tool for Python developers, promoting more Pythonic and efficient code.

The primary motivation behind list comprehensions is to simplify common list creation patterns. Instead of initializing an empty list, then looping through an iterable, performing some operation, and finally appending the result to the list, a list comprehension allows you to do all of this in one expression. This not only reduces the number of lines of code but also often improves performance because the interpreter can optimize the list creation process more effectively than with explicit loops and appends. They are widely used in data processing, algorithm implementation, and any scenario where you need to transform or filter collections of data.

Step-by-Step Explanation

The basic syntax for a list comprehension is:
[expression for item in iterable if condition]

Let's break down each part:

• Expression: This is the element that will be added to the new list. It can be a variable, a function call, or any valid Python expression.
• Item: This is the variable that takes on each value from the iterable in turn. It's similar to the loop variable in a for loop.
• Iterable: This is any object that can be iterated over (e.g., a list, tuple, string, range, etc.).
• Condition (Optional): This is an optional filter. If present, only items for which the condition evaluates to True will be included in the new list.

The flow is as follows: The comprehension iterates through each item in the iterable. For each item, it checks if the optional condition is met. If there is no condition, or if the condition is True, the expression (which often uses the item) is evaluated, and its result is added to the new list.

Comprehensive Code Examples

Basic example: Creating a list of squares

# Using a traditional loop
squares = []
for i in range(1, 6):
    squares.append(i**2)
print(squares)  # Output: [1, 4, 9, 16, 25]

# Using a list comprehension
squares_comp = [i**2 for i in range(1, 6)]
print(squares_comp) # Output: [1, 4, 9, 16, 25]

Real-world example: Filtering data from a list of dictionaries

products = [
    {'name': 'Laptop', 'price': 1200, 'category': 'Electronics'},
    {'name': 'Desk Chair', 'price': 300, 'category': 'Furniture'},
    {'name': 'Monitor', 'price': 400, 'category': 'Electronics'},
    {'name': 'Keyboard', 'price': 75, 'category': 'Electronics'},
    {'name': 'Bookshelf', 'price': 150, 'category': 'Furniture'}
]

# Get names of electronics products under $500
affordable_electronics = [product['name'] for product in products 
                          if product['category'] == 'Electronics' and product['price'] < 500]
print(affordable_electronics) # Output: ['Monitor', 'Keyboard']

Advanced usage: Nested list comprehensions for matrix flattening

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Flatten the matrix into a single list
flattened_list = [num for row in matrix for num in row]
print(flattened_list) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Nested list comprehension with condition
even_numbers_in_matrix = [num for row in matrix for num in row if num % 2 == 0]
print(even_numbers_in_matrix) # Output: [2, 4, 6, 8]

Common Mistakes

• Over-complicating: Trying to do too much in one comprehension, leading to unreadable code. Fix: If the logic becomes too complex, revert to a traditional for loop for better clarity.
• Forgetting brackets: Accidentally using parentheses () instead of square brackets [], which creates a generator expression instead of a list. Fix: Always use [] for list comprehensions.
• Side effects: Using expressions with side effects (like modifying external variables) within a list comprehension. Fix: List comprehensions are for creating new lists based on transformations; avoid side effects.

Best Practices

• Readability over brevity: While comprehensions are concise, prioritize readability. If a comprehension becomes too long or complex, split it into multiple lines or use a traditional loop.
• Use for transformations and filtering: They excel at creating new lists by transforming elements or filtering them based on conditions.
• Avoid nested comprehensions beyond two levels: Deeply nested comprehensions can be hard to read and debug. Consider helper functions or traditional loops for three or more levels of nesting.
• Profile for performance: While often faster, always profile your code if performance is critical, as sometimes a well-optimized loop can be competitive or even better for specific scenarios.

Practice Exercises

• Exercise 1: Create a list of all even numbers from 0 to 20 (inclusive) using a list comprehension.
• Exercise 2: Given a list of words ['apple', 'banana', 'cherry', 'date'], create a new list containing only words that have more than 5 characters.
• Exercise 3: Convert a list of temperatures in Celsius [0, 10, 20, 30] to Fahrenheit using the formula F = (C * 9/5) + 32.

Mini Project / Task

Write a Python script that takes a list of strings representing file names (e.g., ['report.pdf', 'image.jpg', 'data.csv', 'document.docx']) and uses a list comprehension to create a new list containing only the filenames that end with .pdf or .csv. The new list should contain only the base filename (e.g., 'report', 'data') without the extension.

Challenge (Optional)

Given a list of sentences, use a list comprehension to create a new list where each element is a list of words from the original sentence, but only include words that are longer than 3 characters and convert them to uppercase. For example, for ['Hello world', 'Python is great'], the output should be [['HELLO', 'WORLD'], ['PYTHON', 'GREAT']].

Dictionary Comprehensions

Dictionary comprehensions are a compact way to create dictionaries in Python using a single readable expression. Instead of writing a loop, creating an empty dictionary, and filling it one key-value pair at a time, you can build the whole mapping in one statement. They exist to make dictionary creation faster, cleaner, and easier to understand when the transformation is simple. In real projects, developers use them for tasks such as converting lists into lookup tables, formatting API data, inverting mappings, filtering records, and generating configuration dictionaries. A dictionary comprehension usually follows the pattern {key_expression: value_expression for item in iterable}. You can also add conditions, such as {k: v for k, v in data if condition}, to include only selected items. Common sub-types include basic creation, transformation of existing dictionaries, filtering items, and nested dictionary comprehensions. These are not separate Python features, but common usage patterns you will see often in production code.

Step-by-Step Explanation

Start with curly braces because the result is a dictionary. Inside the braces, write the expression for the key, then a colon, then the expression for the value. After that, add a for clause to describe where the data comes from. Example structure: {key: value for item in iterable}. If your iterable contains pairs, you can unpack them directly: {k: v for k, v in pairs}. To filter results, append an if condition: {k: v for k, v in pairs if v > 10}. Python evaluates the loop for each item, computes the key and value, and stores them in the new dictionary. If the same key appears more than once, the last value wins. This is important when generating keys from transformed data. Dictionary comprehensions are best when the logic is short and clear. If the expression becomes too complex, a normal loop may be easier to read and maintain.

Comprehensive Code Examples

Basic example

numbers = [1, 2, 3, 4, 5]
squares = {n: n ** 2 for n in numbers}
print(squares)
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Real-world example

products = {
    "laptop": 1200,
    "mouse": 25,
    "keyboard": 75,
    "monitor": 220
}

discounted_prices = {name: price * 0.9 for name, price in products.items() if price >= 50}
print(discounted_prices)

Advanced usage

students = [
    {"name": "Ava", "score": 88},
    {"name": "Leo", "score": 92},
    {"name": "Mia", "score": 76}
]

grade_map = {
    student["name"]: ("Pass" if student["score"] >= 80 else "Review")
    for student in students
}

print(grade_map)

Common Mistakes

• Forgetting the colon between key and value: Write {k: v for ...}, not {k, v for ...}.
• Using duplicate keys accidentally: If transformed keys repeat, earlier values are overwritten. Check key uniqueness before building the dictionary.
• Making the comprehension too complex: Long nested logic hurts readability. Move complicated logic into a loop or helper function.
• Confusing list and dictionary comprehensions: Square brackets create lists, curly braces with key: value create dictionaries.

Best Practices

• Use dictionary comprehensions for short, clear transformations.
• Prefer meaningful variable names such as name, price, or student instead of single letters when clarity matters.
• Use .items() when iterating through an existing dictionary’s keys and values.
• Add filtering with if only when it improves clarity and avoids extra code.
• Switch to a normal loop if the expression contains heavy nesting, many conditions, or business rules.

Practice Exercises

• Create a dictionary where numbers from 1 to 10 are keys and their cubes are values.
• Given a dictionary of employee names and salaries, create a new dictionary containing only salaries above 50000.
• Given a list of words, build a dictionary where each word is the key and its length is the value.

Mini Project / Task

Create a student result summary. Given a dictionary of student names and marks, use a dictionary comprehension to produce a new dictionary where each student is labeled as "Pass" if the mark is 50 or above, otherwise "Fail".

Challenge (Optional)

Given a sentence, build a dictionary comprehension that counts the length of each unique word after converting all words to lowercase and removing simple punctuation.

String Formatting

String formatting is the process of building readable text by inserting values into a string. In Python, it exists so programs can create dynamic messages instead of hard-coded text. For example, apps use string formatting to show usernames, prices, dates, reports, logs, invoices, and error messages. If a shopping app needs to display a message like "Hello, Aisha. Your total is $49.99", string formatting makes that easy and organized.

Python supports several ways to format strings. Older code may use the % operator. A more structured approach uses the str.format() method. Modern Python most commonly uses f-strings, written with an f before the string. F-strings are popular because they are clear, short, and fast to read. Formatting can also control width, alignment, decimal places, and number separators, which is useful in reports and user interfaces.

When formatting strings, the main idea is simple: combine plain text with variable values. You can insert numbers, strings, expressions, and even formatting rules inside placeholders. This helps produce professional output and avoids messy manual concatenation.

Step-by-Step Explanation

Start with variables that hold data you want to display. Then choose a formatting style.

With the % operator, placeholders such as %s for strings and %d for integers are placed inside the text. Python replaces them with values.

With str.format(), use braces {} as placeholders. Values are passed after the string using .format(...). You can also number placeholders or give them names.

With f-strings, place variables or expressions directly inside braces. Example: f"Hello, {name}". This is often the easiest option for beginners.

You can also format numbers. For example, {price:.2f} shows two decimal places, and {value:,} adds commas for thousands. Alignment is also possible, such as left, right, or center within a fixed width.

Comprehensive Code Examples

Basic example

name = "Mina"
age = 22

print(f"My name is {name} and I am {age} years old.")

Real-world example

customer = "David"
product = "Wireless Mouse"
price = 24.5

message = f"Customer: {customer} | Product: {product} | Price: ${price:.2f}"
print(message)

Advanced usage

item = "Laptop"
quantity = 3
unit_price = 899.99
total = quantity * unit_price

print(f"Item: {item:<10} Quantity: {quantity:^5} Total: ${total:,.2f}")

score = 87.4567
print("Formatted score: {:.1f}".format(score))

name = "Lina"
tasks = 5
print("%s completed %d tasks today." % (name, tasks))

Common Mistakes

• Forgetting the f in an f-string: Writing "Hello {name}" prints braces literally. Fix it with f"Hello {name}".
• Mixing data types badly with concatenation: "Age: " + 20 causes an error. Fix it with f"Age: {20}" or "Age: " + str(20).
• Using the wrong format specifier: Using integer formatting for text or decimals incorrectly can break output. Match the value type to the formatting rule.
• Mismatched placeholder count: In .format() or % formatting, too few or too many values cause errors. Make sure every placeholder gets the correct value.

Best Practices

• Prefer f-strings in modern Python because they are readable and concise.
• Use formatting specifiers for money, percentages, and tables to keep output clean.
• Choose meaningful variable names so formatted messages are easy to understand.
• Avoid overly complex expressions inside f-strings; calculate first, then format.
• Keep output user-friendly by adding labels, spacing, and consistent decimal formatting.

Practice Exercises

• Create variables for a person's name, city, and age, then print a sentence using an f-string.
• Store a product name and price, then print the price with exactly two decimal places.
• Create a small report line that shows an item name left-aligned and a quantity right-aligned.

Mini Project / Task

Build a receipt formatter that stores a customer name, three product prices, and prints a summary showing the customer, subtotal, tax, and final total with two decimal places.

Challenge (Optional)

Create a formatted scoreboard that displays three player names and scores in aligned columns, sorted from highest to lowest score.

Working with Files Reading

Working with files is a fundamental aspect of almost any programming language, and Python makes it incredibly straightforward and powerful. Reading from files allows your programs to ingest data from external sources, whether it's configuration settings, user-generated content, logs, or vast datasets. This capability is crucial for building applications that can persist data, process information that changes over time, or interact with other systems. For instance, a web server might read HTML templates from files, a data analysis script might load a CSV file, or a game could retrieve saved player progress. Without the ability to read files, programs would be limited to data generated during their execution, severely restricting their utility and real-world applicability.

Python's approach to file handling is designed to be intuitive, using built-in functions and methods that abstract away the complexities of operating system interactions. This section will focus specifically on reading operations, covering various techniques to access and process content from text files.

Step-by-Step Explanation

The primary way to open a file in Python is using the built-in open() function. This function returns a file object, which then has methods for reading its content. The basic syntax is open(filename, mode). For reading, the mode is typically 'r' (read), or 'rt' (read text, explicitly for text files, which is the default).

Once you have a file object, you can use several methods to read data:

• .read(): Reads the entire content of the file as a single string. You can optionally pass an integer argument to read only a specified number of characters.
• .readline(): Reads one line from the file at a time. Each call to readline() advances the file pointer to the next line.
• .readlines(): Reads all lines from the file and returns them as a list of strings, where each string represents a line including the newline character (\n).
• Iterating directly over the file object: This is often the most memory-efficient and Pythonic way to read files line by line, especially for large files.

It is absolutely critical to close files after you are done with them to free up system resources and ensure data integrity. The .close() method is used for this. However, the most recommended and Pythonic way to handle file operations is using the with statement. The with statement ensures that the file is automatically closed, even if errors occur during file processing.

Comprehensive Code Examples

Basic example: Reading the entire file

# Assuming 'example.txt' exists with some content
# Create a dummy file for demonstration
with open('example.txt', 'w') as f:
    f.write('Line 1: Hello Python!
')
    f.write('Line 2: File handling is fun.
')
    f.write('Line 3: End of file.')

try:
    with open('example.txt', 'r') as file:
        content = file.read()
        print('--- Entire content ---')
        print(content)
except FileNotFoundError:
    print('Error: The file example.txt was not found.')

Real-world example: Reading configuration from a file line by line

# Imagine 'config.ini' contains settings like:
# database_host=localhost
# database_port=5432
# username=admin

with open('config.ini', 'w') as f:
    f.write('database_host=localhost
')
    f.write('database_port=5432
')
    f.write('username=admin
')

config = {}
try:
    with open('config.ini', 'r') as file:
        for line in file:
            line = line.strip() # Remove leading/trailing whitespace, including newline
            if line and '=' in line: # Ensure line is not empty and contains an '='
                key, value = line.split('=', 1) # Split only on the first '='
                config[key.strip()] = value.strip()
    print('
--- Configuration loaded ---')
    print(config)
    print(f'Database Host: {config.get("database_host")}')
except FileNotFoundError:
    print('Error: config.ini not found.')

Advanced usage: Reading specific number of characters and handling large files efficiently

# Let's create a larger dummy file
with open('large_data.txt', 'w') as f:
    for i in range(100):
        f.write(f'Data line number {i+1}
')

print('
--- Reading in chunks ---')
try:
    with open('large_data.txt', 'r') as file:
        # Read first 10 characters
        partial_content = file.read(10)
        print(f'First 10 chars: "{partial_content}"')

        # Read the next 20 characters
        next_partial_content = file.read(20)
        print(f'Next 20 chars: "{next_partial_content}"')

        # Efficiently reading line by line (best for large files)
        print('
--- Reading line by line efficiently ---')
        line_count = 0
        for line in file:
            print(f'Line {line_count+1}: {line.strip()}')
            line_count += 1
            if line_count >= 3: # Just print first 3 lines after initial read
                break
except FileNotFoundError:
    print('Error: large_data.txt not found.')

Common Mistakes

• Forgetting to close the file: This can lead to resource leaks, data corruption, or files remaining locked, preventing other programs from accessing them. Always use with open(...) to ensure automatic closing.
• Not handling FileNotFoundError: If your program tries to open a file that doesn't exist, it will crash with a FileNotFoundError. Always wrap file opening in a try-except block.
• Reading the entire file into memory for large files: Using .read() or .readlines() on a very large file can consume excessive memory, potentially crashing your program. Iterate over the file object directly (for line in file:) for memory efficiency.

Best Practices

• Always use the with statement: This is the most Pythonic and safest way to handle files, as it guarantees the file is properly closed even if errors occur.
• Specify the mode explicitly: Even though 'r' is the default for open(), explicitly stating 'r' or 'rt' makes your code clearer.
• Handle potential exceptions: Use try-except FileNotFoundError to gracefully handle cases where the file might not exist. Consider other exceptions like IOError for broader error handling.
• Strip whitespace from lines: When reading line by line, lines often include the newline character (\n). Use line.strip() to remove this and any other leading/trailing whitespace.
• Use appropriate reading methods: Choose .read() for small files, .readline() for specific line-by-line processing, and iteration (for line in file:) for large files or general line-by-line processing.

Practice Exercises

• Exercise 1 (Beginner): Create a text file named quotes.txt with at least three famous quotes, each on a new line. Write a Python program that opens this file, reads its entire content, and prints it to the console.
• Exercise 2: Modify the program from Exercise 1 to read quotes.txt line by line and print each quote, prepending its line number (e.g., '1: ').
• Exercise 3: Write a program that reads a file named numbers.txt (which you should create with one number per line, e.g., 5, 12, 3, 8). Calculate the sum of all numbers in the file and print the total.

Mini Project / Task

Create a simple 'Log File Analyzer'.
1. Create a file named app_log.txt. Populate it with several lines of text, some of which should contain the word 'ERROR' and some 'WARNING'.
2. Write a Python script that reads app_log.txt.
3. Count how many lines contain the word 'ERROR' (case-sensitive).
4. Count how many lines contain the word 'WARNING' (case-sensitive).
5. Print the total count for errors and warnings.

Challenge (Optional)

Extend the 'Log File Analyzer' mini-project. Instead of just counting, create two new files: errors.log and warnings.log. The script should now read app_log.txt, and for each line containing 'ERROR', write that line to errors.log. Similarly, for lines containing 'WARNING', write them to warnings.log. Ensure that if these output files already exist, the new lines are appended, not overwritten.

Working with Files Writing

Writing files in Python means sending data from your program into a file stored on disk. This is important because many programs need to save information permanently instead of keeping it only in memory while the program runs. Real-life examples include saving user reports, creating log files, exporting results, generating text documents, and storing configuration values. Python makes file writing simple through the built-in open() function and file methods such as write() and writelines().

When writing files, the main file modes are important. w creates a new file or overwrites an existing one. a appends data to the end of an existing file without deleting old content. x creates a file only if it does not already exist. You may also see text mode, which is default, and binary mode using b for non-text data. For most beginner tasks, text mode is enough.

Step-by-Step Explanation

To write to a file, first call open(filename, mode). This returns a file object. Then use a writing method, and finally close the file. A safer and more professional approach is using a with statement, because Python automatically closes the file even if an error happens.

Basic syntax: open the file with a mode like w or a, write strings into it, and let the file close properly. Remember that write() only accepts strings in text mode, so numbers must be converted using str(). Also note that Python does not add a new line automatically, so use \n when needed.

Comprehensive Code Examples

Basic example

with open("notes.txt", "w") as file:
    file.write("Hello, Python file writing!\n")
    file.write("This is the second line.")

Real-world example

products = [
    ("Laptop", 1200),
    ("Mouse", 25),
    ("Keyboard", 75)
]

with open("sales_report.txt", "w") as file:
    file.write("Sales Report\n")
    file.write("------------\n")
    for name, price in products:
        file.write(f"{name}: ${price}\n")

Advanced usage

log_entries = [
    "Application started\n",
    "User logged in\n",
    "Data exported successfully\n"
]

with open("app.log", "a", encoding="utf-8") as file:
    file.writelines(log_entries)
    file.write("Session ended\n")

In the first example, the file is overwritten and fresh content is saved. In the second, structured business data is written into a readable report. In the third, append mode is used for logging so previous entries remain intact.

Common Mistakes

• Using w when you meant a: w erases old content. Use a to add new data safely.
• Forgetting newline characters: write() does not move to the next line automatically. Add \n where needed.
• Writing non-string values directly: convert integers, floats, or other objects using str() or f-strings.
• Not closing files properly: use with open(...) as file: to avoid resource leaks.

Best Practices

• Use the with statement for automatic file closing.
• Set encoding="utf-8" when working with text files for consistency.
• Choose the correct mode carefully: w for replace, a for append, x for safe creation.
• Use descriptive file names such as report.txt or error_log.txt.
• Keep file-writing code organized and avoid hardcoding too many paths in large programs.

Practice Exercises

• Create a file named welcome.txt and write three lines of text into it.
• Ask the user for their name and favorite color, then save both values in a file named profile.txt.
• Create a list of five tasks and write them into a file named tasks.txt, one task per line.

Mini Project / Task

Build a simple daily journal writer that asks the user for today's date and a short journal entry, then appends the result to a file named journal.txt.

Challenge (Optional)

Create a program that stores student names and scores in a text file, formatting each line neatly as Name - Score, and make sure new records are added without deleting old ones.

Exception Handling

Exception handling is the process of detecting and managing errors that happen while a program is running. In Python, these runtime errors are called exceptions. Instead of letting a program crash unexpectedly, exception handling allows you to respond gracefully, show useful messages, recover when possible, or stop safely. This matters in real applications because users may enter invalid data, files may be missing, network requests may fail, or conversions may not work as expected.

Python uses the try, except, else, and finally keywords to manage exceptions. The try block contains code that might fail. The except block handles a specific error. The else block runs only if no exception occurs. The finally block runs whether an error happens or not, which makes it useful for cleanup tasks such as closing files or connections.

Python also allows you to raise exceptions manually with raise when input or program state is invalid. Common built-in exceptions include ValueError, TypeError, ZeroDivisionError, FileNotFoundError, and IndexError. You can even define custom exception classes for application-specific problems. In real life, exception handling is used in login systems, file upload tools, data processing scripts, web APIs, payment flows, and automation jobs where reliability is important.

Step-by-Step Explanation

Start with a try block around code that may fail. Add one or more except blocks to catch expected errors. Catch the most specific exception types possible. Optionally use else for code that should run only when the try succeeds. Use finally for cleanup tasks. The basic pattern is: place risky code in try, handle known problems in except, and avoid hiding unexpected bugs with broad exception handling unless you log or re-raise them.

If you want to signal an error yourself, use raise. For example, if a function receives a negative age, you may raise a ValueError. This makes your code clearer and easier to debug.

Comprehensive Code Examples

Basic example

try:
    number = int(input("Enter a number: "))
    result = 10 / number
    print(result)
except ValueError:
    print("Please enter a valid integer.")
except ZeroDivisionError:
    print("You cannot divide by zero.")

Real-world example

try:
    with open("customers.txt", "r") as file:
        data = file.read()
except FileNotFoundError:
    print("The file was not found.")
else:
    print("File loaded successfully.")
    print(data)
finally:
    print("File operation finished.")

Advanced usage

class InvalidAgeError(Exception):
    pass

def register_user(name, age):
    if not name:
        raise ValueError("Name cannot be empty.")
    if age < 0:
        raise InvalidAgeError("Age cannot be negative.")
    return f"User {name} registered."

try:
    print(register_user("Asha", -2))
except InvalidAgeError as e:
    print(f"Custom error: {e}")
except ValueError as e:
    print(f"Input error: {e}")

Common Mistakes

• Using a bare except: This catches every error and can hide bugs. Fix it by catching specific exceptions such as ValueError or FileNotFoundError.
• Putting too much code inside try: This makes debugging harder. Fix it by wrapping only the statements that may fail.
• Ignoring exceptions silently: Writing empty handlers can lose important information. Fix it by printing, logging, or re-raising the error when needed.
• Using finally for normal logic: finally is for cleanup, not main workflow. Keep regular success logic in else or after the block.

Best Practices

• Catch the most specific exception types first.
• Keep try blocks small and focused.
• Use clear error messages that help users and developers.
• Use custom exceptions for business rules in larger applications.
• Clean up resources with finally or context managers like with.

Practice Exercises

• Write a program that asks for two numbers and handles invalid input and division by zero.
• Create a script that tries to open a file name entered by the user and shows a friendly message if the file does not exist.
• Write a function that accepts an age and raises a ValueError if the age is less than 0.

Mini Project / Task

Build a simple ATM withdrawal program that asks for an amount, prevents invalid number input, rejects negative values, and handles withdrawal amounts larger than the account balance using exceptions.

Challenge (Optional)

Create a menu-driven program that repeatedly asks the user for a filename, reads integer values from the file, skips invalid lines safely, and reports the total without crashing.

Custom Exceptions

Custom exceptions are user-defined error classes that let you represent specific problems in your own programs instead of relying only on built-in exceptions such as ValueError, TypeError, or ZeroDivisionError. They exist because real applications often need clearer, domain-specific error messages. For example, a banking app may need an error for insufficient funds, a login system may need an account-locked error, and a file import tool may need an invalid-format error. By creating custom exceptions, you make your code easier to understand, debug, and maintain.

In Python, custom exceptions are typically created by defining a class that inherits from Exception or one of its subclasses. This allows your exception to work naturally with try, except, else, and finally blocks. Some custom exceptions are simple marker classes with no extra logic, while others carry additional data such as an error code, username, balance, or file path. In real projects, custom exceptions are especially useful in APIs, business logic layers, validation systems, payment workflows, and data-processing pipelines where generic errors are too vague.

Step-by-Step Explanation

To create a custom exception, define a class using the class keyword and inherit from Exception. A basic custom exception can contain only pass. Raise it with the raise keyword when a specific condition occurs. Catch it using an except block just like built-in exceptions.

There are several common styles. A simple custom exception only signals that something went wrong. A message-based exception accepts text to describe the error. A data-rich exception stores extra attributes for later inspection. You can also create a hierarchy, where a base custom exception represents a broad application error and smaller subclasses represent more specific cases. This structure helps you catch either all app-related errors together or one exact error type when needed.

Comprehensive Code Examples

Basic example

class AgeLimitError(Exception):
    pass

def register_user(age):
    if age < 18:
        raise AgeLimitError("User must be at least 18 years old.")
    return "Registration successful"

try:
    print(register_user(16))
except AgeLimitError as error:
    print(f"Registration failed: {error}")

Real-world example

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Cannot withdraw {amount}. Available balance: {balance}")

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

try:
    new_balance = withdraw(500, 800)
    print(new_balance)
except InsufficientFundsError as error:
    print(error)
    print(f"Balance: {error.balance}, Requested: {error.amount}")

Advanced usage

class AppError(Exception):
    pass

class ValidationError(AppError):
    pass

class InvalidEmailError(ValidationError):
    pass

class WeakPasswordError(ValidationError):
    pass

def validate_signup(email, password):
    if "@" not in email:
        raise InvalidEmailError("Email must contain @")
    if len(password) < 8:
        raise WeakPasswordError("Password must be at least 8 characters long")
    return "Signup data is valid"

try:
    print(validate_signup("userexample.com", "12345"))
except ValidationError as error:
    print(f"Validation failed: {error}")
except AppError as error:
    print(f"Application error: {error}")

Common Mistakes

• Inheriting from the wrong class: Beginners sometimes inherit from object instead of Exception. Fix: always inherit from Exception or a suitable subclass.
• Using custom exceptions for every small issue: Too many exception classes can make code confusing. Fix: create custom exceptions only for meaningful, reusable error cases.
• Raising exceptions without useful messages: This makes debugging harder. Fix: include clear, actionable messages and extra attributes when needed.
• Catching overly broad exceptions: Using except Exception everywhere can hide bugs. Fix: catch the most specific custom exception possible.

Best Practices

• Use exception names ending with Error, such as PaymentError or InvalidTokenError.
• Create a base application exception to organize related errors.
• Keep exception classes focused on error meaning, not business logic.
• Provide descriptive messages that help users or developers understand what failed.
• Store structured context like IDs, amounts, or filenames when that data helps troubleshooting.

Practice Exercises

• Create a custom exception named NegativeNumberError and raise it when a function receives a number below zero.
• Build a function that checks a username length and raises a custom exception if it is shorter than 5 characters.
• Create a base exception called LibraryError and two subclasses for BookNotFoundError and LateReturnError.

Mini Project / Task

Build a simple ATM withdrawal program that asks for a balance and withdrawal amount, then raises a custom exception when the amount exceeds the available balance.

Challenge (Optional)

Create a small input validation module with a base custom exception and at least three specialized exceptions for invalid email, weak password, and invalid age, then handle them with different except blocks.

Modules and Packages

Modules and packages are the tools Python uses to organize code into reusable, manageable pieces. A module is usually a single .py file containing functions, classes, and variables. A package is a folder that groups related modules together, often with an __init__.py file. They exist because real programs quickly become too large to keep in one file. By splitting code into modules and packages, developers improve readability, testing, reuse, and teamwork. In real life, this structure is used everywhere: web frameworks, data libraries, automation tools, and internal company applications all rely on modular design.

In Python, modules can be built-in such as math and random, user-defined such as your own calculator.py, or third-party such as requests. Packages may be simple folders for your project or installable libraries published to package indexes. Imports let one file use code from another with statements like import module or from module import name. Understanding this system is essential because nearly every serious Python project depends on clear file structure and predictable imports.

Step-by-Step Explanation

Start with a basic module. Create a file named greetings.py. Any function or variable inside it can be imported elsewhere. In another file, use import greetings and call members with dot notation such as greetings.say_hello().

You can also import specific names using from greetings import say_hello. This avoids prefixing the module name, but too many direct imports can make code harder to trace. Aliases are created with as, for example import numpy as np.

To make a package, create a folder such as utilities and place modules inside it, for example math_tools.py and string_tools.py. Adding __init__.py helps mark the folder as a package and can expose selected members. Then import using from utilities import math_tools or from utilities.math_tools import add.

Python searches for modules using its import path. This includes the current project, standard library, and installed packages. If imports fail, the file location or package structure is often the cause. Relative imports such as from . import helper are used inside packages, while absolute imports such as from utilities.helper import clean are usually clearer.

Comprehensive Code Examples

Basic example

# greetings.py
def say_hello(name):
    return f"Hello, {name}!"

# main.py
import greetings
print(greetings.say_hello("Ava"))

Real-world example

# utilities/price_tools.py
def add_tax(price, tax_rate=0.18):
    return price * (1 + tax_rate)

# app.py
from utilities.price_tools import add_tax
total = add_tax(100)
print(f"Final price: {total}")

Advanced usage

# utilities/__init__.py
from .math_tools import add

# utilities/math_tools.py
def add(a, b):
    return a + b

# run.py
from utilities import add
print(add(5, 7))

Common Mistakes

• Naming your file the same as a standard library module, such as random.py. Fix: use unique filenames to avoid import conflicts.

• Forgetting package structure when importing nested modules. Fix: check folder names, __init__.py, and import paths carefully.

• Using wildcard imports like from module import *. Fix: import only what you need for clarity and safety.

• Running a file from the wrong directory and breaking imports. Fix: execute code from the project root when working with packages.

Best Practices

• Keep modules focused on one responsibility, such as validation, formatting, or calculations.

• Prefer absolute imports in larger projects because they are easier to read and maintain.

• Use clear filenames and package names that describe purpose.

• Place reusable logic in modules, not directly inside the main execution file.

• Group related modules into packages as soon as the project starts growing.

Practice Exercises

• Create a module named converter.py with functions to convert kilometers to miles and Celsius to Fahrenheit. Import and test both functions in another file.

• Create a package named tools containing two modules: one for string utilities and one for number utilities. Import one function from each module in a main script.

• Write a module with a constant and two functions, then import the constant with an alias and call the functions from another file.

Mini Project / Task

Build a small calculator package with separate modules for addition, subtraction, multiplication, and division, then create a main program that imports them and performs a few sample calculations.

Challenge (Optional)

Design a package called shop with modules for inventory, pricing, and receipts. Make a main script that imports these modules and simulates a simple checkout process.

Importing Modules

In Python, modules are simply Python files containing Python definitions and statements. The purpose of modules is to organize code into reusable units, making it easier to manage, understand, and reuse. Imagine you have a set of functions and classes that perform mathematical operations, and you want to use them in various scripts without rewriting them every time. This is where modules come in. By putting these operations into a module (a .py file), you can then 'import' them into any other Python script. This promotes code reusability, reduces redundancy, and helps in structuring larger projects by breaking them down into smaller, manageable, and logical files.

Modules are extensively used in real-life applications. For instance, the math module provides mathematical functions, os interacts with the operating system, datetime handles dates and times, and popular libraries like requests (for HTTP requests) or numpy (for numerical computing) are all built as modules or collections of modules (packages). Without modules, Python programming would quickly become unmanageable for anything beyond trivial scripts, as all code would reside in a single, massive file.

Step-by-Step Explanation

Python offers several ways to import modules, each with its own use case.

• Basic Import: import module_name
  This is the most straightforward way. It imports the entire module, and you access its contents using the module name followed by a dot (.) and the member's name (e.g., module_name.function()).


• Import with Alias: import module_name as alias_name
  This allows you to give the module a shorter or more convenient name for use within your script. This is particularly useful for modules with long names or to avoid name collisions.


• Import Specific Members: from module_name import member_name
  If you only need a few specific functions, classes, or variables from a module, you can import them directly. This makes them accessible without prefixing them with the module name.


• Import Multiple Specific Members: from module_name import member1, member2
  Similar to the above, but allows importing multiple specific members in one line.


• Import All Members: from module_name import *
  This imports all public members (those not starting with an underscore) from the module directly into the current namespace. While convenient for quick scripting, it's generally discouraged in larger projects as it can lead to name conflicts and make it harder to trace where functions/variables originated.

Comprehensive Code Examples

Basic example

Let's create a simple module named my_module.py:

# my_module.py
def greet(name):
    return f"Hello, {name}!"

PI = 3.14159

Now, let's import and use it in another script:

# main_script.py
import my_module

print(my_module.greet("Alice"))
print(f"The value of PI is: {my_module.PI}")

Real-world example

Using Python's built-in math module for common mathematical operations.

import math

radius = 5
area = math.pi * (radius ** 2)
circumference = 2 * math.pi * radius
square_root_of_16 = math.sqrt(16)
cosine_of_zero = math.cos(0)

print(f"Area of circle with radius {radius}: {area:.2f}")
print(f"Circumference of circle with radius {radius}: {circumference:.2f}")
print(f"Square root of 16: {square_root_of_16}")
print(f"Cosine of 0 radians: {cosine_of_zero}")

Advanced usage

Combining different import styles and handling potential name conflicts.

# Imagine we have two modules:
# module_a.py
def process_data(data):
    return f"Processed A: {data.upper()}"

# module_b.py
def process_data(data):
    return f"Processed B: {data.lower()}"

# main_app.py
import module_a
from module_b import process_data as process_b_data

data_item = "Hello World"

# Using module_a's function via direct import
print(module_a.process_data(data_item))

# Using module_b's function via aliased import
print(process_b_data(data_item))

# Using a built-in module with an alias
import datetime as dt
now = dt.datetime.now()
print(f"Current date and time: {now}")

Common Mistakes

• Forgetting to prefix with module name: When using import module_name, people often forget to write module_name. before accessing its contents.
  import math
print(pi) # Error: NameError: name 'pi' is not defined
print(math.pi) # Correct


• Using from module import * excessively: While convenient, this can lead to name clashes if two imported modules have functions/variables with the same name. It also makes your code harder to read and debug as it's not immediately clear where a function comes from.
  from os import * # Imports everything from os
from math import * # Imports everything from math, 'pi' from math might overwrite 'pi' from another module if it existed.


• Circular Imports: This happens when two modules import each other. Module A imports Module B, and Module B imports Module A. This usually leads to ImportError or unexpected behavior. This is an advanced topic but good to be aware of.

Best Practices

• Place imports at the top: According to PEP 8 (Python's style guide), imports should generally be placed at the top of the file, after any module comments and docstrings, and before global variables and functions.


• Import one module per line: While you can do import os, sys, it's generally preferred to write import os
import sys for readability.


• Use specific imports (from module import member) when possible: This makes your code more explicit about what it's using and avoids polluting your namespace.


• Use aliases for long module names or to avoid conflicts: import numpy as np and import pandas as pd are common and recommended practices in data science.


• Avoid from module import *: Reserve it for interactive sessions or specific, carefully managed cases where name clashes are impossible or acceptable.


• Organize imports: Group imports into standard library imports, third-party library imports, and local application/project imports. Separate each group with a blank line.

Practice Exercises

1. Create a module named calculator.py with two functions: add(a, b) and subtract(a, b). Then, in a separate script, import this module and use both functions to perform calculations.


2. From the built-in random module, import only the randint function. Use it to print a random integer between 1 and 100 (inclusive).


3. Create a module named constants.py that defines a variable GRAVITY = 9.81. In another script, import this module using an alias g_const and print the value of g_const.GRAVITY.

Mini Project / Task

Develop a simple 'Unit Converter' application. Create a module named conversions.py that contains functions for common unit conversions (e.g., celsius_to_fahrenheit(c), meters_to_feet(m)). In your main script (main_converter.py), import these functions and allow the user to choose which conversion they want to perform, input a value, and display the result.

Challenge (Optional)

Extend the 'Unit Converter' project. In your conversions.py module, add a function get_all_conversions() that returns a dictionary of all available conversion function names. In main_converter.py, use this function to dynamically list the available conversions to the user, allowing them to select one by name, and then call the corresponding function from the module.

Standard Library Overview

Python’s standard library is the collection of built-in modules that ships with Python. It exists so developers can solve common problems without installing extra packages. In real projects, this means you can work with files, dates, JSON data, random values, math operations, command-line arguments, compression, logging, and even simple web requests using tools already included with Python. People often describe Python as a language that comes with “batteries included” because the standard library provides ready-made functionality for many everyday tasks.

Common modules include os for interacting with the operating system, pathlib for file paths, sys for Python runtime features, math for mathematical functions, random for random values, datetime for date and time handling, json for reading and writing JSON, and collections for specialized container types. These modules are used in automation scripts, backend services, data pipelines, reporting tools, monitoring systems, command-line utilities, and educational projects.

A module is a Python file containing reusable code, and you use it with the import statement. You can import a full module, a specific function, or give a module a shorter alias. Understanding how to browse and apply the standard library is a major skill because it saves time and reduces the need to reinvent solutions.

Step-by-Step Explanation

To use the standard library, start with import module_name. Then call its functions with dot notation, such as math.sqrt(25).

There are several import styles:

• Import the whole module: import math
• Import a specific item: from datetime import date
• Use an alias: import json as js

When choosing a module, think about the task. Need file paths? Use pathlib. Need random numbers? Use random. Need structured data exchange? Use json. Need timestamps? Use datetime. Good Python developers first check whether the standard library already solves the problem before adding third-party packages.

Comprehensive Code Examples

Basic example

import math
import random

print(math.sqrt(81))
print(random.randint(1, 10))

Real-world example

from pathlib import Path
import json

data = {
    "name": "Asha",
    "role": "Developer",
    "active": True
}

file_path = Path("user_profile.json")
file_path.write_text(json.dumps(data, indent=2))

loaded_data = json.loads(file_path.read_text())
print(loaded_data["name"])

Advanced usage

import logging
from datetime import datetime
from collections import Counter

logging.basicConfig(level=logging.INFO)

events = ["login", "logout", "login", "purchase", "login"]
counts = Counter(events)

logging.info(f"Event summary at {datetime.now()}: {counts}")

Common Mistakes

• Forgetting to import a module before using it. Fix: add the correct import statement at the top of the file.
• Using the wrong module for a task, such as string paths instead of pathlib. Fix: prefer modern standard-library tools designed for clarity.
• Naming your script the same as a library module, like json.py or random.py. Fix: rename your file to avoid import conflicts.

Best Practices

• Check the standard library before installing external packages.
• Use clear imports and avoid unnecessary wildcard imports.
• Prefer pathlib over manual string path building.
• Use logging instead of many raw print() statements in larger programs.

Practice Exercises

• Write a script that imports math and prints the square root of 144 and the value of pi.
• Create a program using random that prints a random integer from 1 to 20.
• Use datetime to display today’s date and current time.

Mini Project / Task

Build a simple user report tool that stores a dictionary as JSON in a file, reads it back, and prints the user’s name with the current date and time.

Challenge (Optional)

Create a script that scans a folder using pathlib, counts how many files exist by extension, and prints the results in a readable summary.

Virtual Environments

A virtual environment is an isolated Python workspace that keeps a project’s packages separate from the system Python and from other projects. This matters because different applications often need different package versions. One project may need Django 4, while another depends on Django 5. Without isolation, installing one version can break the other. In real life, virtual environments are used in backend development, data science notebooks, automation scripts, and team projects where consistent setup is essential. Python commonly uses the built-in venv module, though tools such as virtualenv, Poetry, and Pipenv also build on the same idea of isolated dependency management.

The core idea is simple: each environment has its own Python executable and its own installed packages directory. When the environment is activated, commands like python and pip point to that local environment instead of the global interpreter. The most common subtype for beginners is a project-level venv folder, usually named .venv or venv. On Windows, activation uses the Scripts folder; on macOS and Linux, it uses the bin folder. Deactivation returns your shell to the normal system context.

Step-by-Step Explanation

First, open a terminal inside your project folder. Create an environment with python -m venv .venv. This tells Python to run the built-in venv module and create a local environment in a folder named .venv.

Activate it with one of these commands:
source .venv/bin/activate on macOS/Linux
.venv\Scripts\activate on Windows Command Prompt
.venv\Scripts\Activate.ps1 on PowerShell

After activation, install packages with pip install requests. Save dependencies using pip freeze > requirements.txt. Another developer can recreate the environment, activate it, and run pip install -r requirements.txt. When finished, use deactivate.

Comprehensive Code Examples

Basic example

# Create environment
# python -m venv .venv

# Activate it, then verify interpreter
import sys
print(sys.executable)

Real-world example

# app.py
import requests

response = requests.get("https://api.github.com")
print(response.status_code)
print(response.json().get("current_user_url"))

# Install inside virtual environment:
# pip install requests

Advanced usage

# requirements management workflow
# pip install flask==3.0.0
# pip freeze > requirements.txt

# Later, in a fresh environment:
# pip install -r requirements.txt

import pkgutil
installed = sorted([m.name for m in pkgutil.iter_modules()])
print("flask" in installed)

Common Mistakes

• Installing packages without activating the environment. Fix: activate first, then check python --version and which python or where python.

• Committing the .venv folder to Git. Fix: add .venv/ to .gitignore and commit only source code plus dependency files.

• Using the wrong package installer. Fix: prefer python -m pip install package_name to ensure pip matches the active interpreter.

• Forgetting to recreate dependencies on another machine. Fix: maintain a clean requirements.txt file and document setup steps.

Best Practices

• Create one virtual environment per project.

• Use a consistent folder name such as .venv.

• Pin important dependency versions for reproducible builds.

• Store installation steps in a README so teammates can set up quickly.

• Use python -m pip instead of a plain pip command when possible.

Practice Exercises

• Create a new folder for a project and build a virtual environment named .venv.

• Activate the environment, install the requests package, and generate a requirements.txt file.

• Write a short Python script that prints the current interpreter path using sys.executable and confirm it points to the virtual environment.

Mini Project / Task

Set up a small API test project in a virtual environment, install requests, write a script that fetches data from a public API, and save the project dependencies to requirements.txt so another user can reproduce your setup.

Challenge (Optional)

Create two separate virtual environments for two sample projects and install different versions of the same package in each one. Verify with Python code that each environment uses its own package version without conflict.

Object Oriented Programming

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of 'objects', which can contain data and code: data in the form of fields (attributes or properties), and code in the form of procedures (methods). The primary goal of OOP is to increase the flexibility and maintainability of programs. It allows us to structure our programs in a way that models real-world entities, making complex systems easier to understand, design, and manage. OOP is widely used in almost every domain of software development, including web development (frameworks like Django and Flask), game development, scientific computing, data science, and artificial intelligence. For instance, in a game, a 'Player' or 'Enemy' could be an object with attributes like health, position, and methods like 'move()' or 'attack()'. In web development, a 'User' object might have attributes like username, email, and methods like 'login()' or 'update_profile()'.

The core concepts of OOP are Encapsulation, Inheritance, Polymorphism, and Abstraction. These are often referred to as the four pillars of OOP.

• Encapsulation: This refers to the bundling of data (attributes) and methods (functions) that operate on the data into a single unit, or class. It also restricts direct access to some of an object's components, which means that the internal representation of an object is hidden from the outside. This is typically achieved using access modifiers (though Python uses conventions like leading underscores). The main benefit is data hiding and protection, preventing unintended external interference with an object's internal state.
• Inheritance: This mechanism allows a new class (subclass or derived class) to inherit attributes and methods from an existing class (superclass or base class). It promotes code reusability and establishes a natural hierarchy between classes, representing a 'is-a' relationship (e.g., a 'Dog' 'is-a' 'Animal').
• Polymorphism: Meaning 'many forms', polymorphism allows objects of different classes to be treated as objects of a common superclass. This means a single interface can be used for different data types. In Python, polymorphism is often achieved through method overriding (subclasses providing their own implementation of a method defined in the superclass) and duck typing (if it walks like a duck and quacks like a duck, it's a duck).
• Abstraction: This involves showing only essential information and hiding the complex implementation details. It focuses on 'what' an object does rather than 'how' it does it. Abstract classes and interfaces are common ways to achieve abstraction, defining a blueprint for other classes without providing a full implementation.

Step-by-Step Explanation

In Python, classes are fundamental to OOP. A class is a blueprint for creating objects. An object is an instance of a class. To define a class, you use the class keyword.

1. Defining a Class: Start with the class keyword, followed by the class name (typically PascalCase).

class MyClass:
    pass # An empty class

2. The __init__ Method (Constructor): This is a special method called when an object is created from a class. It's used to initialize the object's attributes. The first parameter is always self, which refers to the instance of the class.

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

3. Attributes: Variables associated with an object. In the example above, make, model, and year are attributes.

4. Methods: Functions defined inside a class that operate on the object's data. They also take self as the first parameter.

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def display_info(self):
        return f"A {self.year} {self.make} {self.model}"

5. Creating Objects (Instantiation): To create an object, you call the class as if it were a function.

my_car = Car("Toyota", "Camry", 2020)
print(my_car.display_info()) # Output: A 2020 Toyota Camry

6. Inheritance: To inherit from another class, put the parent class name in parentheses after the child class name.

class ElectricCar(Car): # ElectricCar inherits from Car
    def __init__(self, make, model, year, battery_size):
        super().__init__(make, model, year) # Call parent's constructor
        self.battery_size = battery_size

    def charge(self):
        return "Charging..."

Comprehensive Code Examples

Basic example: Defining a Simple Class and Object

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        return f"{self.name} says Woof!"

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name)        # Output: Buddy
print(my_dog.bark())      # Output: Buddy says Woof!

Real-world example: A Library Management System

class Book:
    def __init__(self, title, author, isbn, is_available=True):
        self.title = title
        self.author = author
        self.isbn = isbn
        self.is_available = is_available

    def __str__(self): # Special method for string representation
        status = "Available" if self.is_available else "Borrowed"
        return f"'{self.title}' by {self.author} (ISBN: {self.isbn}) - {status}"

class Library:
    def __init__(self, name):
        self.name = name
        self.books = []

    def add_book(self, book):
        self.books.append(book)
        print(f"Added: {book.title} to {self.name}")

    def borrow_book(self, isbn):
        for book in self.books:
            if book.isbn == isbn and book.is_available:
                book.is_available = False
                print(f"Successfully borrowed '{book.title}'")
                return True
        print(f"Book with ISBN {isbn} not available or not found.")
        return False

    def return_book(self, isbn):
        for book in self.books:
            if book.isbn == isbn and not book.is_available:
                book.is_available = True
                print(f"Successfully returned '{book.title}'")
                return True
        print(f"Book with ISBN {isbn} was not borrowed or not found.")
        return False

    def list_all_books(self):
        print(f"\nBooks in {self.name}:")
        if not self.books:
            print("No books in the library.")
            return
        for book in self.books:
            print(book)

my_library = Library("City Public Library")

book1 = Book("The Great Gatsby", "F. Scott Fitzgerald", "978-0743273565")
book2 = Book("1984", "George Orwell", "978-0451524935")
book3 = Book("To Kill a Mockingbird", "Harper Lee", "978-0061120084")

my_library.add_book(book1)
my_library.add_book(book2)
my_library.add_book(book3)

my_library.list_all_books()

my_library.borrow_book("978-0743273565") # Borrow Gatsby
my_library.borrow_book("978-0743273565") # Try to borrow again
my_library.borrow_book("978-0000000000") # Non-existent book

my_library.list_all_books()

my_library.return_book("978-0743273565") # Return Gatsby
my_library.list_all_books()

Advanced usage: Inheritance and Polymorphism with Abstract Base Classes

from abc import ABC, abstractmethod

class Shape(ABC): # Abstract Base Class
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

    def describe(self): # Concrete method in an ABC
        return "This is a generic shape."r>
class Circle(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

    def describe(self): # Overriding parent method
        return f"This is a circle with radius {self.radius}."r>
class Rectangle(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)

    def describe(self): # Overriding parent method
        return f"This is a rectangle with width {self.width} and height {self.height}."r>
# Using polymorphism
shapes = [
    Circle(5),
    Rectangle(4, 6),
    Circle(3)
]

for shape in shapes:
    print(f"{shape.describe()} Area: {shape.area():.2f}, Perimeter: {shape.perimeter():.2f}")

# Uncommenting the line below would raise a TypeError because Shape is an abstract class
# generic_shape = Shape()

Common Mistakes

• Forgetting self: Newcomers often forget to include self as the first parameter in method definitions or when accessing instance attributes/methods. Python will raise an error like TypeError: my_method() takes 0 positional arguments but 1 was given. Always remember to pass self implicitly for instance methods.
  Fix: Ensure self is the first parameter for all instance methods and used to access attributes (e.g., self.attribute_name).
• Misunderstanding Class vs. Instance Attributes: Accidentally using an attribute like my_attribute inside a method instead of self.my_attribute. This leads to creating a local variable instead of accessing the object's state.
  Fix: Always use self.attribute_name to refer to attributes belonging to the object instance.
• Incorrect Inheritance Syntax or super() Usage: Forgetting to call super().__init__() in a child class's constructor when the parent class also has one. This can lead to parent attributes not being initialized.
  Fix: If a child class has its own __init__ method, always call super().__init__(*args, **kwargs) to ensure the parent class's constructor is properly executed.

Best Practices

• Use Descriptive Class and Method Names: Class names should be nouns (e.g., User, Product), and method names should be verbs (e.g., save_user(), calculate_total()). Use PascalCase for class names and snake_case for method/attribute names.
• Keep Classes Small and Focused (Single Responsibility Principle): Each class should ideally have one primary responsibility. If a class is doing too many things, consider splitting it into smaller, more focused classes.
• Encapsulate Data: While Python doesn't enforce strict private/public access, use leading underscores (e.g., _protected_attribute, __private_attribute - though the latter is more for name mangling than strict privacy) as a convention to indicate attributes that should not be accessed directly from outside the class. Provide getter/setter methods if direct access is truly needed, or use properties.
• Prefer Composition over Inheritance: While inheritance is powerful, it can lead to tight coupling. Often, 'has-a' relationships (composition, where one class contains an instance of another) are more flexible than 'is-a' relationships (inheritance).
• Use Docstrings: Document your classes and methods using docstrings to explain their purpose, arguments, and return values. This greatly improves code readability and maintainability.

Practice Exercises

1. Create a simple BankAccount class:
Define a class BankAccount with an __init__ method that takes account_holder_name and an initial balance. Include methods deposit(amount) and withdraw(amount). Ensure withdrawals don't go below zero.

2. Implement a Student and Course system:
Create a Student class with attributes name and student_id. Create a Course class with name and a list of enrolled students. Add methods to Course to enroll_student(student_obj) and list_students().

3. Build a Shape hierarchy:
Define a base class Shape with a method get_area() that returns 0. Create two child classes, Square and Triangle, that inherit from Shape. Each child class should have an __init__ method to set its specific dimensions (side for Square, base and height for Triangle) and override get_area() to calculate its correct area.

Mini Project / Task

Design and implement a basic ContactBook application. Create a Contact class with attributes like name, phone_number, and email. Then, create a ContactBook class that can store multiple Contact objects. Implement methods in ContactBook to:

• add_contact(contact_obj)
• find_contact(name) (returns the Contact object or None)
• delete_contact(name)
• list_all_contacts()

Challenge (Optional)

Extend your ContactBook mini-project. Add functionality to update a contact's information (e.g., change phone number or email). Additionally, implement a search feature that allows finding contacts by partial name matches (e.g., searching for 'Jo' finds 'John Doe' and 'Jane Johnson'). Consider how you would handle duplicate contact names.

Classes and Objects

In Python, Classes and Objects are fundamental concepts of Object-Oriented Programming (OOP). OOP is a programming paradigm that organizes software design around data, or objects, rather than functions and logic. An object can be defined as a data field that has unique attributes and behavior. Classes are blueprints or templates for creating objects. Think of a class as a cookie cutter and objects as the cookies it produces. Each cookie (object) shares the same basic structure defined by the cutter (class), but can have its own unique characteristics (e.g., different frosting or sprinkles).

Why do we use classes and objects? They allow us to structure our code in a modular and reusable way. This makes programs easier to understand, maintain, and extend. By encapsulating data and the functions that operate on that data within a single unit (an object), we can reduce complexity and improve code organization. In real life, almost everything can be modeled as an object. A car is an object with attributes like color, brand, and speed, and behaviors like accelerating, braking, and turning. A human is an object with attributes like name, age, height, and behaviors like walking, talking, and eating. Python's object-oriented nature makes it ideal for developing complex applications, simulations, and data processing systems where real-world entities need to be represented.

Step-by-Step Explanation

The basic syntax for defining a class in Python involves the class keyword, followed by the class name (conventionally capitalized using CamelCase), and a colon. Inside the class, you define attributes (variables) and methods (functions).

1. Class Definition: Use the class keyword.

class MyClass:
        # Class attributes and methods go here
        pass # 'pass' is a placeholder for an empty block

2. The __init__ Method (Constructor): This is a special method that gets called automatically when you create a new object (instance) of the class. It's used to initialize the object's attributes. The first parameter of any method in a class, including __init__, must be self, which refers to the instance of the class itself.

class Car:
        def __init__(self, brand, model, year):
            self.brand = brand
            self.model = model
            self.year = year

3. Instance Attributes: Variables prefixed with self. inside __init__ are instance attributes. Each object will have its own copy of these attributes.
4. Methods: Functions defined inside a class are called methods. They operate on the object's data. Like __init__, their first parameter is always self.

class Car:
        def __init__(self, brand, model, year):
            self.brand = brand
            self.model = model
            self.year = year

        def display_info(self):
            return f"{self.year} {self.brand} {self.model}"

5. Creating Objects (Instantiation): To create an object from a class, you call the class name as if it were a function, passing the required arguments for the __init__ method.

my_car = Car("Toyota", "Camry", 2020)
    your_car = Car("Honda", "Civic", 2022)

6. Accessing Attributes and Calling Methods: Use the dot notation (.) to access an object's attributes or call its methods.

print(my_car.brand) # Output: Toyota
    print(your_car.display_info()) # Output: 2022 Honda Civic

Comprehensive Code Examples

Basic example

This example demonstrates a simple Dog class with attributes for name and age, and a method for barking.

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        return f"{self.name} says Woof!"

    def get_age_in_human_years(self):
        return self.age * 7

my_dog = Dog("Buddy", 3)
your_dog = Dog("Lucy", 5)

print(f"My dog's name is {my_dog.name} and he is {my_dog.age} years old.")
print(my_dog.bark())
print(f"Lucy is {your_dog.get_age_in_human_years()} human years old.")
print(your_dog.bark())

Real-world example: Bank Account

This example simulates a simple bank account with deposit, withdrawal, and balance check functionalities.

class BankAccount:
    def __init__(self, account_holder, initial_balance=0):
        self.account_holder = account_holder
        self.balance = initial_balance
        print(f"Account created for {self.account_holder} with initial balance ${self.balance:.2f}")

    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            print(f"Deposited ${amount:.2f}. New balance: ${self.balance:.2f}")
        else:
            print("Deposit amount must be positive.")

    def withdraw(self, amount):
        if amount > 0:
            if self.balance >= amount:
                self.balance -= amount
                print(f"Withdrew ${amount:.2f}. New balance: ${self.balance:.2f}")
            else:
                print("Insufficient funds.")
        else:
            print("Withdrawal amount must be positive.")

    def get_balance(self):
        return f"Current balance for {self.account_holder}: ${self.balance:.2f}"

account1 = BankAccount("Alice Smith", 1000)
account2 = BankAccount("Bob Johnson")

account1.deposit(500)
account1.withdraw(200)
print(account1.get_balance())

account2.deposit(150)
account2.withdraw(300) # Insufficient funds
print(account2.get_balance())

Advanced usage: Inheritance

Inheritance allows a class (child/subclass) to inherit attributes and methods from another class (parent/superclass), promoting code reuse. Here, ElectricCar inherits from Car.

class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def display_vehicle_info(self):
        return f"Vehicle: {self.make} {self.model}"

class Car(Vehicle): # Car inherits from Vehicle
    def __init__(self, make, model, fuel_type):
        super().__init__(make, model) # Call parent constructor
        self.fuel_type = fuel_type

    def drive(self):
        return f"The {self.make} {self.model} is driving using {self.fuel_type}."

class ElectricCar(Car): # ElectricCar inherits from Car
    def __init__(self, make, model, battery_capacity):
        super().__init__(make, model, "Electric") # Call parent constructor with specific fuel_type
        self.battery_capacity = battery_capacity

    def charge(self):
        return f"The {self.make} {self.model} with {self.battery_capacity} kWh battery is charging."

my_vehicle = Vehicle("Generic", "Transporter")
my_car = Car("Toyota", "Camry", "Gasoline")
my_electric_car = ElectricCar("Tesla", "Model 3", 75)

print(my_vehicle.display_vehicle_info())
print(my_car.display_vehicle_info())
print(my_car.drive())
print(my_electric_car.display_vehicle_info())
print(my_electric_car.drive()) # Inherited method
print(my_electric_car.charge())

Common Mistakes

• Forgetting self: All instance methods (including __init__) must have self as their first parameter. Forgetting it will lead to a TypeError because Python expects an argument for self when you call the method.
  

  class Example:
              def bad_method(): # Missing self
                  pass
          # Fix: def good_method(self):

  
  


• Not calling super().__init__() in subclasses: When a subclass has its own __init__ method, it overrides the parent's __init__. If you don't explicitly call super().__init__(...), the parent's initialization logic (and its attributes) will not be executed, leading to missing attributes in the subclass instance.
  

  class Parent:
              def __init__(self, name):
                  self.name = name
          class Child(Parent):
              def __init__(self, age):
                  self.age = age # Parent's name attribute is not initialized
          # Fix: super().__init__("default_name"); self.age = age

  
  


• Confusing class attributes with instance attributes: Class attributes are shared by all instances of a class, while instance attributes are unique to each instance. Modifying a mutable class attribute (like a list or dictionary) through one instance will affect all instances. Use instance attributes for data specific to an object.
  

  class WrongExample:
              shared_list = [] # Class attribute
              def __init__(self, item):
                  self.shared_list.append(item) # Modifies the shared list for all instances
          obj1 = WrongExample('A')
          obj2 = WrongExample('B')
          print(obj1.shared_list) # Output: ['A', 'B'] - likely not intended
          # Fix: self.instance_list = [] in __init__ for instance-specific lists

Best Practices

• Use Meaningful Names: Class names should be nouns, capitalized (e.g., BankAccount). Method and attribute names should be descriptive and follow snake_case (e.g., deposit_funds, account_number).


• Encapsulation: Group related data (attributes) and the functions that operate on them (methods) within a class. While Python doesn't have strict private access modifiers, use a single leading underscore (_attribute) to indicate an internal attribute that should not be accessed directly from outside the class, and two leading underscores (__attribute) for name mangling, making it harder to access from outside.


• Keep Classes Focused (Single Responsibility Principle): Each class should have one primary responsibility. If a class starts doing too many things, consider refactoring it into smaller, more focused classes.


• Use Properties for Attribute Access: For attributes that require validation or computation upon access/modification, use Python's @property decorator instead of direct attribute access. This allows you to add logic without changing the client code that uses the attribute.


• Leverage Inheritance Wisely: Use inheritance when there is a clear "is-a" relationship (e.g., an ElectricCar "is a" Car). Avoid deep inheritance hierarchies, as they can become complex and hard to manage.

Practice Exercises

• Create a Rectangle Class: Define a class Rectangle with attributes width and height. Add methods to calculate its area and perimeter. Create an instance and print its area and perimeter.


• Implement a Book Class: Create a Book class with attributes title, author, and pages. Include a method get_short_description that returns a string like "Title by Author, X pages". Instantiate two books and print their descriptions.


• Extend with a Library Class: Design a Library class that can hold multiple Book objects. It should have a method add_book(book) to add a book to its collection and list_books() which prints the short description of all books in the library.

Mini Project / Task

Build a simple Contact Management System. Create a Contact class with attributes for name, phone_number, and email. Then, create a ContactManager class that can store a list of Contact objects. The ContactManager should have methods to add_contact(contact), view_contacts() (prints details of all contacts), and find_contact(name) (returns the contact object or None if not found).

Challenge (Optional)

Enhance your ContactManager from the mini-project. Add a method delete_contact(name) that removes a contact by name. Also, implement a search feature that allows finding contacts by partial name matching (e.g., searching for "Jo" might return "John Doe" and "Jane Johnson"). Consider how you would handle duplicate contact names.

Constructors and Methods

In Python, constructors and methods are fundamental parts of object-oriented programming. They help define how objects are created and how those objects behave after creation. A constructor is a special method that runs automatically when a new object is made from a class. In Python, the most common constructor is __init__. Methods are functions defined inside a class and are used to perform actions with the object's data. In real applications, constructors are used to initialize things like user profiles, bank accounts, products, or configuration settings, while methods are used to update values, perform calculations, validate input, or display information.

A class acts like a blueprint, and an object is the actual item created from that blueprint. The constructor helps prepare each object with its starting state. For example, if you create a Car object, the constructor can assign a brand, model, and year. Methods then allow the object to do useful work, such as starting the engine or calculating mileage. Python methods commonly include instance methods, which work with object-specific data through self; class methods, which work with class-level data through cls; and static methods, which are utility functions placed inside the class for related behavior.

Step-by-Step Explanation

To define a constructor, create a class and write a method named __init__. Its first parameter is always self, which refers to the current object. Any additional parameters are values passed when creating the object. Inside __init__, assign those values to the object using self.attribute_name.

A method is defined similarly, but it uses a regular name such as display or deposit. Instance methods must also include self as the first parameter. When you call a method on an object, Python automatically passes that object as self. Class methods are marked with @classmethod, and static methods use @staticmethod.

Comprehensive Code Examples

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"My name is {self.name} and I am {self.age} years old."

student1 = Student("Asha", 20)
print(student1.introduce())

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount

    def show_balance(self):
        return f"{self.owner} has ${self.balance}"

account = BankAccount("David", 500)
account.deposit(200)
account.withdraw(100)
print(account.show_balance())

class Employee:
    company = "TechCorp"

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def annual_salary(self):
        return self.salary * 12

    @classmethod
    def change_company(cls, new_name):
        cls.company = new_name

    @staticmethod
    def is_valid_salary(amount):
        return amount >= 0

emp = Employee("Lina", 4000)
print(emp.annual_salary())
print(Employee.is_valid_salary(4000))
Employee.change_company("NextGenSoft")
print(emp.company)

Common Mistakes

• Forgetting self: Instance methods and constructors must include self as the first parameter.
• Misspelling __init__: Writing _init_ or init prevents the constructor from running automatically.
• Not using self.attribute: If you write only name = name, the value will not be stored in the object.
• Using class methods when instance methods are needed: Choose the method type based on whether you need object data or class data.

Best Practices

• Keep constructors focused on initialization only.
• Use clear attribute names such as self.title or self.price.
• Provide default values when appropriate to make objects easier to create.
• Use instance methods for object behavior, class methods for shared class actions, and static methods for helper logic.
• Validate important input inside constructors or dedicated methods.

Practice Exercises

• Create a Book class with a constructor that stores title and author, and a method that displays both values.
• Create a Rectangle class with a constructor for width and height, and methods to calculate area and perimeter.
• Create a User class with a constructor that stores username and email, and a method that prints a welcome message.

Mini Project / Task

Build a simple Product class for an online store. Use a constructor to set the product name, price, and stock quantity. Add methods to update stock, apply a discount, and display product details.

Challenge (Optional)

Create a LibraryMember class with a constructor for member name and borrowed books count. Add methods to borrow a book, return a book, and prevent the borrowed count from going below zero.

Inheritance

Inheritance is an object-oriented programming feature that allows one class to reuse and extend the behavior of another class. The class being reused is called the parent class, base class, or superclass, while the new class is called the child class, derived class, or subclass. In Python, inheritance exists to reduce repetition, organize related code, and model real-world relationships such as Vehicle and Car, Employee and Manager, or Animal and Dog.
In real applications, inheritance is used when multiple objects share common features but also need their own specialized behavior. For example, an e-commerce system may have a base Product class with name and price, while Book and Electronics subclasses add their own details. Python supports single inheritance, multiple inheritance, and multilevel inheritance. Single inheritance means one child inherits from one parent. Multiple inheritance means a child inherits from more than one parent. Multilevel inheritance means a class inherits from a class that already inherited from another class.

Step-by-Step Explanation

To create inheritance in Python, define a parent class first. Then define a child class by placing the parent class name in parentheses after the child class name. The child automatically gets access to the parent class methods and attributes. If the child needs its own constructor, use super() to call the parent constructor and initialize shared data. A child class can also override a parent method by defining a method with the same name. When that method is called on a child object, Python uses the child version instead of the parent version.
Basic syntax uses class Child(Parent):. Inside the child class, call super().__init__() when you want to reuse parent setup. In multiple inheritance, Python follows a method resolution order, often called MRO, to decide which parent method to call first. You can inspect it with ClassName.mro().

Comprehensive Code Examples

Basic example

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a sound"

class Dog(Animal):
    def speak(self):
        return f"{self.name} barks"

pet = Dog("Rocky")
print(pet.name)
print(pet.speak())

Real-world example

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def get_details(self):
        return f"{self.name} earns {self.salary}"

class Manager(Employee):
    def __init__(self, name, salary, department):
        super().__init__(name, salary)
        self.department = department

    def get_details(self):
        return f"{self.name} manages {self.department} and earns {self.salary}"

m = Manager("Asha", 90000, "Engineering")
print(m.get_details())

Advanced usage

class Walker:
    def move(self):
        return "Walking"

class Swimmer:
    def move(self):
        return "Swimming"

class Amphibian(Walker, Swimmer):
    pass

a = Amphibian()
print(a.move())
print(Amphibian.mro())

Common Mistakes

• Forgetting to call super().__init__() in a child class, which can leave parent attributes uninitialized. Fix: call the parent constructor when shared setup is needed.
• Overriding methods without matching intent. A child method may accidentally remove important parent behavior. Fix: call super().method_name() if you want to extend rather than replace behavior.
• Using inheritance when composition is better. Not every relationship is an is-a relationship. Fix: use inheritance only when the child truly represents a specialized form of the parent.

Best Practices

• Keep parent classes focused on shared behavior and shared data.
• Use clear class names that show the relationship naturally.
• Prefer method overriding only when the child genuinely needs different behavior.
• Use super() consistently for cleaner and maintainable code.
• Be careful with multiple inheritance; use it only when class roles are clear.

Practice Exercises

• Create a parent class called Vehicle with a method start(). Make a child class Car that inherits from it and test both inherited and custom behavior.
• Create a parent class Person with name and age. Create a child class Student that adds grade and prints full details.
• Create a parent class Shape with a method area(). Create child classes Rectangle and Circle that override the method.

Mini Project / Task

Build a small school system with a base class User and child classes Teacher and Student. Store common information in the parent and add role-specific methods in each child.

Challenge (Optional)

Create a multilevel inheritance example using Person, Employee, and Developer. Override at least one method and use super() to reuse parent logic.

Encapsulation

Encapsulation is an object-oriented programming principle that bundles data and the methods that work on that data into a single unit, usually a class. In Python, encapsulation is used to control access to an object's internal state so that data is not changed carelessly from outside the class. This makes programs easier to understand, safer to use, and simpler to maintain. In real-life software, encapsulation is used in banking systems to protect account balances, in e-commerce apps to manage product inventory, and in user management systems to keep sensitive information like passwords hidden from direct access.

Python does not enforce strict access modifiers like some other languages, but it follows naming conventions to signal intended visibility. Public attributes can be accessed freely. A single underscore, such as _value, suggests that an attribute is internal and should not be touched directly. A double underscore, such as __value, triggers name mangling, making accidental external access harder. Encapsulation is often paired with methods such as getters, setters, and especially @property, which allows controlled reading and updating of values while keeping a simple interface.

Encapsulation is useful because it separates what users of a class can do from how the class is implemented internally. For example, a BankAccount class may allow deposits and withdrawals through methods, while preventing direct balance modification. This ensures validation rules are always applied.

Step-by-Step Explanation

To use encapsulation in Python, first create a class. Next, define attributes inside __init__. Decide which values should be internal. Use naming conventions like _name or __balance for protected or private-like data. Then create methods to safely read or update these values. For controlled access, use @property for reading and @attribute.setter for validation before assignment.

Basic flow:
1. Create a class.
2. Add internal attributes.
3. Write public methods to work with those attributes.
4. Optionally use properties for clean access syntax.
5. Prevent invalid states by checking values before storing them.

Comprehensive Code Examples

class Student:
    def __init__(self, name, age):
        self.name = name
        self._age = age  # internal by convention

    def get_age(self):
        return self._age

    def set_age(self, age):
        if age > 0:
            self._age = age

student = Student("Ava", 20)
print(student.get_age())
student.set_age(21)
print(student.get_age())

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

account = BankAccount("Liam", 500)
account.deposit(200)
account.withdraw(100)
print(account.get_balance())

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.__salary = salary

    @property
    def salary(self):
        return self.__salary

    @salary.setter
    def salary(self, value):
        if value < 0:
            raise ValueError("Salary cannot be negative")
        self.__salary = value

emp = Employee("Noah", 4000)
print(emp.salary)
emp.salary = 4500
print(emp.salary)

Common Mistakes

• Accessing internal attributes directly: Beginners often modify _age or __balance from outside the class. Fix this by using methods or properties.
• Using double underscores without understanding name mangling: __value is not truly private. Fix this by learning that Python only discourages accidental access.
• Skipping validation: Setting values directly can create invalid states like negative salary. Fix this by validating in setters or methods.

Best Practices

• Expose behavior, not raw data: Prefer methods like deposit() instead of direct attribute changes.
• Use @property for clean APIs: It gives control while keeping code readable.
• Validate all important updates: Protect object state from invalid values.
• Keep internal details hidden: Design classes so users do not depend on implementation details.

Practice Exercises

• Create a Book class with a private-like price and methods to get and update it only if the new price is positive.
• Create a Temperature class using @property so Celsius cannot go below absolute zero.
• Build a Wallet class with encapsulated balance, plus methods to add and spend money safely.

Mini Project / Task

Build a UserAccount class that stores a username and a hidden password. Add methods to change the password only when the old password is correct and the new password meets a minimum length.

Challenge (Optional)

Create an InventoryItem class with encapsulated stock and price. Allow restocking, selling, and price updates, but prevent negative stock, overselling, and invalid prices.

Polymorphism

Polymorphism is an object-oriented programming concept where the same interface, method name, or operation can behave differently depending on the object using it. The word means “many forms.” In Python, polymorphism is especially powerful because the language is dynamically typed and supports duck typing, which means Python often cares more about what an object can do than what exact class it belongs to. In real-life software, polymorphism is used in payment systems where different payment methods share the same action like pay(), in file handling where different file-like objects support read(), and in graphics programs where different shapes implement draw() in their own way. Common forms include method overriding in inheritance, built-in polymorphism such as len() working on different data types, and interface-style behavior where unrelated classes provide the same method. This makes programs more flexible, easier to extend, and simpler to maintain because new object types can often be added without changing existing logic.

Step-by-Step Explanation

To use polymorphism, first define a common action such as move() or pay(). Next, create multiple classes that implement that action in their own way. Then write code that calls the action without worrying about the exact object type. In inheritance-based polymorphism, a child class overrides a parent method. In duck typing, classes do not need a shared parent as long as they provide the expected method. For beginners, the key idea is simple: one method name, many behaviors. This lets you write loops and functions that work with different objects through a shared interface.

Comprehensive Code Examples

Basic example

class Dog:
    def speak(self):
        return "Bark"

class Cat:
    def speak(self):
        return "Meow"

animals = [Dog(), Cat()]
for animal in animals:
    print(animal.speak())

Both classes have a speak() method. The loop treats them the same, but each object responds differently.

Real-world example

class CreditCard:
    def pay(self, amount):
        return f"Paid {amount} using Credit Card"

class PayPal:
    def pay(self, amount):
        return f"Paid {amount} using PayPal"

class UPI:
    def pay(self, amount):
        return f"Paid {amount} using UPI"

def process_payment(method, amount):
    print(method.pay(amount))

process_payment(CreditCard(), 500)
process_payment(PayPal(), 800)
process_payment(UPI(), 1200)

The process_payment() function works with any object that provides pay().

Advanced usage

class Shape:
    def area(self):
        raise NotImplementedError("Subclasses must implement area()")

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

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

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

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

shapes = [Rectangle(4, 6), Circle(3)]
for shape in shapes:
    print(shape.area())

Here polymorphism appears through method overriding. Each subclass calculates area differently.

Common Mistakes

• Assuming inheritance is always required: In Python, duck typing allows polymorphism even without a common parent class. Fix: focus on shared behavior.
• Using different method names for similar actions: If one class uses pay() and another uses make_payment(), polymorphism breaks. Fix: keep the interface consistent.
• Forgetting required parameters: If methods have mismatched signatures, generic code may fail. Fix: design methods with compatible arguments.
• Not overriding base methods properly: A child class may inherit behavior accidentally. Fix: implement the method clearly in each subclass.

Best Practices

• Program to behavior, not exact types: Write code that calls shared methods instead of checking class names.
• Keep interfaces consistent: Use the same method names and parameter patterns across related classes.
• Use inheritance only when it models a true relationship: Otherwise, duck typing may be simpler.
• Raise clear errors in base classes: Methods such as raise NotImplementedError make subclass expectations obvious.
• Test each implementation separately: Ensure all classes satisfy the same expected behavior.

Practice Exercises

• Create classes Car, Bike, and Bus, each with a move() method that returns a different message. Loop through them and print the result.
• Create classes PDFFile and TextFile with a open_file() method. Write a function that accepts any file object and calls the method.
• Create a base class Employee with a method calculate_bonus(). Override it in Manager and Developer with different bonus rules.

Mini Project / Task

Build a simple notification system with classes EmailNotification, SMSNotification, and PushNotification. Each class should implement a send(message) method. Store objects in a list and send the same message through all channels using one loop.

Challenge (Optional)

Create a polymorphic reporting system with classes such as PDFReport, CSVReport, and JSONReport. Each class should implement a generate(data) method. Write one function that accepts any report object and exports the same dataset in different formats.

Iterators and Generators

Iterators and generators are fundamental concepts in Python that enable efficient and memory-friendly processing of data sequences. They provide a way to access elements of a collection one at a time, without loading the entire collection into memory. This is particularly useful when dealing with large datasets or infinite sequences. An iterator is an object that implements the iterator protocol, which means it has a __iter__() method that returns itself and a __next__() method that returns the next item in the sequence. When there are no more items, __next__() raises a StopIteration exception. This mechanism is behind all Python's iteration constructs, such as for loops. Python's built-in list, tuple, string, and dictionary types are all iterable, meaning you can get an iterator from them.

A generator is a special type of iterator that is much simpler to create. Instead of implementing the __iter__() and __next__() methods explicitly, you define a function that uses the yield keyword. When a generator function is called, it doesn't execute the function body immediately; instead, it returns a generator object. When next() is called on this object, the function executes until it hits a yield statement, at which point it pauses and returns the yielded value. The state of the function is saved, and execution resumes from where it left off the next time next() is called. This 'lazy evaluation' makes generators extremely memory efficient, especially for potentially infinite sequences or very large data streams where you only need one item at a time. Real-world applications include processing large log files, streaming data from networks, and implementing custom range-like functions.

Step-by-Step Explanation

To understand iterators, consider any object that you can loop over (like a list). When you write for item in my_list:, Python internally calls iter(my_list) to get an iterator object. Then, it repeatedly calls next() on that iterator until a StopIteration exception is raised. You can manually simulate this:

• Get an iterator: my_iterator = iter(my_list)


• Get the next item: item = next(my_iterator)

Generators simplify this. When Python encounters a yield statement in a function, it automatically turns that function into a generator factory. Each time yield is executed, the value is returned, and the function's state is frozen. The next call to next() on the generator object resumes execution right after the yield.

Comprehensive Code Examples

Basic Iterator Example

# Custom iterator class
class MyRange:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.end:
            num = self.current
            self.current += 1
            return num
        raise StopIteration

# Using the custom iterator
for i in MyRange(1, 5):
    print(i)

# Manual iteration
it = iter(MyRange(10, 13))
print(next(it))
print(next(it))
print(next(it))
try:
    print(next(it))
except StopIteration:
    print("End of iteration")

Basic Generator Example

def simple_generator():
    yield 1
    yield 2
    yield 3

# Using the generator
gen = simple_generator()
print(next(gen))
print(next(gen))
print(next(gen))
try:
    print(next(gen))
except StopIteration:
    print("Generator exhausted")

# Generators can be used directly in for loops
for i in simple_generator():
    print(i)

Real-world Example: Reading Large Files (Generator)

def read_large_file(file_path):
    """Reads a large file line by line using a generator."""
    with open(file_path, 'r') as f:
        for line in f:
            yield line.strip()

# Example usage (assuming 'large_data.txt' exists with many lines)
# Create a dummy file for demonstration
with open('large_data.txt', 'w') as f:
    for i in range(10000):
        f.write(f'Line {i}\n')

line_count = 0
for line in read_large_file('large_data.txt'):
    # Process each line without loading the whole file into memory
    if line_count < 5: # Just print first 5 lines for brevity
        print(line)
    line_count += 1
print(f"Processed {line_count} lines.")

Advanced Usage: Generator Expressions

# Similar to list comprehensions but returns a generator object
squares_generator = (x * x for x in range(10))

print(type(squares_generator)) # 
print(next(squares_generator)) # 0
print(next(squares_generator)) # 1

# Can be consumed by iteration
for sq in squares_generator:
    print(sq)

# Summing elements from a generator expression
total_sum = sum(x for x in range(1, 101))
print(f"Sum of numbers from 1 to 100: {total_sum}")

Common Mistakes

• Exhausting a Generator Too Soon: A generator can only be iterated over once. Once all values have been yielded, it's exhausted. Trying to iterate again will yield nothing.
  Fix: If you need to iterate multiple times, recreate the generator object or store the results in a list (if memory allows).


• Confusing return with yield in Generators: A function with yield is a generator. Using return will terminate the generator immediately, similar to raising StopIteration.
  Fix: Use yield for all values you intend to produce sequentially. return can be used without a value to signal the end of the generator, or with a value in Python 3.3+ to return a final value (which is typically ignored by for loops but accessible via StopIteration exception).


• Not Understanding Memory Implications: Expecting a generator to hold all values in memory like a list.
  Fix: Remember that generators produce values on demand. This is their strength for memory efficiency, but it means you can't re-access previous values without regenerating them.

Best Practices

• Use Generators for Large Datasets: Anytime you're dealing with potentially large or infinite sequences, prefer generators or generator expressions over lists to save memory.


• Keep Generator Logic Simple: Generator functions should ideally focus on generating the sequence of items. Complex logic can make them harder to debug.


• Leverage Generator Expressions: For simple, one-liner generator needs (like mapping or filtering), generator expressions (item for item in iterable if condition) are more concise and often more readable than full generator functions.


• Understand yield from: For delegating to a sub-generator, yield from (Python 3.3+) provides a cleaner way to chain generators.

Practice Exercises

• Exercise 1 (Beginner): Write a generator function called even_numbers(limit) that yields all even numbers up to (but not including) the limit. Then, loop through it and print the numbers.


• Exercise 2: Create a generator expression that generates the cubes of numbers from 1 to 7. Convert this generator expression into a list and print it.


• Exercise 3: Implement a custom iterator class named ReverseString that takes a string and iterates over its characters in reverse order.

Mini Project / Task

Build a simple log file processor. Create a generator function filter_logs(file_path, keyword) that takes a log file path and a keyword. It should yield only those lines from the log file that contain the specified keyword. Test it with a dummy log file containing several lines, some of which include your keyword.

Challenge (Optional)

Create a generator function fibonacci_sequence(n) that yields the first n Fibonacci numbers. Then, modify it to create an infinite_fibonacci() generator that yields Fibonacci numbers indefinitely. Use itertools.islice to take the first 10 numbers from your infinite generator.

Decorators

Decorators in Python are a way to add extra behavior to a function or method without rewriting the original code. They exist because developers often need to repeat the same logic across many functions, such as logging, permission checks, performance measurement, caching, or input validation. Instead of copying that logic everywhere, a decorator wraps the target function and runs code before or after it. In real-life software, decorators are heavily used in web frameworks, testing tools, access control systems, and debugging utilities.

A decorator works because Python treats functions as objects. This means a function can be passed into another function, returned from another function, and stored in variables. Most decorators are built using an outer function that accepts the original function and returns an inner wrapper function. When the decorated function is called, Python actually runs the wrapper. Common forms include simple function decorators, decorators with arguments, method decorators, and stacked decorators where multiple decorators are applied in order.

Step-by-Step Explanation

The basic syntax uses the @decorator_name symbol above a function. This is a shortcut for writing my_function = decorator_name(my_function).

To create one, first define a decorator function that takes another function as a parameter. Inside it, define a wrapper function. The wrapper receives any arguments using *args and **kwargs, runs extra logic, calls the original function, and returns the result. Finally, the decorator returns the wrapper.

If you need custom settings, create a decorator factory. This means one outer function accepts configuration values, then returns the real decorator. This pattern is useful for retry counts, labels, role checks, or custom messages.

Comprehensive Code Examples

Basic example

def greet_decorator(func):
    def wrapper(*args, **kwargs):
        print("Starting function...")
        result = func(*args, **kwargs)
        print("Function finished.")
        return result
    return wrapper

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

say_hello()

Real-world example

def require_admin(func):
    def wrapper(user_role, *args, **kwargs):
        if user_role != "admin":
            print("Access denied")
            return
        return func(user_role, *args, **kwargs)
    return wrapper

@require_admin
def delete_user(user_role, username):
    print(f"User {username} deleted")

delete_user("guest", "sam")
delete_user("admin", "sam")

Advanced usage

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

@repeat(3)
def show_message(text):
    print(text)

show_message("Python decorators are useful")

Common Mistakes

• Forgetting to return the wrapper: If the decorator does not return the inner function, the decorated function becomes unusable. Always end the decorator with return wrapper.
• Not forwarding arguments: Beginners sometimes write wrappers with no parameters. Use *args and **kwargs so the decorator works with different functions.
• Forgetting the original result: If the wrapped function returns a value, the wrapper should usually return it too.
• Confusing decorator execution time: The decorator is applied when the function is defined, not only when it is called.

Best Practices

• Keep decorators focused on one responsibility, such as logging or authorization.
• Use clear names like log_calls, require_login, or measure_time.
• Support flexible arguments with *args and **kwargs.
• Use decorators to remove repeated code, not to hide important business logic.
• When needed in professional code, preserve metadata with tools like functools.wraps.

Practice Exercises

• Create a decorator that prints a message before and after a function runs.
• Write a decorator that counts how many times a function is called.
• Build a decorator factory that repeats a function call a chosen number of times.

Mini Project / Task

Create a small login activity tracker. Write a decorator that logs when a function starts and ends, then apply it to functions like login_user() and logout_user().

Challenge (Optional)

Create a decorator that only allows a function to run during working hours. If the current hour is outside the allowed range, print a warning instead of calling the function.

Working with Dates and Time

Dates and time are essential in almost every software system. Applications use them to record events, schedule tasks, generate reports, calculate deadlines, track user activity, and organize logs. In Python, working with dates and time is mainly done with the built-in datetime module. It exists because plain numbers are not enough when dealing with calendars, hours, minutes, and time zones. Real-life examples include appointment booking systems, countdown timers, attendance software, online order timestamps, and financial transaction records.

Python provides several related types for handling temporal data. The date type stores only year, month, and day. The time type stores hour, minute, second, and microsecond. The datetime type combines both date and time in one object, which is the most commonly used type. The timedelta type represents a duration, such as 7 days or 3 hours, and is useful for date arithmetic. You may also use the strftime() method to format dates into readable strings and strptime() to convert strings back into date objects.

Step-by-Step Explanation

First, import the required classes using from datetime import date, time, datetime, timedelta. To get today’s date, use date.today(). To get the current date and time, use datetime.now(). You can create a specific date manually with date(2025, 6, 15) and a specific datetime with datetime(2025, 6, 15, 14, 30, 0).

To access parts of a date or time, use attributes like .year, .month, .day, .hour, and .minute. To format output, use strftime(), such as now.strftime("%Y-%m-%d %H:%M"). To parse user input like "2025-12-01", use datetime.strptime(text, "%Y-%m-%d"). To add or subtract time, use timedelta, for example today + timedelta(days=7). You can also compare dates directly with operators like <, >, and ==.

Comprehensive Code Examples

from datetime import date, datetime, timedelta

today = date.today()

print(today)

print(today.year, today.month, today.day)

from datetime import datetime

now = datetime.now()

formatted = now.strftime("%d/%m/%Y %H:%M")

print("Current time:", formatted)

from datetime import datetime, timedelta

order_date = datetime.strptime("2025-04-10", "%Y-%m-%d")

delivery_date = order_date + timedelta(days=5)

print("Expected delivery:", delivery_date.strftime("%A, %d %B %Y"))

Common Mistakes

• Mixing strings with date objects. Fix: parse strings with strptime() before comparing or calculating.

• Using the wrong format codes in strftime() or strptime(). Fix: check codes carefully, such as %Y for full year and %m for month.

• Trying to add integers directly to dates. Fix: use timedelta(days=number) instead.

• Confusing date and datetime. Fix: choose date when time is unnecessary and datetime when both are needed.

Best Practices

• Use datetime.now() only when current time is truly needed; otherwise use a fixed value for testing.

• Store dates in standard formats like YYYY-MM-DD for consistency.

• Format dates only for display; keep internal values as date or datetime objects.

• Use meaningful variable names such as start_date, end_time, and due_datetime.

Practice Exercises

• Write a program that prints today’s date and the current year, month, and day separately.

• Ask the user for a date in YYYY-MM-DD format and display it as DD/MM/YYYY.

• Create a program that calculates the date 30 days after a given date.

Mini Project / Task

Build a subscription tracker that accepts a signup date and calculates the renewal date after 30 days, then prints both in a friendly format.

Challenge (Optional)

Create a countdown program that takes a future date from the user and shows how many days remain until that date.

JSON Handling

JSON, short for JavaScript Object Notation, is a lightweight text format used to store and exchange structured data. In Python, JSON handling means converting Python objects such as dictionaries, lists, strings, numbers, booleans, and None into JSON text, and converting JSON text back into Python objects. It exists because applications often need a universal format to communicate with web APIs, configuration files, frontend apps, databases, and cloud services. In real life, JSON is everywhere: a weather app receives JSON from an API, a mobile app sends login data as JSON, and many systems save settings in JSON files.

Python provides the built-in json module for this job. The most important concepts are serialization and deserialization. Serialization means turning a Python object into JSON using json.dumps() for strings or json.dump() for files. Deserialization means reading JSON and converting it into Python objects using json.loads() for strings or json.load() for files. You should also understand the basic type mapping: Python dictionaries become JSON objects, lists become arrays, strings stay strings, numbers stay numbers, True becomes true, False becomes false, and None becomes null.

Step-by-Step Explanation

First, import the module with import json. If you already have Python data and want JSON text, use json.dumps(data). If you want readable formatting, add indent=2. To save directly into a file, open the file in write mode and use json.dump(data, file). To read JSON from a string, use json.loads(text). To read from a file, open it in read mode and use json.load(file).

A key beginner point is that JSON requires valid formatting. Strings must use double quotes in JSON text, keys in objects must also use double quotes, and trailing commas are not allowed. If formatting is wrong, Python raises json.JSONDecodeError.

Comprehensive Code Examples

import json

student = {
    "name": "Asha",
    "age": 21,
    "skills": ["Python", "SQL"]
}

json_text = json.dumps(student, indent=2)
print(json_text)

python_data = json.loads(json_text)
print(python_data["name"])

import json

settings = {
    "theme": "dark",
    "notifications": True,
    "language": "en"
}

with open("settings.json", "w", encoding="utf-8") as file:
    json.dump(settings, file, indent=2)

with open("settings.json", "r", encoding="utf-8") as file:
    loaded_settings = json.load(file)

print(loaded_settings)

import json
from datetime import datetime

data = {
    "event": "login",
    "time": datetime.now().isoformat()
}

json_text = json.dumps(data, sort_keys=True, indent=2)
print(json_text)

Common Mistakes

• Using single quotes in raw JSON text: JSON requires double quotes. Fix by writing valid JSON before calling json.loads().
• Confusing dump and dumps: dump writes to a file object, while dumps returns a string.
• Trying to serialize unsupported objects: Types like datetime are not directly JSON serializable. Convert them to strings first.
• Forgetting file encoding: Use encoding="utf-8" when opening files for reliable text handling.

Best Practices

• Use indent for human-readable files during development.
• Validate external JSON with try and except json.JSONDecodeError.
• Keep JSON focused on simple data structures such as dictionaries, lists, and basic values.
• Use descriptive keys so JSON remains easy to understand and maintain.
• When sharing data between systems, document expected keys and value types clearly.

Practice Exercises

• Create a Python dictionary for a book with title, author, and price, then convert it to formatted JSON text.
• Write a program that saves a list of three tasks into a JSON file and then reads the file back.
• Given a JSON string containing user information, convert it into Python data and print only the email field.

Mini Project / Task

Build a simple contact manager that stores contacts as a list of dictionaries in a JSON file. Allow the program to add a new contact and then reload and display all saved contacts.

Challenge (Optional)

Write a program that reads a JSON file of products, filters items with price greater than a chosen amount, and saves the filtered results into a new JSON file with proper indentation.

Working with APIs

APIs, or Application Programming Interfaces, let one software system communicate with another. In Python, working with APIs usually means sending HTTP requests to a remote server and processing the response. This is common in weather apps, payment systems, maps, social platforms, e-commerce dashboards, AI integrations, and internal business tools. Instead of building every feature from scratch, developers connect to existing services that expose data or actions through API endpoints. Python is especially well suited for this because it has clean syntax and excellent libraries such as requests for making web requests and handling JSON data easily.

Most modern APIs are web APIs. They typically use HTTP methods such as GET to fetch data, POST to create data, PUT or PATCH to update data, and DELETE to remove data. API responses are often returned in JSON format, which Python can convert into dictionaries and lists. Another important concept is authentication. Some APIs are public, while others require API keys, bearer tokens, or OAuth. You also need to understand status codes. For example, 200 means success, 404 means not found, and 500 means a server error.

Step-by-Step Explanation

To use an API in Python, first install the requests package if needed. Next, identify the endpoint URL. Then send a request using the correct HTTP method. After receiving the response, check the status code before using the data. If the response is JSON, call response.json() to convert it into Python data structures. You can also send query parameters using the params argument, headers using headers, and body data using json or data.

A beginner should remember this flow: choose endpoint, send request, validate response, parse data, then use or store the result. For secure APIs, avoid hardcoding secrets directly in code. Professional projects also use timeouts and exception handling so the program does not freeze or crash when the network fails.

Comprehensive Code Examples

Basic example

import requests

url = "https://jsonplaceholder.typicode.com/posts/1"
response = requests.get(url, timeout=10)

if response.status_code == 200:
    data = response.json()
    print(data["title"])

Real-world example

import requests

url = "https://api.github.com/repos/python/cpython"
response = requests.get(url, timeout=10)

if response.ok:
    repo = response.json()
    print("Name:", repo["name"])
    print("Stars:", repo["stargazers_count"])
    print("Language:", repo["language"])

Advanced usage

import requests

url = "https://jsonplaceholder.typicode.com/posts"
payload = {"title": "API Demo", "body": "Created from Python", "userId": 1}
headers = {"Content-Type": "application/json"}

try:
    response = requests.post(url, json=payload, headers=headers, timeout=10)
    response.raise_for_status()
    result = response.json()
    print("Created ID:", result["id"])
except requests.RequestException as error:
    print("Request failed:", error)

Common Mistakes

• Ignoring status codes: Always check whether the request succeeded before reading data.
• Assuming every response is JSON: Some APIs return text, HTML, or empty responses. Validate first.
• Forgetting timeouts: Without a timeout, your program may hang if the server is slow.
• Hardcoding secrets: Store API keys in environment variables or secure config files.

Best Practices

• Read the API documentation carefully before writing code.
• Use meaningful variable names like response, payload, and headers.
• Wrap requests in try/except blocks for reliability.
• Use response.raise_for_status() in production-style code.
• Respect rate limits and avoid sending unnecessary repeated requests.

Practice Exercises

• Write a Python script that sends a GET request to a public JSON API and prints two fields from the response.
• Create a program that sends query parameters with a request and displays the returned JSON data.
• Build a script that makes a POST request to a test API and prints the created object.

Mini Project / Task

Build a simple Python API client that fetches a list of posts from a public API, prints the first five titles, and handles network errors gracefully.

Challenge (Optional)

Create a reusable function that accepts an endpoint, method, headers, and payload, then returns parsed JSON while handling errors and invalid responses safely.

Command Line Arguments

Command line arguments are values passed to a Python program when it starts running. They exist so a script can receive input without asking the user interactively through input(). This makes programs easier to automate, schedule, and reuse in terminals, shell scripts, CI pipelines, and server environments. In real life, command line arguments are used when running tools like file converters, backup scripts, deployment utilities, data processors, and testing commands. For example, a developer may run a script with a filename, output directory, or mode such as python app.py report.csv --verbose.

In Python, the most direct way to access command line arguments is through sys.argv. This is a list where the first item is the script name and the remaining items are the arguments supplied by the user. A more advanced and professional approach is to use modules such as argparse, which helps define required and optional arguments, default values, help messages, and type conversion. These approaches serve different needs: sys.argv is simple and useful for learning, while argparse is better for real applications.

Step-by-Step Explanation

Start by importing the sys module. Then access sys.argv. If you run python script.py hello 25, then sys.argv[0] is usually script.py, sys.argv[1] is hello, and sys.argv[2] is 25. Remember that arguments arrive as strings, so numbers must be converted using int() or float() when needed.

When building stronger scripts, check the number of arguments before using them. This prevents index errors. For professional command-line tools, use argparse. You create a parser, define expected arguments, and let Python handle usage messages and validation. Optional flags often begin with dashes, such as --name or --verbose.

Comprehensive Code Examples

import sys

print(sys.argv)

Basic example: prints every argument exactly as received.

import sys

if len(sys.argv) != 3:
    print("Usage: python add.py num1 num2")
else:
    num1 = int(sys.argv[1])
    num2 = int(sys.argv[2])
    print("Sum:", num1 + num2)

Real-world example: a small calculator that accepts two numbers from the command line.

import argparse

parser = argparse.ArgumentParser(description="Process a text file")
parser.add_argument("filename", help="Path to the input file")
parser.add_argument("--uppercase", action="store_true", help="Convert content to uppercase")
args = parser.parse_args()

with open(args.filename, "r", encoding="utf-8") as file:
    content = file.read()

if args.uppercase:
    content = content.upper()

print(content)

Advanced usage: combines a required positional argument with an optional flag, which is common in production scripts.

Common Mistakes

• Forgetting that all arguments are strings: convert values before doing math.
• Using an argument index that does not exist: always check len(sys.argv) first.
• Ignoring helpful error messages: provide usage instructions when arguments are missing or invalid.
• Using sys.argv for very complex tools: switch to argparse for better structure.

Best Practices

• Use clear argument names and meaningful help text.
• Validate values before processing files or calculations.
• Prefer argparse for scripts with options, flags, or multiple inputs.
• Show example usage when the user runs the script incorrectly.
• Keep command-line tools focused on one clear task.

Practice Exercises

• Write a script that accepts a user name as a command line argument and prints a greeting.
• Create a script that takes two integers from the command line and prints their product.
• Build a script that accepts a filename and prints how many characters are inside the file.

Mini Project / Task

Build a command-line temperature converter that accepts a numeric value and a unit such as C or F, then prints the converted result.

Challenge (Optional)

Create a command-line to-do script using argparse that supports commands like adding a task, listing tasks, and removing a task by number.

Logging

Logging in Python is the standard way to record events that happen while a program runs. It exists because printing messages with print() is not enough for real applications. In real life, developers use logging to trace bugs, monitor servers, track user actions, and understand failures after deployment. For example, a web app may log login attempts, a script may log file processing steps, and a data pipeline may log missing records. Python provides the built-in logging module so programs can produce structured, configurable messages without rewriting custom tracking systems.

The main concepts are log levels, loggers, handlers, formatters, and configuration. Log levels help classify message importance: DEBUG for detailed internal state, INFO for normal progress, WARNING for unexpected but non-fatal situations, ERROR for failures in one operation, and CRITICAL for severe problems that may stop the program. A logger creates messages. A handler decides where messages go, such as the console or a file. A formatter controls how log output looks, such as including time, level, and message. In simple scripts, basicConfig() is enough. In larger systems, multiple handlers and custom formatting are common.

Step-by-Step Explanation

To start logging, import the module and configure it. The simplest setup uses logging.basicConfig(). You usually set a minimum level and a format string. Then create messages with functions like logging.info() or logging.error(). If the level is lower than the configured threshold, the message will not appear. A better practice for larger codebases is creating a named logger with logging.getLogger(__name__). This makes logs easier to organize by module.

The common syntax is: import logging, call basicConfig(level=..., format=...), then write messages. The format often includes %(asctime)s, %(levelname)s, and %(message)s. To write logs to a file, pass filename='app.log'. For dynamic values, prefer logging.info("User %s logged in", username) instead of building strings manually. This is cleaner and more efficient.

Comprehensive Code Examples

import logging

logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')

logging.debug('This will not show at INFO level')
logging.info('Application started')
logging.warning('Low disk space warning')

import logging

logging.basicConfig(
    filename='orders.log',
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

order_id = 1042
customer = 'Asha'

logging.info('Processing order %s for %s', order_id, customer)

try:
    total = 250 / 0
except ZeroDivisionError:
    logging.error('Failed to calculate total for order %s', order_id)

import logging

logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('app.log')

formatter = logging.Formatter('%(asctime)s | %(name)s | %(levelname)s | %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

logger.addHandler(console_handler)
logger.addHandler(file_handler)

def divide(a, b):
    logger.debug('divide() called with a=%s, b=%s', a, b)
    try:
        result = a / b
        logger.info('Division successful: %s', result)
        return result
    except ZeroDivisionError:
        logger.exception('Division by zero error')

divide(10, 2)
divide(10, 0)

Common Mistakes

• Using print instead of logging: print() cannot filter by level or write cleanly to multiple destinations. Use the logging module.
• Setting the wrong level: if level is WARNING, INFO and DEBUG messages will not appear. Choose levels carefully.
• Building log strings manually: avoid 'User: ' + name. Use placeholders like logging.info('User: %s', name).
• Forgetting exception details: use logging.exception() inside except blocks to capture traceback information.

Best Practices

• Use named loggers: prefer logging.getLogger(__name__) in modules.
• Choose meaningful levels: reserve ERROR and CRITICAL for actual failures.
• Include useful context: log IDs, filenames, and operation names.
• Write to both console and file when needed: this helps during development and production support.
• Avoid logging sensitive data: never log passwords, tokens, or personal secrets.

Practice Exercises

• Create a script that logs one message at each standard level and observe which messages appear when the level changes.
• Build a program that asks for two numbers, performs division, and logs success or failure.
• Configure logging to write messages to a file named activity.log with timestamp, level, and message.

Mini Project / Task

Create a file-processing logger that reads several filenames from a list, logs when each file starts processing, logs a warning if a file does not exist, and logs a final summary message.

Challenge (Optional)

Build a small multi-function application where each function uses the same named logger, and configure separate console and file handlers with different log levels.

Testing with unittest

unittest is Python’s built-in testing framework for creating automated tests that confirm your code works as expected. It exists to help developers catch bugs early, safely refactor code, and document intended behavior through test cases. In real projects, unittest is used in backend services, data pipelines, command-line tools, APIs, and business applications where reliability matters. Instead of manually running functions and checking outputs yourself, you write repeatable test methods that compare actual and expected results.

The framework is based on a few key ideas. A test case is a class that inherits from unittest.TestCase. A test method is any method whose name starts with test_. Assertions such as assertEqual(), assertTrue(), and assertRaises() check whether behavior matches expectations. Fixtures like setUp() and tearDown() prepare and clean resources for each test. You may also group tests into suites or run them from the command line with python -m unittest.

Step-by-Step Explanation

To begin, import unittest. Next, create a class that inherits from unittest.TestCase. Inside that class, define methods that start with test_. In each method, call your function and compare the result using assertions. Finally, include unittest.main() so the file can run directly.

Basic structure:
import unittest
class TestSomething(unittest.TestCase):
def test_example(self):
self.assertEqual(actual, expected)
if __name__ == '__main__':
unittest.main()

Common assertion methods include checking equality, truth values, membership, and exceptions. If you need shared setup, place it in setUp(). That method runs before every test, which keeps tests independent and predictable.

Comprehensive Code Examples

Basic example

import unittest

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

class TestAdd(unittest.TestCase):
    def test_add_positive_numbers(self):
        self.assertEqual(add(2, 3), 5)

    def test_add_negative_numbers(self):
        self.assertEqual(add(-1, -1), -2)

if __name__ == '__main__':
    unittest.main()

Real-world example

import unittest

def is_valid_email(email):
    return '@' in email and '.' in email.split('@')[-1]

class TestEmailValidation(unittest.TestCase):
    def test_valid_email(self):
        self.assertTrue(is_valid_email('[email protected]'))

    def test_invalid_email_missing_at(self):
        self.assertFalse(is_valid_email('userexample.com'))

    def test_invalid_email_missing_domain_dot(self):
        self.assertFalse(is_valid_email('user@examplecom'))

Advanced usage

import unittest

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError('Amount must be positive')
        self.balance += amount

class TestBankAccount(unittest.TestCase):
    def setUp(self):
        self.account = BankAccount(100)

    def test_deposit_increases_balance(self):
        self.account.deposit(50)
        self.assertEqual(self.account.balance, 150)

    def test_deposit_invalid_amount_raises_error(self):
        with self.assertRaises(ValueError):
            self.account.deposit(0)

Common Mistakes

• Forgetting the test_ prefix: methods without that prefix are not discovered. Rename them properly.
• Writing dependent tests: one test should not rely on another test’s result. Use setUp() to prepare fresh data.
• Testing too many things at once: large tests are harder to debug. Keep each test focused on one behavior.

Best Practices

• Use clear test names that describe behavior, such as test_login_rejects_empty_password.
• Write small, isolated tests with predictable input and output.
• Test both successful outcomes and failure cases, including raised exceptions.
• Use fixtures to remove duplication and improve readability.
• Run tests regularly during development, not only at the end.

Practice Exercises

• Create a function subtract(a, b) and write three unit tests for positive, negative, and zero results.
• Write a function that checks whether a number is even, then test true and false cases.
• Create a class with a method that raises ValueError for invalid input, and test that exception with assertRaises().

Mini Project / Task

Build a small calculator module with add, subtract, multiply, and divide functions, then write a unittest test class that verifies correct results and division-by-zero handling.

Challenge (Optional)

Create tests for a simple shopping cart class that adds items, removes items, calculates totals, and rejects negative item prices.

Debugging Techniques

Debugging is the process of finding, understanding, and fixing problems in code. In Python, debugging matters because even small mistakes such as incorrect indentation, wrong variable names, invalid assumptions, or unexpected input can cause programs to fail or behave incorrectly. In real life, developers use debugging when a web application crashes, a data pipeline produces wrong results, an automation script skips files, or a game mechanic behaves unpredictably. Python offers several ways to debug: reading error messages, using temporary print statements, inspecting variables, testing smaller parts of a program, and using the built-in debugger called pdb. Common error categories include syntax errors, runtime errors such as ZeroDivisionError or TypeError, and logic errors where the code runs but gives the wrong result. Good debugging is not guessing randomly; it is a structured investigation where you reproduce the issue, narrow down the location, inspect data, and confirm the fix.

Step-by-Step Explanation

Start by reproducing the bug consistently. If you cannot make the issue happen again, it becomes much harder to fix. Next, read the traceback carefully from bottom to top because the final lines usually show the exact error type and line number. Then inspect the surrounding code and verify assumptions about variable values, data types, and control flow. For simple problems, add print() statements before and after important steps to trace execution. For deeper inspection, use breakpoint() or import pdb; pdb.set_trace() to pause execution and check variables interactively. You can step through code line by line, continue execution, or inspect expressions. Another useful method is isolation: reduce the program to the smallest example that still shows the bug. This removes noise and makes the root cause easier to see. Finally, after fixing the issue, rerun the program and test related cases to make sure the solution does not break something else.

Comprehensive Code Examples

Basic example

numbers = [1, 2, 3]
print(numbers[3])  # IndexError

The traceback tells you that index 3 does not exist because valid indexes are 0, 1, and 2.

Real-world example

def calculate_discount(price, percent):
    final_price = price - price * percent
    return final_price

print(calculate_discount(100, 20))

This runs but gives the wrong answer because 20 should be converted to 0.20. A quick debug print such as print(price, percent, final_price) helps reveal the logic problem.

Advanced usage

def divide_values(a, b):
    breakpoint()
    result = a / b
    return result

print(divide_values(10, 0))

When execution pauses, inspect a and b, then identify that dividing by zero causes the runtime error. This is useful when bugs appear only under certain input conditions.

Common Mistakes

• Ignoring the full traceback: Beginners often read only the error name. Fix: read the file name, line number, and call stack carefully.
• Changing many things at once: This hides the real cause. Fix: make one small change, then test again.
• Assuming variable values: Many bugs come from wrong assumptions. Fix: print or inspect values directly with breakpoint().
• Not reproducing the bug first: Fix: create a clear sequence of steps and sample input that always triggers the issue.

Best Practices

• Use descriptive variable names so debugging output is easier to understand.
• Test small parts of the program separately before combining them.
• Keep functions short so bugs are easier to isolate.
• Use try/except carefully to handle expected errors, not to hide problems silently.
• After fixing a bug, test edge cases such as empty input, zero values, and invalid data types.

Practice Exercises

• Write a program with an intentional TypeError, run it, and identify the exact line and cause from the traceback.
• Create a function that calculates an average but returns the wrong result; use print debugging to find the logic mistake.
• Write a small script that uses breakpoint() to inspect variables before a division operation.

Mini Project / Task

Build a simple calculator that asks for two numbers and an operation. Intentionally test invalid input such as letters or division by zero, then debug and improve the program until it handles errors clearly.

Challenge (Optional)

Create a program that reads a list of numbers from user input, removes invalid entries, and computes the average. Use debugging techniques to handle malformed input and identify any hidden logic errors.

Final Project

The final project is the capstone activity where you combine the most important Python skills into one complete, working application. It exists to help learners move from isolated exercises into real development, where programs must be planned, structured, tested, and improved. In real life, developers rarely write tiny one-file examples only; they build tools that accept input, process data, handle errors, and present useful results. A Python final project simulates that professional workflow. It can be a command-line tool, data tracker, automation script, mini game, or file-processing utility. The key goal is not just writing code, but designing a solution from start to finish. In this stage, you apply variables, conditions, loops, functions, modules, file handling, and basic debugging in one place. Common project styles include utility applications, text-based management systems, reporting tools, and small automation programs. For beginners, a strong final project should solve one clear problem, stay focused, and be easy to test. Good examples include a personal expense tracker, student record manager, task planner, password generator, or inventory checker.

Step-by-Step Explanation

Start by choosing a simple real-world problem. Define what the user should be able to do, such as add data, view data, search records, update entries, and save information. Next, break the project into features. For example, a task manager might need a menu, task storage, add task, mark complete, and save to file. Then decide the program structure. Beginners should separate the project into small functions, with each function doing one clear job. After that, build the project in layers: first create the menu, then one feature at a time, then add validation and error handling. Finally, test each feature using realistic input. A useful project flow is: define requirements, sketch program steps, write functions, connect them in a main loop, test edge cases, and clean the code. This approach keeps the project manageable and reduces bugs.

Comprehensive Code Examples

Basic example: a simple menu-driven project skeleton.

def show_menu():
    print("1. Add item")
    print("2. View items")
    print("3. Exit")

items = []

while True:
    show_menu()
    choice = input("Choose an option: ")

    if choice == "1":
        item = input("Enter item: ")
        items.append(item)
    elif choice == "2":
        for i in items:
            print("-", i)
    elif choice == "3":
        break
    else:
        print("Invalid choice")

Real-world example: a task tracker with status.

tasks = []

def add_task(name):
    tasks.append({"name": name, "done": False})

def view_tasks():
    if not tasks:
        print("No tasks yet.")
        return
    for index, task in enumerate(tasks, start=1):
        status = "Done" if task["done"] else "Pending"
        print(f"{index}. {task['name']} - {status}")

def complete_task(index):
    if 0 <= index < len(tasks):
        tasks[index]["done"] = True

add_task("Write report")
add_task("Practice Python")
complete_task(1)
view_tasks()

Advanced usage: saving project data to a file.

def save_tasks(filename, tasks):
    with open(filename, "w") as file:
        for task in tasks:
            file.write(f"{task['name']}|{task['done']}\n")

def load_tasks(filename):
    tasks = []
    try:
        with open(filename, "r") as file:
            for line in file:
                name, done = line.strip().split("|")
                tasks.append({"name": name, "done": done == "True"})
    except FileNotFoundError:
        pass
    return tasks

Common Mistakes

• Making the project too large: Beginners often plan too many features. Fix this by starting with a minimum working version.
• Writing everything in one block: Large scripts become hard to debug. Fix this by using functions for each feature.
• Ignoring invalid input: Users may type unexpected values. Fix this with checks, conditions, and try-except where needed.
• Not testing often: Waiting until the end makes bugs harder to find. Fix this by testing after each feature.

Best Practices

• Choose one clear problem and solve it well.
• Use meaningful function and variable names.
• Keep logic separated into small reusable functions.
• Add simple error handling for files and user input.
• Test normal, empty, and incorrect inputs.
• Improve readability with consistent formatting and comments only where helpful.

Practice Exercises

• Create a menu-based contact list program that can add and view contacts.
• Build a score tracker that stores player names and scores in a list of dictionaries.
• Make a note-saving tool that writes user notes to a text file and reads them back.

Mini Project / Task

Build a command-line expense tracker where users can add expenses, view all entries, calculate the total amount spent, and save the records to a file.

Challenge (Optional)

Upgrade your final project so it supports searching, editing, and deleting records while keeping the data saved between program runs.