Python is a general-purpose programming language. “General-purpose” means you can build many types of software with it, not just one category.
  
  Python is famous for one thing: **readability**. A beginner can read Python code and understand what it is doing, and a professional team can still use it to build real products.
  
  ## What Python is (in simple terms)
  
  When you write Python, you write instructions in a `.py` file. When you run the file, the Python interpreter reads your code and executes it line by line.
  
  Python is an **interpreted** language in everyday usage (it runs through an interpreter), which makes it excellent for learning and for fast development.
  
  ## Why companies use Python
  
  Python is popular because it solves real problems efficiently:
  
  - **Web backends**: build APIs and server logic
  - **Automation**: scripts to rename files, scrape data, send emails
  - **Data and reporting**: dashboards, ETL, analytics
  - **AI and machine learning**: training models, building AI services
  - **Testing**: automation tests and tools
  
  ## How Python runs your code
  
  When you run a program, this is the mental model:
  
  1) You write instructions
  2) Python reads them in order
  3) Python executes them and produces output
  
  ```mermaid
  flowchart LR
    A[Write code in .py] --> B[Run python file.py]
    B --> C[Python interpreter executes line by line]
    C --> D[Output / results]
  ```
  
  ## Your first program (and what it means)
  
  ```python
  print("Hello, Python!")
  ```
  
  - `print()` is a built-in function
  - It displays text on the screen
  
  Run:
  
  ```bash
  python hello.py
  ```
  
  Expected output:
  
  ```
  Hello, Python!
  ```
  
  ## The 3 beginner tools you will use most
  
  - **Terminal**: to run Python files
  - **Editor (VS Code)**: to write code
  - **Browser**: to search docs and learn
  
  You do not need fancy setups at the beginning. You need a clean installation, consistent practice, and small projects.
  
  ## How to think like a programmer from day 1
  
  A strong concept that helps you learn faster:
  
  - Programs are not magic
  - A program is a set of instructions
  - The computer follows instructions exactly
  - If your output is wrong, the instructions are wrong or incomplete
  
  ## Common confusion: Python vs Python packages
  
  Python is the language.
  Packages are add-ons (libraries) you install, like:
  - requests (for HTTP)
  - pandas (for data)
  - numpy (for math)
  
  You do not need packages to start learning. First, master core Python.
  
  ## Quick learning checklist
  
  By the end of the first 10 lessons, you should be able to:
  - run Python from terminal
  - use variables, strings, numbers
  - use lists and dictionaries
  - use if statements and loops
  - write functions to reuse logic
  
  In the next lesson, you will install Python correctly and verify the setup so your environment behaves consistently.

Understand what Python is, how it runs your code, and why it is used in web, automation, data, and AI.

Python Introduction

A correct installation prevents most beginner problems. Your goal is simple: when you type `python` in the terminal, it runs Python 3.
  
  ## Step 1: Install Python
  
  Download Python from the official Python website and install it.
  
  ### Windows (important details)
  - Run the installer
  - **Check “Add Python to PATH”**
  - Install for “All Users” if possible
  
  Why PATH matters:
  PATH allows your system to find Python when you type `python` in the terminal.
  
  ### macOS
  - Run the installer package
  - After install, verify in Terminal
  - Some systems require using `python3` instead of `python`
  
  ### Linux
  - Python 3 may already be installed
  - If not, install using your package manager
  
  ## Step 2: Verify your version
  
  Run:
  
  ```bash
  python --version
  ```
  
  Expected output example:
  
  ```
  Python 3.12.0
  ```
  
  If `python` does not work, try:
  
  ```bash
  python3 --version
  ```
  
  ## Step 3: Check that pip works
  
  pip installs packages.
  
  ```bash
  pip --version
  ```
  
  If pip is missing, Python installation may be incomplete.
  
  ## Step 4: VS Code setup (clean beginner setup)
  
  - Install VS Code
  - Install the **Python extension**
  - Choose the correct interpreter inside VS Code
  
  ## Step 5: Run a test file
  
  Create `test.py`:
  
  ```python
  print("Python setup is working.")
  ```
  
  Run:
  
  ```bash
  python test.py
  ```
  
  Expected output:
  
  ```
  Python setup is working.
  ```
  
  ## Setup pipeline (the reason steps matter)
  
  ```mermaid
  flowchart LR
    A[Install Python] --> B[Verify python command]
    B --> C[Verify pip]
    C --> D[Install VS Code + extension]
    D --> E[Run test.py]
  ```
  
  ## Common installation problems (and the exact reason)
  
  - **python not found**: PATH not added
  - **pip not found**: incomplete installation
  - **VS Code runs wrong Python**: interpreter not selected
  
  When you fix the root cause, the same issues do not return.
  
  In the next lesson, you will learn variables, how Python stores information, and how to name your variables like a professional.

Install Python properly, verify it works, and set up VS Code for an ideal beginner workflow.

Python Installation

Variables are how programs store information. A variable is a name that points to a value in memory.
  
  The key idea:
  - You create a variable by assigning a value to it with `=`
  
  ## Create variables
  
  ```python
  name = "John"
  age = 25
  city = "New York"
  is_student = True
  
  print(name)
  print(age)
  print(city)
  print(is_student)
  ```
  
  Expected output:
  
  ```
  John
  25
  New York
  True
  ```
  
  ## What assignment really means
  
  In Python, `=` means “make this name refer to this value”.
  
  ```python
  a = 10
  b = a
  a = 20
  
  print(a)
  print(b)
  ```
  
  Expected output:
  
  ```
  20
  10
  ```
  
  This shows that `b` kept the old value. Python does not “link” them in this simple example.
  
  ## Naming rules (do this from day 1)
  
  Good names tell the reader what the data represents.
  
  ✅ Good:
  
  ```python
  total_price = 120.50
  user_email = "john@example.com"
  items_in_cart = 3
  ```
  
  ❌ Poor:
  
  ```python
  x = 120.50
  temp = "john@example.com"
  n = 3
  ```
  
  ## Python naming style
  
  Python developers mostly use **snake_case**:
  - `user_name`
  - `total_cost`
  - `is_active`
  
  ## Updating variables
  
  ```python
  score = 0
  print(score)
  
  score = 10
  print(score)
  
  score = score + 5
  print(score)
  ```
  
  Expected output:
  
  ```
  0
  10
  15
  ```
  
  ## Graph: name to value
  
  ```mermaid
  flowchart LR
    A[name] --> B["John"]
    C[age] --> D[25]
    E[score] --> F[15]
  ```
  
  ## One concept that prevents bugs
  
  If you see wrong output, check:
  - What value is stored?
  - Where did it change?
  - What line updated it?
  
  That thinking makes debugging easier.
  
  In the next lesson, you will learn data types so you understand what kind of values Python variables can hold.

Learn how variables work in Python, how to name them correctly, and how assignment behaves.

Python Variables

A data type tells you what kind of value you are working with. Python automatically detects types, but you still need to understand them to avoid mistakes.
  
  ## Core types you must know
  
  ```python
  name = "Sarah"                 # str
  age = 30                       # int
  height = 5.6                   # float
  is_working = True              # bool
  cities = ["Boston", "Dallas"]  # list
  person = {"name": "Mike"}      # dict
  ```
  
  ## Why types matter
  
  If you mix types incorrectly, Python will complain.
  
  Example:
  
  ```python
  age = "25"
  # print(age + 5)  # error: can't add string and integer
  ```
  
  Because "25" is text, not a number.
  
  ## Check a type with type()
  
  ```python
  print(type("hello"))
  print(type(10))
  print(type(3.14))
  ```
  
  Expected output:
  
  ```
  <class 'str'>
  <class 'int'>
  <class 'float'>
  ```
  
  ## Type conversion (a daily skill)
  
  Convert string to integer:
  
  ```python
  age_text = "25"
  age = int(age_text)
  print(age + 5)
  ```
  
  Expected output:
  
  ```
  30
  ```
  
  Convert integer to string (useful for messages):
  
  ```python
  count = 7
  message = "Items: " + str(count)
  print(message)
  ```
  
  Expected output:
  
  ```
  Items: 7
  ```
  
  ## Important detail: int(float) does not round
  
  ```python
  price = 19.99
  print(int(price))
  ```
  
  Expected output:
  
  ```
  19
  ```
  
  If you want rounding, use `round()`.
  
  ## Graph: common conversions
  
  ```mermaid
  flowchart LR
    A["'25' (str)"] -->|int()| B["25 (int)"]
    C["7 (int)"] -->|str()| D["'7' (str)"]
    E["19.99 (float)"] -->|int()| F["19 (int)"]
  ```
  
  In the next lesson, you will dive into strings, because most beginner projects involve working with text.

Understand Python’s core data types, when to use them, and how type conversion works safely.

Python Data Types

Strings represent text. They are used in names, messages, file paths, and almost every program you write.
  
  The most important concept:
  - a string is a sequence of characters
  
  ## Creating strings
  
  ```python
  name = "Lisa"
  message = "Hello from Chicago"
  multi_line = """This is
  a multi-line
  string."""
  
  print(name)
  print(message)
  print(multi_line)
  ```
  
  Expected output:
  
  ```
  Lisa
  Hello from Chicago
  This is
  a multi-line
  string.
  ```
  
  ## Indexing (getting characters)
  
  ```python
  text = "Python"
  print(text[0])
  print(text[-1])
  ```
  
  Expected output:
  
  ```
  P
  n
  ```
  
  ## Slicing (getting part of a string)
  
  ```python
  text = "Python"
  print(text[0:3])
  print(text[2:])
  ```
  
  Expected output:
  
  ```
  Pyt
  thon
  ```
  
  ## Strings are immutable (important)
  
  You cannot change a character directly:
  
  ```python
  text = "Python"
  # text[0] = "J"  # this causes an error
  ```
  
  Instead, build a new string:
  
  ```python
  text = "Python"
  new_text = "J" + text[1:]
  print(new_text)
  ```
  
  Expected output:
  
  ```
  Jython
  ```
  
  ## Useful string methods
  
  ```python
  text = "hello world"
  
  print(text.upper())
  print(text.capitalize())
  print(text.replace("world", "Python"))
  print(len(text))
  ```
  
  Expected output:
  
  ```
  HELLO WORLD
  Hello world
  hello Python
  11
  ```
  
  ## Formatting strings (use f-strings)
  
  ```python
  name = "Tom"
  age = 25
  print(f"My name is {name} and I am {age}.")
  ```
  
  Expected output:
  
  ```
  My name is Tom and I am 25.
  ```
  
  ## Graph: string processing pipeline
  
  ```mermaid
  flowchart LR
    A["input text"] --> B[clean/transform]
    B --> C[format into message]
    C --> D[print/output]
  ```
  
  In the next lesson, you will learn numbers and calculations, including what each operator means and when it is used.

Learn strings deeply: creation, indexing, slicing, methods, formatting, and common mistakes.

Python Strings

Numbers are core to programming. Python mainly uses:
  - `int` for whole numbers
  - `float` for decimals
  
  ## Basic arithmetic operators
  
  ```python
  x = 10
  y = 3
  
  print(x + y)
  print(x - y)
  print(x * y)
  print(x / y)
  print(x // y)
  print(x % y)
  print(x ** y)
  ```
  
  Expected output:
  
  ```
  13
  7
  30
  3.3333333333333335
  3
  1
  1000
  ```
  
  ## What each operator means (concept)
  
  - `/` gives true division (usually float)
  - `//` gives floor division (drops decimal)
  - `%` gives remainder
  - `**` is power/exponent
  
  ## Rounding and absolute values
  
  ```python
  print(round(3.7))
  print(round(3.14159, 2))
  print(abs(-10))
  ```
  
  Expected output:
  
  ```
  4
  3.14
  10
  ```
  
  ## math module (advanced operations)
  
  ```python
  import math
  
  print(math.sqrt(16))
  print(math.floor(3.7))
  print(math.ceil(3.1))
  ```
  
  Expected output:
  
  ```
  4.0
  3
  4
  ```
  
  ## Graph: division behavior
  
  ```mermaid
  flowchart TD
    A["10 / 3"] --> B[3.333... float]
    C["10 // 3"] --> D[3 int]
    E["10 % 3"] --> F[1 remainder]
  ```
  
  In the next lesson, you will learn lists, how indexing works, and how to manipulate collections of data.

Understand integers, floats, operators, rounding, and the math module with practical examples and outputs.

Python Numbers

Lists store multiple values in one variable. They are ordered, and they are mutable (you can change them).
  
  Lists are used everywhere:
  - storing names
  - storing items in a cart
  - storing results from a database
  - storing rows in a CSV file
  
  ## Create a list
  
  ```python
  cities = ["Miami", "Austin", "Denver"]
  print(cities)
  ```
  
  Expected output:
  
  ```
  ['Miami', 'Austin', 'Denver']
  ```
  
  ## Indexing (get items)
  
  ```python
  cities = ["Miami", "Austin", "Denver"]
  
  print(cities[0])
  print(cities[1])
  print(cities[-1])
  ```
  
  Expected output:
  
  ```
  Miami
  Austin
  Denver
  ```
  
  ## Slicing (get part of list)
  
  ```python
  numbers = [10, 20, 30, 40, 50]
  print(numbers[1:4])
  ```
  
  Expected output:
  
  ```
  [20, 30, 40]
  ```
  
  ## Updating a list
  
  ```python
  fruits = ["apple", "banana"]
  
  fruits.append("orange")
  print(fruits)
  
  fruits.remove("banana")
  print(fruits)
  
  fruits[0] = "grape"
  print(fruits)
  ```
  
  Expected output:
  
  ```
  ['apple', 'banana', 'orange']
  ['apple', 'orange']
  ['grape', 'orange']
  ```
  
  ## Sorting (and why it matters)
  
  ```python
  numbers = [3, 1, 4, 1, 5]
  numbers.sort()
  print(numbers)
  ```
  
  Expected output:
  
  ```
  [1, 1, 3, 4, 5]
  ```
  
  ## Graph: list operations
  
  ```mermaid
  flowchart LR
    A[List] --> B[Index access]
    A --> C[Slicing]
    A --> D[append/remove]
    A --> E[sort]
  ```
  
  In the next lesson, you will learn if statements, how conditions work, and how to build decision logic correctly.

Master lists: indexing, slicing, updating, looping, and common list methods with outputs.

Python Lists

If statements let your program choose different paths based on data. This is the foundation of “logic” in programming.
  
  ## The core idea
  
  - A condition evaluates to either **True** or **False**
  - If True, Python runs the indented block
  
  ## Basic if
  
  ```python
  age = 18
  
  if age >= 18:
      print("You can vote.")
  ```
  
  Expected output:
  
  ```
  You can vote.
  ```
  
  ## if / else
  
  ```python
  temperature = 75
  
  if temperature > 80:
      print("It's hot in Phoenix.")
  else:
      print("Nice weather in Seattle.")
  ```
  
  Expected output:
  
  ```
  Nice weather in Seattle.
  ```
  
  ## if / elif / else
  
  ```python
  score = 85
  
  if score >= 90:
      print("Grade: A")
  elif score >= 80:
      print("Grade: B")
  elif score >= 70:
      print("Grade: C")
  else:
      print("Grade: F")
  ```
  
  Expected output:
  
  ```
  Grade: B
  ```
  
  ## Comparisons you must know
  
  ```python
  x = 10
  print(x == 10)
  print(x != 5)
  print(x > 5)
  print(x <= 10)
  ```
  
  Expected output:
  
  ```
  True
  True
  True
  True
  ```
  
  ## Logical operators: and / or / not
  
  ```python
  age = 25
  has_license = True
  
  if age >= 18 and has_license:
      print("You can drive.")
  ```
  
  Expected output:
  
  ```
  You can drive.
  ```
  
  ## Graph: decision flow
  
  ```mermaid
  flowchart TD
    A[Check condition] --> B{True?}
    B -->|Yes| C[Run block]
    B -->|No| D[Skip or next condition]
  ```
  
  In the next lesson, you will learn loops so you can repeat actions without copying and pasting code.

Learn conditions, comparisons, and clean decision-making using if, elif, and else with practical examples and outputs.

Python If Statements

Loops repeat code. They are essential for handling collections and repeating tasks.
  
  Two main loop types:
  - `for`: repeat over items (lists, ranges)
  - `while`: repeat until a condition becomes false
  
  ## for loop (over a list)
  
  ```python
  cities = ["Boston", "Portland", "Atlanta"]
  
  for city in cities:
      print(city)
  ```
  
  Expected output:
  
  ```
  Boston
  Portland
  Atlanta
  ```
  
  ## for loop with range()
  
  ```python
  for i in range(5):
      print(i)
  ```
  
  Expected output:
  
  ```
  0
  1
  2
  3
  4
  ```
  
  ## while loop (repeat until condition changes)
  
  ```python
  count = 0
  
  while count < 3:
      print(count)
      count += 1
  ```
  
  Expected output:
  
  ```
  0
  1
  2
  ```
  
  ## break and continue
  
  break stops the loop:
  
  ```python
  for i in range(6):
      if i == 3:
          break
      print(i)
  ```
  
  Expected output:
  
  ```
  0
  1
  2
  ```
  
  continue skips one iteration:
  
  ```python
  for i in range(5):
      if i == 2:
          continue
      print(i)
  ```
  
  Expected output:
  
  ```
  0
  1
  3
  4
  ```
  
  ## Graph: loop cycle
  
  ```mermaid
  flowchart TD
    A[Start] --> B{Condition/Items left?}
    B -->|Yes| C[Run body]
    C --> D[Update / next item]
    D --> B
    B -->|No| E[Exit]
  ```
  
  In the next lesson, you will learn functions so your code becomes reusable and easier to maintain.

Learn for loops, while loops, and loop control statements (break/continue) with output examples and mental models.

Python Loops

Functions let you organize code into reusable blocks. Instead of rewriting the same logic in multiple places, you define it once and call it whenever needed.
  
  ## Why functions matter (real reason)
  
  Without functions:
  - your code becomes repetitive
  - bugs multiply because you fix one place but forget others
  - projects become hard to read
  
  With functions:
  - logic is reusable
  - code is easier to test
  - you build programs like building blocks
  
  ## A simple function
  
  ```python
  def greet():
      print("Hello from Los Angeles!")
  
  greet()
  ```
  
  Expected output:
  
  ```
  Hello from Los Angeles!
  ```
  
  ## Parameters (input to a function)
  
  ```python
  def greet_person(name):
      print(f"Hello {name}!")
  
  greet_person("Emma")
  greet_person("Jack")
  ```
  
  Expected output:
  
  ```
  Hello Emma!
  Hello Jack!
  ```
  
  ## Return values (output from a function)
  
  ```python
  def add(a, b):
      return a + b
  
  result = add(5, 3)
  print(result)
  ```
  
  Expected output:
  
  ```
  8
  ```
  
  ## Default parameters
  
  ```python
  def greet(name, city="Chicago"):
      print(f"Hello {name} from {city}!")
  
  greet("Tom")
  greet("Sarah", "Miami")
  ```
  
  Expected output:
  
  ```
  Hello Tom from Chicago!
  Hello Sarah from Miami!
  ```
  
  ## Multiple return values (tuple return)
  
  ```python
  def get_user():
      name = "David"
      age = 30
      return name, age
  
  user_name, user_age = get_user()
  print(user_name)
  print(user_age)
  ```
  
  Expected output:
  
  ```
  David
  30
  ```
  
  ## Graph: function call lifecycle
  
  ```mermaid
  flowchart LR
    A[Call function] --> B[Run body]
    B --> C{Return?}
    C -->|Yes| D[Send value back]
    C -->|No| E[Finish]
  ```
  
  In the next lesson, you will learn dictionaries, which is one of the most practical data structures in Python and common in API work.

Learn how functions work, how parameters and return values behave, and how to design small reusable functions.

Python Functions

A dictionary stores data as **key-value pairs**. You use dictionaries when you want to look up something by a meaningful key instead of a position.
    
    Think of it like a real dictionary:
    - you search a word (key)
    - you get a meaning (value)
    
    In programming:
    - key: "name"
    - value: "Rachel"
    
    ## Why dictionaries are important
    
    Dictionaries appear everywhere:
    - JSON responses from APIs
    - user profiles (name, email, city)
    - settings/config (theme, language, timeout)
    - counting and grouping (how many times each word appears)
    
    ## Create a dictionary
    
    ```python
    person = {
        "name": "Rachel",
        "age": 28,
        "city": "Houston"
    }
    
    print(person)
    ```
    
    Expected output:
    
    ```
    {'name': 'Rachel', 'age': 28, 'city': 'Houston'}
    ```
    
    ## Access values (strict vs safe)
    
    ### Strict access using brackets
    ```python
    print(person["name"])
    ```
    
    Expected output:
    
    ```
    Rachel
    ```
    
    If the key is missing, Python throws a `KeyError`.
    
    ### Safe access using get()
    ```python
    print(person.get("age"))
    print(person.get("email", "Not found"))
    ```
    
    Expected output:
    
    ```
    28
    Not found
    ```
    
    Use `get()` when the key might not exist.
    
    ## Add, update, and remove keys
    
    ```python
    person = {"name": "Mark", "age": 25}
    
    person["city"] = "Dallas"   # add
    person["age"] = 26          # update
    
    del person["age"]           # remove
    
    print(person)
    ```
    
    Expected output:
    
    ```
    {'name': 'Mark', 'city': 'Dallas'}
    ```
    
    ## Loop through dictionaries
    
    Keys:
    
    ```python
    person = {"name": "Lisa", "age": 30, "city": "Phoenix"}
    
    for key in person:
        print(key)
    ```
    
    Expected output:
    
    ```
    name
    age
    city
    ```
    
    Values:
    
    ```python
    for value in person.values():
        print(value)
    ```
    
    Expected output:
    
    ```
    Lisa
    30
    Phoenix
    ```
    
    Keys + values:
    
    ```python
    for key, value in person.items():
        print(f"{key}: {value}")
    ```
    
    Expected output:
    
    ```
    name: Lisa
    age: 30
    city: Phoenix
    ```
    
    ## Real pattern: counting items with a dictionary
    
    This is a common interview and real-work pattern.
    
    ```python
    words = ["apple", "banana", "apple", "orange", "banana", "apple"]
    counts = {}
    
    for w in words:
        counts[w] = counts.get(w, 0) + 1
    
    print(counts)
    ```
    
    Expected output:
    
    ```
    {'apple': 3, 'banana': 2, 'orange': 1}
    ```
    
    ## Graph: dictionary lookup
    
    ```mermaid
    flowchart LR
      A["key: 'name'"] --> B[(dict)]
      B --> C["value: 'Rachel'"]
      D["key: 'email'"] --> B --> E["default: 'Not found'"]
    ```
    
    In the next lesson, you will learn tuples, a “fixed” sequence type used for data that should not change.

Learn dictionaries deeply: key-value pairs, safe lookups, updates, looping, and common real-world patterns.

Python Dictionaries

A tuple is similar to a list, but with one key difference: **tuples are immutable** (you cannot change them after creation).
    
    Tuples are used for:
    - coordinates (lat, lon)
    - RGB colors
    - returning multiple values from a function
    - fixed records that shouldn’t be edited
    
    ## Create tuples
    
    ```python
    coordinates = (40.7128, -74.0060)  # New York
    colors = ("red", "green", "blue")
    single = (5,)  # 1-item tuple needs a comma
    
    print(coordinates)
    print(colors)
    print(single)
    ```
    
    Expected output:
    
    ```
    (40.7128, -74.006)
    ('red', 'green', 'blue')
    (5,)
    ```
    
    ## Access tuple items
    
    ```python
    point = (10, 20, 30)
    
    print(point[0])
    print(point[-1])
    ```
    
    Expected output:
    
    ```
    10
    30
    ```
    
    ## Tuples vs lists (what changes)
    
    ```python
    cities = ["Miami", "Austin"]
    cities[0] = "Denver"
    print(cities)
    
    coords = (10, 20)
    # coords[0] = 15  # would error
    print(coords)
    ```
    
    Expected output:
    
    ```
    ['Denver', 'Austin']
    (10, 20)
    ```
    
    ## Unpacking tuples (very common)
    
    ```python
    lat, lon = (34.0522, -118.2437)  # Los Angeles
    print(lat)
    print(lon)
    ```
    
    Expected output:
    
    ```
    34.0522
    -118.2437
    ```
    
    ## Real concept: why immutability helps
    
    Immutability prevents accidental edits. If your coordinates change by mistake, your map logic breaks. Tuples protect fixed data.
    
    ## Graph: list vs tuple
    
    ```mermaid
    flowchart TD
      A[List] --> B[Mutable, can update]
      A --> C[append/remove allowed]
      D[Tuple] --> E[Immutable, fixed values]
      D --> F[Best for constant data]
    ```
    
    In the next lesson, you will learn sets, which are designed for uniqueness and fast membership checks.

Understand tuples, immutability, unpacking, and when tuples are better than lists.

Python Tuples

A set is an unordered collection of **unique** values.
    
    Use sets when:
    - you need to remove duplicates
    - you want fast membership checks: `x in set`
    - you want to compare groups (common items, missing items)
    
    ## Create a set (duplicates auto removed)
    
    ```python
    unique_numbers = {1, 2, 2, 3, 3, 3}
    print(unique_numbers)
    ```
    
    Expected output:
    
    ```
    {1, 2, 3}
    ```
    
    ## Add and remove
    
    ```python
    fruits = {"apple", "banana"}
    
    fruits.add("orange")
    print(fruits)
    
    fruits.remove("banana")
    print(fruits)
    
    fruits.discard("grape")  # safe remove
    print(fruits)
    ```
    
    Expected output (order may vary):
    
    ```
    {'orange', 'apple', 'banana'}
    {'orange', 'apple'}
    {'orange', 'apple'}
    ```
    
    ## Set operations (powerful part)
    
    ```python
    east = {"New York", "Boston", "Miami"}
    west = {"Los Angeles", "Seattle", "Denver"}
    south = {"Miami", "Houston", "Austin"}
    
    print(east | west)    # union
    print(east & south)   # intersection
    print(east - south)   # difference
    ```
    
    Expected output (order may vary):
    
    ```
    {'New York', 'Boston', 'Miami', 'Los Angeles', 'Seattle', 'Denver'}
    {'Miami'}
    {'New York', 'Boston'}
    ```
    
    ## Membership checks (fast)
    
    ```python
    cities = {"Chicago", "Dallas", "Phoenix"}
    print("Chicago" in cities)
    print("Seattle" not in cities)
    ```
    
    Expected output:
    
    ```
    True
    True
    ```
    
    ## Graph: how set operations relate
    
    ```mermaid
    flowchart LR
      A[east] --> B[intersection]
      C[south] --> B
      B --> D[common elements]
      A --> E[union]
      F[west] --> E
      E --> G[all unique]
    ```
    
    In the next lesson, you will learn input and output so your program can interact with users.

Learn sets for unique values, membership checks, and set operations like union and intersection with clear examples.

Python Sets

Input and output are how your program communicates with a user through the terminal.
    
    - **Output**: `print()`
    - **Input**: `input()`
    
    ## Printing output
    
    ```python
    print("Hello World")
    print("Welcome", "to", "Python")
    
    print("""Line 1
    Line 2
    Line 3""")
    ```
    
    Expected output:
    
    ```
    Hello World
    Welcome to Python
    Line 1
    Line 2
    Line 3
    ```
    
    ## Getting user input
    
    ```python
    name = input("What's your name? ")
    print(f"Hello {name}!")
    ```
    
    Example:
    
    ```
    What's your name? Rachel
    Hello Rachel!
    ```
    
    ## Very important concept: input() returns a string
    
    Even when a user types `20`, Python reads it as text.
    
    ```python
    age_text = input("Enter your age: ")
    print(type(age_text))
    ```
    
    Example:
    
    ```
    Enter your age: 20
    <class 'str'>
    ```
    
    So you convert:
    
    ```python
    age = int(age_text)
    ```
    
    ## Type conversion example with logic
    
    ```python
    age = int(input("Enter your age: "))
    
    if age >= 18:
        print("You're an adult.")
    else:
        print("You're under 18.")
    ```
    
    Example:
    
    ```
    Enter your age: 15
    You're under 18.
    ```
    
    ## Print formatting: sep and end
    
    ```python
    print("apple", "banana", "cherry", sep=", ")
    print("Loading", end="...")
    print("Done!")
    ```
    
    Expected output:
    
    ```
    apple, banana, cherry
    Loading...Done!
    ```
    
    ## Graph: input to output
    
    ```mermaid
    flowchart TD
      A[input()] --> B["string value"]
      B --> C[int()/float() if needed]
      C --> D[logic]
      D --> E[print output]
    ```
    
    In the next lesson, you will learn file handling so your program can save and read information from disk.

Learn how to take user input safely, convert types, and print clean output like a professional program.

Python Input Output

File handling lets your program store information outside the program run. This is how apps create logs, save reports, and manage data files.
    
    The most important rule: use `with` so the file closes automatically.
    
    ## Write to a file
    
    ```python
    with open("notes.txt", "w") as file:
        file.write("Hello from San Diego!")
    ```
    
    Now `notes.txt` exists and contains one line.
    
    ## Read the file
    
    ```python
    with open("notes.txt", "r") as file:
        content = file.read()
    
    print(content)
    ```
    
    Expected output:
    
    ```
    Hello from San Diego!
    ```
    
    ## Append to the file
    
    ```python
    with open("notes.txt", "a") as file:
        file.write("\nNew line added!")
    ```
    
    Read again:
    
    ```python
    with open("notes.txt", "r") as file:
        print(file.read())
    ```
    
    Expected output:
    
    ```
    Hello from San Diego!
    New line added!
    ```
    
    ## Read line by line (best for large files)
    
    ```python
    with open("notes.txt", "r") as file:
        for line in file:
            print(line.strip())
    ```
    
    Expected output:
    
    ```
    Hello from San Diego!
    New line added!
    ```
    
    ## Handling missing file error
    
    ```python
    try:
        with open("missing.txt", "r") as file:
            print(file.read())
    except FileNotFoundError:
        print("The file does not exist.")
    ```
    
    Expected output:
    
    ```
    The file does not exist.
    ```
    
    ## Graph: safe file workflow
    
    ```mermaid
    flowchart TD
      A[Open with 'with'] --> B{File exists?}
      B -->|Yes| C[Read/Write]
      B -->|No| D[Handle error]
      C --> E[Auto close]
      D --> E[Auto close]
    ```
    
    In the next lesson, you will start intermediate Python with list comprehensions, which help you write cleaner data transformations.

Learn how to read, write, append, and handle file errors using best-practice patterns with clear outputs.

Python File Handling

List comprehensions create lists in a compact, readable way. They are perfect when your logic is straightforward.
    
    A list comprehension is basically:
    - loop + optional filter + transform
    - written in one line
    
    ## Basic example: squares
    
    Loop version:
    
    ```python
    squares = []
    for i in range(5):
        squares.append(i ** 2)
    
    print(squares)
    ```
    
    Comprehension version:
    
    ```python
    squares = [i ** 2 for i in range(5)]
    print(squares)
    ```
    
    Expected output:
    
    ```
    [0, 1, 4, 9, 16]
    ```
    
    ## With a condition (filtering)
    
    ```python
    evens = [i for i in range(10) if i % 2 == 0]
    print(evens)
    ```
    
    Expected output:
    
    ```
    [0, 2, 4, 6, 8]
    ```
    
    ## Transform data (very common)
    
    ```python
    cities = ["miami", "austin", "denver"]
    upper_cities = [city.upper() for city in cities]
    print(upper_cities)
    ```
    
    Expected output:
    
    ```
    ['MIAMI', 'AUSTIN', 'DENVER']
    ```
    
    ## Nested comprehensions (use carefully)
    
    ```python
    matrix = [[i * j for j in range(3)] for i in range(3)]
    print(matrix)
    ```
    
    Expected output:
    
    ```
    [[0, 0, 0], [0, 1, 2], [0, 2, 4]]
    ```
    
    ## Graph: comprehension mental model
    
    ```mermaid
    flowchart LR
      A[Iterable] --> B[Optional filter]
      B --> C[Transform]
      C --> D[New list]
    ```
    
    Rule: if a comprehension becomes hard to read, use a normal loop. Readability matters more than “one line”.
    
    In the next lesson, you will learn lambda functions and where they fit in real code.

Learn list comprehensions deeply: when to use them, how they work, and how to keep them readable.

Python List Comprehension

A lambda is a small anonymous function written in one line. It is useful when your logic is short and you do not want to define a full function with `def`.
    
    Important rule:
    If the lambda becomes long, write a normal function.
    
    ## Lambda basics
    
    ```python
    add = lambda x, y: x + y
    print(add(3, 5))
    ```
    
    Expected output:
    
    ```
    8
    ```
    
    ## Most common real use: sorting
    
    ```python
    people = [
        {"name": "Tom", "age": 25},
        {"name": "Sarah", "age": 22},
        {"name": "Mike", "age": 30}
    ]
    
    people.sort(key=lambda person: person["age"])
    print(people)
    ```
    
    Expected output:
    
    ```
    [{'name': 'Sarah', 'age': 22}, {'name': 'Tom', 'age': 25}, {'name': 'Mike', 'age': 30}]
    ```
    
    ## map and filter examples
    
    ```python
    numbers = [1, 2, 3, 4]
    doubled = list(map(lambda x: x * 2, numbers))
    print(doubled)
    ```
    
    Expected output:
    
    ```
    [2, 4, 6, 8]
    ```
    
    ```python
    ages = [15, 22, 18, 30, 12]
    adults = list(filter(lambda age: age >= 18, ages))
    print(adults)
    ```
    
    Expected output:
    
    ```
    [22, 18, 30]
    ```
    
    ## Graph: lambda usage pattern
    
    ```mermaid
    flowchart LR
      A[Data] --> B[sort/map/filter]
      B --> C[lambda expression]
      C --> D[Result]
    ```
    
    In the next lesson, you will learn try/except, which helps your program handle errors without crashing.

Use lambda for short one-line logic, especially sorting and quick transformations, without hurting readability.

Python Lambda Functions

In real programs, errors are normal. A user might type a wrong input, or a file might be missing. Error handling lets your program fail safely with a helpful message.
    
    ## Basic try/except
    
    ```python
    try:
        number = int(input("Enter a number: "))
        print(10 / number)
    except Exception:
        print("Something went wrong.")
    ```
    
    This works, but it is too general. It hides the real reason.
    
    ## Catch specific exceptions (best practice)
    
    ```python
    try:
        number = int(input("Enter a number: "))
        result = 10 / number
        print(result)
    except ValueError:
        print("Please enter a valid number (like 2 or 10).")
    except ZeroDivisionError:
        print("Division by zero is not allowed.")
    ```
    
    Example:
    
    ```
    Enter a number: 0
    Division by zero is not allowed.
    ```
    
    ## else and finally
    
    - `else` runs if no error happened
    - `finally` runs no matter what, good for cleanup
    
    ```python
    try:
        with open("data.txt", "r") as file:
            content = file.read()
    except FileNotFoundError:
        print("File not found.")
    else:
        print("File read successfully.")
    finally:
        print("Done.")
    ```
    
    ## Raise your own error
    
    ```python
    def check_age(age: int) -> None:
        if age < 0:
            raise ValueError("Age cannot be negative.")
        if age < 18:
            print("Too young.")
        else:
            print("Welcome!")
    
    check_age(25)
    ```
    
    Expected output:
    
    ```
    Welcome!
    ```
    
    ## Graph: error handling flow
    
    ```mermaid
    flowchart TD
      A[Try block] --> B{Error?}
      B -->|No| C[Else block]
      B -->|Yes| D[Except block]
      C --> E[Finally]
      D --> E[Finally]
    ```
    
    In the next lesson, you will learn modules and imports so your Python code can be organized into multiple files like a real project.

Handle errors professionally using try/except, specific exceptions, else/finally, and raising your own exceptions.

Python Try Except

As soon as your code grows, one file becomes messy. Modules let you split code into multiple files and reuse functions cleanly.
    
    ## Import built-in modules
    
    ```python
    import math
    
    print(math.sqrt(16))
    print(round(math.pi, 4))
    ```
    
    Expected output:
    
    ```
    4.0
    3.1416
    ```
    
    ## Import specific items
    
    ```python
    from math import sqrt, pi
    
    print(sqrt(25))
    print(pi)
    ```
    
    Expected output:
    
    ```
    5.0
    3.141592653589793
    ```
    
    ## Aliases (common in real projects)
    
    ```python
    import datetime as dt
    
    now = dt.datetime.now()
    print(now)
    ```
    
    Expected output example:
    
    ```
    2025-12-18 14:20:33.123456
    ```
    
    ## Create your own module
    
    Create `mymodule.py`:
    
    ```python
    def greet(name: str) -> str:
        return f"Hello {name} from Seattle!"
    
    def add(a: int, b: int) -> int:
        return a + b
    ```
    
    Create `main.py`:
    
    ```python
    import mymodule
    
    print(mymodule.greet("Tom"))
    print(mymodule.add(5, 3))
    ```
    
    Expected output:
    
    ```
    Hello Tom from Seattle!
    8
    ```
    
    ## Graph: import flow
    
    ```mermaid
    flowchart LR
      A[main.py] --> B[import mymodule]
      B --> C[Python loads mymodule.py]
      C --> D[Functions ready]
      D --> E[Call functions]
    ```
    
    In the next lesson, you will learn packages and virtual environments so each project can keep dependencies clean and avoid conflicts.

Learn imports, aliases, and how to create your own module so projects stay clean and reusable.

Python Modules

As soon as you install third-party packages, you need a clean way to keep project dependencies separate.
    
    A virtual environment is basically a project-specific Python + site-packages folder.
    
    Why it matters:
    - Project A might need `requests` version 2.31
    - Project B might need a different version
    - Without venv, packages collide and projects break
    
    ## Create a virtual environment
    
    Inside your project folder:
    
    ```bash
    python -m venv .venv
    ```
    
    ## Activate it
    
    ### Windows (PowerShell)
    ```bash
    .venv\Scripts\Activate.ps1
    ```
    
    ### macOS/Linux
    ```bash
    source .venv/bin/activate
    ```
    
    After activation, your terminal usually shows `(.venv)`.
    
    ## Install a package inside the venv
    
    ```bash
    pip install requests
    ```
    
    ## Freeze dependencies (share with others)
    
    ```bash
    pip freeze > requirements.txt
    ```
    
    Later, anyone can install:
    
    ```bash
    pip install -r requirements.txt
    ```
    
    ## Deactivate
    
    ```bash
    deactivate
    ```
    
    ## Graph: dependency isolation
    
    ```mermaid
    flowchart LR
      A[Project A] --> B[(venv A)]
      C[Project B] --> D[(venv B)]
      B --> E[Packages A]
      D --> F[Packages B]
    ```
    
    Now Project A and Project B do not conflict.
    
    This is one of the most important habits to build early, because it saves hours of debugging later.

Understand why virtual environments matter, how to create them, and how they prevent dependency conflicts in real projects.

Python Virtual Environments

Inheritance is an OOP feature that lets one class **reuse** and **extend** another class.
      
      Think of it like a blueprint:
      - A **parent class** defines common behavior.
      - A **child class** inherits it, then adds or changes what it needs.
      
      Inheritance solves a real problem:
      When you have multiple classes that share the same logic, you do not want to copy-paste that logic everywhere.
      
      ## When inheritance is a good idea (and when it is not)
      
      Inheritance is good when:
      - classes share a clear "is-a" relationship  
        Example: Dog is an Animal, Car is a Vehicle
      
      Inheritance is not ideal when:
      - the relationship is "has-a"  
        Example: A Car has an Engine (composition is better)
      
      If you are unsure, start with simple classes. Use inheritance only when the relationship is natural.
      
      ## Basic inheritance (parent and child)
      
      ```python
      class Animal:
          def __init__(self, name):
              self.name = name
      
          def speak(self):
              print("Some sound")
      
      class Dog(Animal):
          def speak(self):
              print(f"{self.name} says Woof!")
      
      class Cat(Animal):
          def speak(self):
              print(f"{self.name} says Meow!")
      
      dog = Dog("Max")
      cat = Cat("Whiskers")
      
      dog.speak()
      cat.speak()
      ```
      
      Expected output:
      
      ```
      Max says Woof!
      Whiskers says Meow!
      ```
      
      ### What happened here?
      
      - `Dog` and `Cat` **inherit** `name` from `Animal`
      - They **override** `speak()` so each animal speaks differently
      
      ## Method overriding (same method name, different behavior)
      
      If the child defines a method with the same name as the parent, the child version runs.
      
      ```python
      class Animal:
          def speak(self):
              print("Some sound")
      
      class Dog(Animal):
          def speak(self):
              print("Woof!")
      
      Dog().speak()
      ```
      
      Expected output:
      
      ```
      Woof!
      ```
      
      ## Using super() correctly
      
      `super()` lets the child call the parent’s version of a method. This is extremely common in real code for constructors.
      
      ```python
      class Vehicle:
          def __init__(self, brand):
              self.brand = brand
      
          def info(self):
              print(f"Brand: {self.brand}")
      
      class Car(Vehicle):
          def __init__(self, brand, model):
              super().__init__(brand)   # initialize parent part
              self.model = model        # initialize child part
      
          def info(self):
              super().info()            # parent info
              print(f"Model: {self.model}")
      
      car = Car("Tesla", "Model 3")
      car.info()
      ```
      
      Expected output:
      
      ```
      Brand: Tesla
      Model: Model 3
      ```
      
      ## Multiple inheritance (use carefully)
      
      Python allows a class to inherit from multiple parents. This is powerful but can get confusing if overused.
      
      ```python
      class Walker:
          def walk(self):
              print("Walking...")
      
      class Swimmer:
          def swim(self):
              print("Swimming...")
      
      class Duck(Walker, Swimmer):
          pass
      
      duck = Duck()
      duck.walk()
      duck.swim()
      ```
      
      Expected output:
      
      ```
      Walking...
      Swimming...
      ```
      
      ## Graph: inheritance structure
      
      ```mermaid
      classDiagram
        Animal <|-- Dog
        Animal <|-- Cat
        class Animal {
          +name
          +speak()
        }
        class Dog {
          +speak()
        }
        class Cat {
          +speak()
        }
      ```
      
      ## Common beginner mistakes
      
      - Using inheritance just to “reuse code” without a real relationship
      - Forgetting to call `super().__init__()` in the child class
      - Making deep inheritance chains (hard to maintain)
      
      A good rule:
      Keep inheritance shallow and readable. If your class tree looks like a family tree with 10 generations, it will be hard to debug.
      
      In the next lesson, you will learn JSON handling, which is one of the most practical skills for API work in Python.

Learn inheritance step by step: parent vs child classes, method overriding, super(), and safe patterns used in real projects.

Python Inheritance

JSON is the most common data format used by APIs. If you work with web services, you will see JSON daily.
      
      Important concept:
      - In Python, JSON maps naturally to dictionaries and lists.
      - JSON object → Python dict
      - JSON array → Python list
      
      ## Python object to JSON string
      
      ```python
      import json
      
      person = {
          "name": "Alice",
          "age": 28,
          "city": "Portland"
      }
      
      json_string = json.dumps(person)
      print(json_string)
      ```
      
      Expected output:
      
      ```
      {"name": "Alice", "age": 28, "city": "Portland"}
      ```
      
      ### Pretty print JSON (good for debugging)
      
      ```python
      json_pretty = json.dumps(person, indent=2)
      print(json_pretty)
      ```
      
      Expected output:
      
      ```
      {
        "name": "Alice",
        "age": 28,
        "city": "Portland"
      }
      ```
      
      ## JSON string to Python object
      
      ```python
      import json
      
      json_string = '{"name": "Bob", "age": 30}'
      person = json.loads(json_string)
      
      print(person)
      print(person["name"])
      ```
      
      Expected output:
      
      ```
      {'name': 'Bob', 'age': 30}
      Bob
      ```
      
      ## Read JSON from a file (load)
      
      ```python
      import json
      
      with open("data.json", "r") as file:
          data = json.load(file)
      
      print(data)
      ```
      
      ## Write JSON to a file (dump)
      
      ```python
      import json
      
      data = {
          "users": [
              {"name": "Tom", "city": "Austin"},
              {"name": "Sarah", "city": "Miami"}
          ]
      }
      
      with open("users.json", "w") as file:
          json.dump(data, file, indent=2)
      ```
      
      ## dumps vs dump (simple rule)
      
      - `dumps()` → returns a **string**
      - `dump()` → writes to a **file**
      
      - `loads()` → converts a **string**
      - `load()` → reads from a **file**
      
      ## Graph: JSON flow in real projects
      
      ```mermaid
      flowchart LR
        A[Python dict/list] -->|json.dumps| B[JSON string]
        B -->|send to API| C[Network]
        C -->|receive JSON| D[JSON string]
        D -->|json.loads| E[Python dict/list]
      ```
      
      ## Practical tip: JSON numbers, booleans, null
      
      - JSON `true/false` → Python `True/False`
      - JSON `null` → Python `None`
      
      If you see `None`, that often means “missing” or “no value”.
      
      In the next lesson, you will learn datetime, because handling dates correctly is a real-world skill in APIs, databases, and logs.

Learn JSON end to end: dumps vs dump, loads vs load, reading and writing files, and common real-world API patterns.

Python JSON Handling

Dates and times are tricky in every language. Python provides the `datetime` module to handle them safely.
      
      You will commonly do four things:
      1) get the current time
      2) convert a string into a date (parsing)
      3) format a date into a string
      4) add/subtract time (timedelta)
      
      ## Date vs datetime (important difference)
      
      - `date`: only year-month-day
      - `datetime`: year-month-day + hours-minutes-seconds
      
      ## Get current date and time
      
      ```python
      from datetime import datetime, date
      
      now = datetime.now()
      today = date.today()
      
      print(now)
      print(today)
      ```
      
      Expected output example:
      
      ```
      2025-12-18 14:30:45.123456
      2025-12-18
      ```
      
      ## Create a specific date/time
      
      ```python
      from datetime import datetime
      
      birthday = datetime(1995, 6, 15, 9, 30)  # June 15, 1995 09:30
      print(birthday)
      ```
      
      Expected output:
      
      ```
      1995-06-15 09:30:00
      ```
      
      ## Parse a date string (strptime)
      
      You must match the pattern exactly.
      
      ```python
      from datetime import datetime
      
      date_str = "2025-12-18"
      date_obj = datetime.strptime(date_str, "%Y-%m-%d")
      
      print(date_obj)
      ```
      
      Expected output:
      
      ```
      2025-12-18 00:00:00
      ```
      
      ## Format a date into a string (strftime)
      
      ```python
      from datetime import datetime
      
      now = datetime(2025, 12, 18, 14, 30)
      
      print(now.strftime("%B %d, %Y"))  # Month day, Year
      print(now.strftime("%m/%d/%Y"))   # US format
      print(now.strftime("%Y-%m-%d"))   # ISO-like
      ```
      
      Expected output:
      
      ```
      December 18, 2025
      12/18/2025
      2025-12-18
      ```
      
      ## Date arithmetic (timedelta)
      
      ```python
      from datetime import datetime, timedelta
      
      today = datetime(2025, 12, 18)
      
      tomorrow = today + timedelta(days=1)
      last_week = today - timedelta(weeks=1)
      
      print(tomorrow)
      print(last_week)
      ```
      
      Expected output:
      
      ```
      2025-12-19 00:00:00
      2025-12-11 00:00:00
      ```
      
      ## Graph: parsing and formatting
      
      ```mermaid
      flowchart LR
        A["'2025-12-18' (string)"] -->|strptime| B[datetime object]
        B -->|strftime| C["'December 18, 2025' (string)"]
        B -->|+ timedelta| D[new datetime]
      ```
      
      ## Beginner warning: time zones
      
      This lesson uses local time for simplicity. In real apps, time zones matter a lot. The safest professional approach is:
      - store timestamps in UTC
      - convert to local time only when showing to the user
      
      In the next lesson, you will learn regex, which helps you validate and extract information from text like emails, phone numbers, and IDs.

Learn datetime step by step: date vs datetime, parsing strings, formatting, and doing time arithmetic correctly.

Python Datetime

Regular expressions (regex) help you search and manipulate text using patterns.
      
      Regex is useful when:
      - validating input (email, phone, password rules)
      - extracting data from text (IDs, dates, links)
      - cleaning messy text (remove extra spaces, mask numbers)
      
      Important: regex is powerful, but keep patterns readable. If the pattern becomes too complex, you can often solve the problem with normal string logic.
      
      ## Basic search (find one match)
      
      ```python
      import re
      
      text = "My phone is 555-1234"
      match = re.search(r"\d{3}-\d{4}", text)
      
      if match:
          print(match.group())
      ```
      
      Expected output:
      
      ```
      555-1234
      ```
      
      ### Pattern meaning
      - `\d` = a digit
      - `{3}` = exactly 3 times
      - `-` = literal dash
      - `{4}` = exactly 4 digits
      
      ## Find all matches
      
      ```python
      import re
      
      text = "Contact: john@example.com or sarah@test.com"
      emails = re.findall(r"[\w.-]+@[\w.-]+", text)
      
      print(emails)
      ```
      
      Expected output:
      
      ```
      ['john@example.com', 'sarah@test.com']
      ```
      
      ## Replace text (masking)
      
      ```python
      import re
      
      text = "My number is 123-456-7890"
      new_text = re.sub(r"\d{3}-\d{3}-\d{4}", "XXX-XXX-XXXX", text)
      
      print(new_text)
      ```
      
      Expected output:
      
      ```
      My number is XXX-XXX-XXXX
      ```
      
      ## Groups (extract parts)
      
      ```python
      import re
      
      text = "Order ID: 8459"
      match = re.search(r"Order ID: (\d+)", text)
      
      if match:
          order_id = match.group(1)
          print(order_id)
      ```
      
      Expected output:
      
      ```
      8459
      ```
      
      ## Common patterns (simple and useful)
      
      ```python
      import re
      
      email = "user@example.com"
      print(bool(re.match(r"^[\w.-]+@[\w.-]+\.\w+$", email)))
      
      phone = "555-1234"
      print(bool(re.match(r"^\d{3}-\d{4}$", phone)))
      ```
      
      Expected output:
      
      ```
      True
      True
      ```
      
      ## Graph: regex workflow
      
      ```mermaid
      flowchart LR
        A[Raw text] --> B[Regex pattern]
        B --> C{search/findall/sub}
        C --> D[Match / list / replaced text]
      ```
      
      ## Beginner mistakes to avoid
      
      - Forgetting to use raw strings: always prefer `r"pattern"`
      - Writing patterns that are too strict or too loose
      - Using regex for everything (sometimes normal string methods are better)
      
      In the next lesson, you will learn decorators, a powerful Python feature used in web frameworks and professional codebases.

Learn regex with practical patterns: search, findall, replace, groups, and how to avoid common regex mistakes.

Python Regular Expressions

Decorators are a Python feature that lets you **wrap** a function to add extra behavior without changing the function’s core logic.
      
      Think of it like adding a cover on a phone:
      - the phone stays the same
      - the cover adds protection and extra features
      
      In code:
      - your function stays the same
      - the decorator adds timing, logging, validation, permissions, and more
      
      ## Step 1: functions can be passed around
      
      ```python
      def greet():
          return "hello"
      
      def call_function(func):
          return func()
      
      print(call_function(greet))
      ```
      
      Expected output:
      
      ```
      hello
      ```
      
      ## Step 2: a decorator is a function that returns a new function
      
      ```python
      def uppercase_decorator(func):
          def wrapper():
              result = func()
              return result.upper()
          return wrapper
      
      @uppercase_decorator
      def greet():
          return "hello from boston"
      
      print(greet())
      ```
      
      Expected output:
      
      ```
      HELLO FROM BOSTON
      ```
      
      ### What changed?
      
      - You still call `greet()`
      - But now it runs through `wrapper()` first
      
      ## Decorators with arguments (repeat example)
      
      ```python
      def repeat(times):
          def decorator(func):
              def wrapper(*args, **kwargs):
                  for _ in range(times):
                      func(*args, **kwargs)
              return wrapper
          return decorator
      
      @repeat(3)
      def say_hi(name):
          print(f"Hi {name}!")
      
      say_hi("Tom")
      ```
      
      Expected output:
      
      ```
      Hi Tom!
      Hi Tom!
      Hi Tom!
      ```
      
      ## Real-world example: timing a function
      
      ```python
      import time
      
      def timer(func):
          def wrapper(*args, **kwargs):
              start = time.time()
              result = func(*args, **kwargs)
              end = time.time()
              print(f"Time: {end - start:.4f}s")
              return result
          return wrapper
      
      @timer
      def slow_function():
          time.sleep(1)
          print("Done!")
      
      slow_function()
      ```
      
      Expected output example:
      
      ```
      Done!
      Time: 1.00xxs
      ```
      
      ## Graph: decorator flow
      
      ```mermaid
      flowchart LR
        A[Call function] --> B[Decorator wrapper]
        B --> C[Original function]
        C --> D[Return result]
        D --> E[Decorator adds behavior]
      ```
      
      ## Common decorator mistakes
      
      - forgetting `*args, **kwargs` (breaks functions that take parameters)
      - not returning the function result when needed
      - writing decorators that hide errors
      
      In the next lesson, you will learn generators, which help you process large data efficiently without loading everything into memory.

Understand decorators deeply: why they exist, how wrapper functions work, decorators with args, and real use cases like logging and access control.

Python Decorators

Generators help you produce values **one at a time** instead of creating a full list in memory.
      
      This matters when:
      - you process huge files
      - you handle many records from a database
      - you stream data (logs, events, sensors)
      
      ## Generator vs list (big idea)
      
      - List creates everything now (eager)
      - Generator creates one item when asked (lazy)
      
      ## Basic generator with yield
      
      ```python
      def count_up_to(n):
          count = 1
          while count <= n:
              yield count
              count += 1
      
      for num in count_up_to(5):
          print(num)
      ```
      
      Expected output:
      
      ```
      1
      2
      3
      4
      5
      ```
      
      ## Generator vs list example
      
      ```python
      def get_squares_list(n):
          return [i ** 2 for i in range(n)]
      
      def get_squares_gen(n):
          for i in range(n):
              yield i ** 2
      
      print(get_squares_list(5))
      ```
      
      Expected output:
      
      ```
      [0, 1, 4, 9, 16]
      ```
      
      ## Generator expression (like list comprehension but lazy)
      
      ```python
      squares_gen = (i ** 2 for i in range(5))
      print(list(squares_gen))
      ```
      
      Expected output:
      
      ```
      [0, 1, 4, 9, 16]
      ```
      
      ## Real-world example: reading a large file safely
      
      ```python
      def read_large_file(file_path):
          with open(file_path, "r") as file:
              for line in file:
                  yield line.strip()
      
      for line in read_large_file("huge_data.txt"):
          print(line)
      ```
      
      ## Graph: lazy iteration
      
      ```mermaid
      flowchart LR
        A[Generator] --> B[Next value requested]
        B --> C[Yield one item]
        C --> D[Stop or continue]
        D --> B
      ```
      
      In the next lesson, you will learn context managers, which are about safe resource handling like files and database connections.

Learn generators and yield: iterate lazily, save memory, and build efficient pipelines for large datasets.

Python Generators

Context managers are Python’s way to manage resources safely.
      
      A resource is anything that must be cleaned up:
      - files must be closed
      - database connections must be closed
      - locks must be released
      
      The `with` statement guarantees cleanup even if an error happens.
      
      ## The best example: files
      
      ```python
      with open("data.txt", "r") as file:
          content = file.read()
          print(content)
      # file is closed automatically here
      ```
      
      ## Why not open() without with?
      
      If you do this and forget `close()`, resources may leak:
      
      ```python
      file = open("data.txt", "r")
      content = file.read()
      file.close()
      ```
      
      `with` makes this safer and cleaner.
      
      ## Create your own context manager (class)
      
      ```python
      class DatabaseConnection:
          def __enter__(self):
              print("Opening connection...")
              return self
      
          def __exit__(self, exc_type, exc_val, exc_tb):
              print("Closing connection...")
      
          def query(self, sql):
              print(f"Running: {sql}")
      
      with DatabaseConnection() as db:
          db.query("SELECT * FROM users")
      ```
      
      Expected output:
      
      ```
      Opening connection...
      Running: SELECT * FROM users
      Closing connection...
      ```
      
      ## Using contextlib (cleaner for small cases)
      
      ```python
      from contextlib import contextmanager
      import time
      
      @contextmanager
      def timer():
          start = time.time()
          yield
          end = time.time()
          print(f"Time: {end - start:.4f}s")
      
      with timer():
          sum([i for i in range(1000000)])
      ```
      
      Expected output example:
      
      ```
      Time: 0.0xxx s
      ```
      
      ## Multiple context managers
      
      ```python
      with open("input.txt", "r") as infile, open("output.txt", "w") as outfile:
          outfile.write(infile.read().upper())
      ```
      
      ## Graph: context manager lifecycle
      
      ```mermaid
      flowchart TD
        A[Enter with] --> B[__enter__ runs]
        B --> C[Work inside block]
        C --> D[__exit__ runs]
        D --> E[Cleanup done]
      ```
      
      In the next lesson, you will learn the collections module, which gives you powerful data structures for real-world problems.

Learn context managers: why 'with' matters, how __enter__/__exit__ work, and how to build safe resource management.

Python Context Managers

Python’s `collections` module provides specialized data structures that make many tasks easier and cleaner.
      
      You will use these in real projects when basic lists and dicts become inconvenient.
      
      ## Counter (count items easily)
      
      ```python
      from collections import Counter
      
      fruits = ["apple", "banana", "apple", "orange", "banana", "apple"]
      count = Counter(fruits)
      
      print(count)
      print(count["apple"])
      print(count.most_common(2))
      ```
      
      Expected output:
      
      ```
      Counter({'apple': 3, 'banana': 2, 'orange': 1})
      3
      [('apple', 3), ('banana', 2)]
      ```
      
      ## defaultdict (avoid KeyError)
      
      ```python
      from collections import defaultdict
      
      scores = defaultdict(int)
      scores["Tom"] += 10
      scores["Sarah"] += 20
      
      print(scores)
      ```
      
      Expected output:
      
      ```
      defaultdict(<class 'int'>, {'Tom': 10, 'Sarah': 20})
      ```
      
      ## namedtuple (lightweight structured data)
      
      ```python
      from collections import namedtuple
      
      Point = namedtuple("Point", ["x", "y"])
      p = Point(10, 20)
      
      print(p.x)
      print(p.y)
      ```
      
      Expected output:
      
      ```
      10
      20
      ```
      
      ## deque (fast queue from both ends)
      
      ```python
      from collections import deque
      
      queue = deque(["Tom", "Sarah", "Mike"])
      
      queue.append("Alice")
      queue.appendleft("Bob")
      queue.pop()
      queue.popleft()
      
      print(queue)
      ```
      
      Expected output:
      
      ```
      deque(['Tom', 'Sarah', 'Mike'])
      ```
      
      ## Graph: choose the right structure
      
      ```mermaid
      flowchart LR
        A[Need counts?] --> B[Counter]
        C[Need default values?] --> D[defaultdict]
        E[Need lightweight record?] --> F[namedtuple]
        G[Need fast queue?] --> H[deque]
      ```
      
      In the next lesson, you will learn virtual environments again but in a more project-focused way, so you can manage dependencies like a professional developer.

Use Counter, defaultdict, namedtuple, and deque to solve real problems cleanly with Python’s collections module.

Python Collections Module

A virtual environment (venv) creates an isolated space for your project’s packages.
      
      Without venv:
      - packages get installed globally
      - projects can break each other due to version conflicts
      
      With venv:
      - each project has its own dependencies
      - your computer stays clean
      
      ## Create and activate a venv (step by step)
      
      Create:
      
      ```bash
      python -m venv .venv
      ```
      
      Activate:
      
      ### Windows (PowerShell)
      ```bash
      .venv\Scripts\Activate.ps1
      ```
      
      ### macOS/Linux
      ```bash
      source .venv/bin/activate
      ```
      
      ## Install packages inside the venv
      
      ```bash
      pip install requests
      ```
      
      ## Save dependencies (so others can set up the project)
      
      ```bash
      pip freeze > requirements.txt
      ```
      
      Install from file:
      
      ```bash
      pip install -r requirements.txt
      ```
      
      ## Best practice: .gitignore
      
      Do not commit your environment folder:
      
      ```
      .venv/
      ```
      
      ## Graph: isolation concept
      
      ```mermaid
      flowchart LR
        A[Project A] --> B[(.venv A)]
        C[Project B] --> D[(.venv B)]
        B --> E[Packages A]
        D --> F[Packages B]
      ```
      
      In the next lesson, you will learn *args and **kwargs, which helps you build flexible, reusable functions in professional code.

Learn virtual environments with a real workflow: create, activate, install, freeze, share, and avoid dependency conflicts.

In real projects, you often want functions that can accept:
      - any number of positional values
      - any number of keyword options
      
      That is what:
      - `*args` handles (positional arguments)
      - `**kwargs` handles (keyword arguments)
      
      ## *args (variable positional arguments)
      
      ```python
      def add_all(*args):
          print(args)       # shows it's a tuple
          return sum(args)
      
      print(add_all(1, 2, 3))
      print(add_all(1, 2, 3, 4, 5))
      ```
      
      Expected output:
      
      ```
      (1, 2, 3)
      6
      (1, 2, 3, 4, 5)
      15
      ```
      
      ## **kwargs (variable keyword arguments)
      
      ```python
      def print_info(**kwargs):
          print(kwargs)  # shows it's a dictionary
          for key, value in kwargs.items():
              print(f"{key}: {value}")
      
      print_info(name="Tom", city="Austin", age=25)
      ```
      
      Expected output:
      
      ```
      {'name': 'Tom', 'city': 'Austin', 'age': 25}
      name: Tom
      city: Austin
      age: 25
      ```
      
      ## Using both together
      
      ```python
      def make_user(name, *hobbies, **details):
          print(f"Name: {name}")
          print(f"Hobbies: {hobbies}")
          print(f"Details: {details}")
      
      make_user(
          "Sarah",
          "reading", "gaming",
          city="Seattle",
          age=28
      )
      ```
      
      Expected output:
      
      ```
      Name: Sarah
      Hobbies: ('reading', 'gaming')
      Details: {'city': 'Seattle', 'age': 28}
      ```
      
      ## Unpacking (very common in real code)
      
      ```python
      def greet(first, last):
          print(f"Hello {first} {last}!")
      
      names = ["Tom", "Smith"]
      greet(*names)
      
      person = {"first": "Sarah", "last": "Johnson"}
      greet(**person)
      ```
      
      Expected output:
      
      ```
      Hello Tom Smith!
      Hello Sarah Johnson!
      ```
      
      ## Graph: argument flow
      
      ```mermaid
      flowchart LR
        A[Call site] --> B[*args tuple]
        A --> C[**kwargs dict]
        B --> D[Function receives arguments]
        C --> D
      ```
      
      ## Best practice rule
      
      Use `*args` and `**kwargs` to make APIs flexible, but do not use them to hide unclear function design.
      If a function expects a specific argument, name it directly.
      
      In the next lesson, you will learn type hints, which improves clarity and helps tools catch mistakes earlier.

Learn *args and **kwargs clearly: how variable arguments work, how unpacking works, and how to design flexible APIs safely.

Python Args and Kwargs

Type hints let you describe what type of data a variable or function expects.
      
      Important:
      Python will still run without type hints. Type hints are mainly for:
      - clearer code
      - better autocomplete in editors
      - catching mistakes early with tools (like mypy)
      
      ## Basic type hints
      
      ```python
      def greet(name: str) -> str:
          return f"Hello {name}!"
      
      age: int = 25
      price: float = 19.99
      is_active: bool = True
      
      print(greet("Tom"))
      ```
      
      Expected output:
      
      ```
      Hello Tom!
      ```
      
      ## Collection hints (modern style)
      
      ```python
      from typing import List, Dict, Tuple
      
      names: List[str] = ["Tom", "Sarah", "Mike"]
      scores: Dict[str, int] = {"Tom": 90, "Sarah": 85}
      point: Tuple[int, int] = (10, 20)
      
      print(names)
      print(scores)
      print(point)
      ```
      
      ## Optional (value can be None)
      
      ```python
      from typing import Optional
      
      def find_user(user_id: int) -> Optional[str]:
          if user_id == 1:
              return "Tom"
          return None
      
      print(find_user(1))
      print(find_user(99))
      ```
      
      Expected output:
      
      ```
      Tom
      None
      ```
      
      ## Union (multiple allowed types)
      
      ```python
      from typing import Union
      
      def process(value: Union[int, str]) -> str:
          return str(value)
      
      print(process(123))
      print(process("abc"))
      ```
      
      Expected output:
      
      ```
      123
      abc
      ```
      
      ## Callable (function as a parameter)
      
      ```python
      from typing import Callable
      
      def apply(func: Callable[[int, int], int], x: int, y: int) -> int:
          return func(x, y)
      
      def add(a: int, b: int) -> int:
          return a + b
      
      print(apply(add, 5, 3))
      ```
      
      Expected output:
      
      ```
      8
      ```
      
      ## Graph: what type hints change
      
      ```mermaid
      flowchart LR
        A[Write code] --> B[Add type hints]
        B --> C[Editor autocomplete improves]
        B --> D[Static checks catch mistakes]
        B --> E[Code becomes clearer]
      ```
      
      Type hints do not replace tests, but they make refactoring safer and reduce simple mistakes.
      
      In the next lesson, you will learn threading basics, including when to use threads and when not to.

Learn type hints for readability, safer refactoring, and better editor support, including lists, dicts, Optional, Union, and Callable.

Python Type Hints

Threading lets your program run tasks “at the same time” (concurrently). It is most useful when tasks are waiting on I/O, like:
      - downloading files
      - making API requests
      - reading/writing files
      - waiting for network responses
      
      Important concept:
      Threads in Python are not best for CPU-heavy tasks due to the GIL. For CPU-heavy workloads, `multiprocessing` is usually better.
      
      ## Basic thread example
      
      ```python
      import threading
      import time
      
      def task(name):
          print(f"{name} starting...")
          time.sleep(2)
          print(f"{name} done!")
      
      t1 = threading.Thread(target=task, args=("Task 1",))
      t2 = threading.Thread(target=task, args=("Task 2",))
      
      t1.start()
      t2.start()
      
      t1.join()
      t2.join()
      
      print("All done!")
      ```
      
      Expected output (order may vary slightly):
      
      ```
      Task 1 starting...
      Task 2 starting...
      Task 1 done!
      Task 2 done!
      All done!
      ```
      
      ## Threading with a list of tasks
      
      ```python
      import threading
      import time
      
      def download_file(file_name):
          print(f"Downloading {file_name}...")
          time.sleep(1)
          print(f"Downloaded {file_name}")
      
      files = ["file1.txt", "file2.txt", "file3.txt"]
      threads = []
      
      for file in files:
          t = threading.Thread(target=download_file, args=(file,))
          t.start()
          threads.append(t)
      
      for t in threads:
          t.join()
      
      print("All downloads finished.")
      ```
      
      ## Shared data problem (race condition)
      
      If multiple threads update the same variable, results can be wrong.
      
      ## Fix with Lock
      
      ```python
      import threading
      
      counter = 0
      lock = threading.Lock()
      
      def increment():
          global counter
          for _ in range(100000):
              with lock:
                  counter += 1
      
      threads = [threading.Thread(target=increment) for _ in range(10)]
      
      for t in threads:
          t.start()
      
      for t in threads:
          t.join()
      
      print(counter)
      ```
      
      Expected output:
      
      ```
      1000000
      ```
      
      ## Graph: thread lifecycle
      
      ```mermaid
      flowchart TD
        A[Create Thread] --> B[start()]
        B --> C[Run task]
        C --> D[join()]
        D --> E[Program continues]
      ```
      
      In the next lesson, you will learn how to work with APIs in Python, which is a practical skill for building real applications.

Learn threading step by step: starting threads, joining, shared state, and using locks to avoid race conditions.

Python Threading Basics

APIs let your program talk to other services. Most modern applications depend on APIs.
      
      In Python, the most common beginner-friendly library for HTTP is `requests`.
      
      ## Install requests
      
      ```bash
      pip install requests
      ```
      
      ## GET request (fetch data)
      
      ```python
      import requests
      
      response = requests.get("https://api.github.com/users/octocat", timeout=10)
      
      print("Status:", response.status_code)
      
      if response.status_code == 200:
          data = response.json()
          print("Login:", data.get("login"))
          print("Type:", data.get("type"))
      else:
          print("Request failed")
      ```
      
      Expected output example:
      
      ```
      Status: 200
      Login: octocat
      Type: User
      ```
      
      ## Query parameters
      
      ```python
      import requests
      
      params = {"q": "python", "sort": "stars"}
      response = requests.get("https://api.github.com/search/repositories", params=params, timeout=10)
      
      data = response.json()
      print("Total:", data.get("total_count"))
      ```
      
      ## POST request (send data)
      
      ```python
      import requests
      
      payload = {"name": "Tom", "email": "tom@example.com"}
      
      response = requests.post("https://httpbin.org/post", json=payload, timeout=10)
      data = response.json()
      
      print(data["json"])
      ```
      
      Expected output:
      
      ```
      {'name': 'Tom', 'email': 'tom@example.com'}
      ```
      
      ## Headers (authentication is usually here)
      
      ```python
      import requests
      
      headers = {
          "Authorization": "Bearer YOUR_TOKEN",
          "Content-Type": "application/json"
      }
      
      response = requests.get("https://api.example.com/data", headers=headers, timeout=10)
      ```
      
      ## Error handling (professional pattern)
      
      ```python
      import requests
      
      try:
          response = requests.get("https://api.github.com/users/octocat", timeout=5)
          response.raise_for_status()
          data = response.json()
          print(data.get("login"))
      except requests.exceptions.Timeout:
          print("Request timed out.")
      except requests.exceptions.HTTPError as e:
          print("HTTP error:", e)
      except requests.exceptions.RequestException as e:
          print("Request failed:", e)
      ```
      
      ## Graph: API request flow
      
      ```mermaid
      flowchart LR
        A[Client code] --> B[HTTP request]
        B --> C[Server API]
        C --> D[JSON response]
        D --> E[Parse with .json()]
        E --> F[Use data in app]
      ```
      
      In the next lesson, you will revisit list methods in a more complete way, including what each method returns and how to avoid common list bugs.

Learn API calls with requests: GET/POST, headers, query params, timeouts, and clean error handling with real patterns.

Python Working with APIs

Lists are used constantly, so you should master their methods and know what each method does.
      
      A common beginner mistake:
      Some list methods modify the list and return nothing (`None`). That is normal.
      
      ## Adding items
      
      ```python
      fruits = ["apple", "banana"]
      
      fruits.append("orange")
      print(fruits)
      
      fruits.insert(1, "grape")
      print(fruits)
      
      fruits.extend(["mango", "kiwi"])
      print(fruits)
      ```
      
      Expected output:
      
      ```
      ['apple', 'banana', 'orange']
      ['apple', 'grape', 'banana', 'orange']
      ['apple', 'grape', 'banana', 'orange', 'mango', 'kiwi']
      ```
      
      ## Removing items
      
      ```python
      fruits = ["apple", "banana", "orange", "banana"]
      
      fruits.remove("banana")  # removes first banana
      print(fruits)
      
      removed = fruits.pop(1)  # removes by index and returns it
      print("Removed:", removed)
      print("Now:", fruits)
      
      fruits.clear()
      print(fruits)
      ```
      
      Expected output:
      
      ```
      ['apple', 'orange', 'banana']
      Removed: orange
      Now: ['apple', 'banana']
      []
      ```
      
      ## Sorting and reversing
      
      ```python
      numbers = [5, 2, 8, 1, 9]
      
      numbers.sort()
      print(numbers)
      
      numbers.sort(reverse=True)
      print(numbers)
      
      numbers.reverse()
      print(numbers)
      ```
      
      Expected output:
      
      ```
      [1, 2, 5, 8, 9]
      [9, 8, 5, 2, 1]
      [1, 2, 5, 8, 9]
      ```
      
      ## Searching
      
      ```python
      cities = ["Miami", "Austin", "Denver", "Boston"]
      print(cities.index("Denver"))
      
      nums = [1, 2, 3, 2, 2]
      print(nums.count(2))
      
      print("Miami" in cities)
      ```
      
      Expected output:
      
      ```
      2
      3
      True
      ```
      
      ## Copy list safely
      
      ```python
      original = [1, 2, 3]
      copy1 = original.copy()
      
      copy1.append(4)
      print("Original:", original)
      print("Copy:", copy1)
      ```
      
      Expected output:
      
      ```
      Original: [1, 2, 3]
      Copy: [1, 2, 3, 4]
      ```
      
      ## Graph: list method categories
      
      ```mermaid
      flowchart LR
        A[List] --> B[Add: append/extend/insert]
        A --> C[Remove: remove/pop/clear]
        A --> D[Order: sort/reverse]
        A --> E[Search: index/count/in]
        A --> F[Copy: copy/slicing]
      ```
      
      In the next lesson, you will master string methods with the same mindset: what each method returns and how to use them in real programs.

Master the list API: append, extend, insert, remove, pop, clear, sort, reverse, index, count, copy, and safe patterns.

Python List Methods

Strings are everywhere: names, emails, logs, files, messages, and API responses.
      
      Important concept:
      Strings are **immutable**. That means methods return a **new** string, they do not change the original string.
      
      ## Case conversion
      
      ```python
      text = "Hello World"
      
      print(text.upper())
      print(text.lower())
      print(text.capitalize())
      print(text.title())
      print(text.swapcase())
      ```
      
      Expected output:
      
      ```
      HELLO WORLD
      hello world
      Hello world
      Hello World
      hELLO wORLD
      ```
      
      ## Finding and counting
      
      ```python
      text = "Python is awesome. Python is easy."
      
      print(text.find("Python"))
      print(text.find("Python", 10))
      print(text.find("Java"))
      
      print(text.count("Python"))
      ```
      
      Expected output:
      
      ```
      0
      19
      -1
      2
      ```
      
      ## Replacing
      
      ```python
      text = "I love Python"
      new_text = text.replace("love", "enjoy")
      
      print(text)
      print(new_text)
      ```
      
      Expected output:
      
      ```
      I love Python
      I enjoy Python
      ```
      
      Replace only first N occurrences:
      
      ```python
      text = "ha ha ha"
      print(text.replace("ha", "he", 2))
      ```
      
      Expected output:
      
      ```
      he he ha
      ```
      
      ## Splitting and joining (very practical)
      
      ```python
      csv = "apple,banana,orange"
      fruits = csv.split(",")
      print(fruits)
      
      cities = ["Miami", "Austin", "Denver"]
      text = ", ".join(cities)
      print(text)
      ```
      
      Expected output:
      
      ```
      ['apple', 'banana', 'orange']
      Miami, Austin, Denver
      ```
      
      ## Trimming spaces
      
      ```python
      text = "   hello   "
      print(text.strip())
      print(text.lstrip())
      print(text.rstrip())
      ```
      
      Expected output:
      
      ```
      hello
      hello   
         hello
      ```
      
      ## Checking content (validation)
      
      ```python
      print("hello".isalpha())
      print("123".isdigit())
      print("hello123".isalnum())
      print("HELLO".isupper())
      print("hello".islower())
      ```
      
      Expected output:
      
      ```
      True
      True
      True
      True
      True
      ```
      
      ## Real pattern: clean user input
      
      ```python
      raw = "   SARAH.JOHNSON@EXAMPLE.COM   "
      clean = raw.strip().lower()
      
      print(clean)
      ```
      
      Expected output:
      
      ```
      sarah.johnson@example.com
      ```
      
      ## Graph: string cleaning pipeline
      
      ```mermaid
      flowchart LR
        A[Raw input] --> B[strip spaces]
        B --> C[lower/upper]
        C --> D[replace/split]
        D --> E[Clean output]
      ```
      
      You now have a strong foundation of practical string methods and patterns used in real applications.

Master string methods: case conversion, searching, replacing, splitting/joining, trimming, checking, and practical text-cleaning patterns.

Python String Methods

Dictionaries store data as **key-value pairs**. They are one of the most powerful and most used data structures in Python.
        
        You should use a dictionary when:
        - you want fast lookups by a key
        - data has meaning (name → value)
        - order does not matter (though Python preserves insertion order)
        
        Think of a dictionary like a real dictionary:
        You look up a word (key) to get its meaning (value).
        
        ## Basic dictionary
        
        ```python
        person = {"name": "Tom", "age": 25, "city": "Austin"}
        print(person)
        ```
        
        ## Getting values safely
        
        ```python
        person = {"name": "Tom", "age": 25, "city": "Austin"}
        
        print(person["name"])            # Tom
        print(person.get("name"))        # Tom
        print(person.get("email"))       # None
        print(person.get("email", "N/A"))# Default if missing
        ```
        
        Why prefer `get()`?
        Because accessing a missing key with `person["email"]` throws an error, while `get()` is safe.
        
        ## Keys, values, items
        
        ```python
        print(person.keys())
        print(person.values())
        print(person.items())
        ```
        
        These return *views* that reflect live changes in the dictionary.
        
        ## Adding and updating
        
        ```python
        person["job"] = "Developer"      # add
        person["age"] = 26              # update
        
        person.update({"city": "Miami", "country": "USA"})
        print(person)
        ```
        
        ## Removing items
        
        ```python
        person = {"name": "Tom", "age": 25, "city": "Austin"}
        
        age = person.pop("age")
        print(age)
        print(person)
        
        last = person.popitem()
        print(last)
        print(person)
        
        person.clear()
        print(person)
        ```
        
        ## setdefault (get or create)
        
        ```python
        person = {"name": "Tom"}
        
        age = person.setdefault("age", 25)
        print(age)
        print(person)
        ```
        
        Useful when building grouped data.
        
        ## Copying dictionaries
        
        ```python
        original = {"name": "Tom", "age": 25}
        copy1 = original.copy()
        copy2 = dict(original)
        ```
        
        ## Merging dictionaries
        
        ```python
        dict1 = {"name": "Tom", "age": 25}
        dict2 = {"city": "Austin", "age": 26}
        
        merged = dict1 | dict2
        print(merged)
        
        merged_old = {**dict1, **dict2}
        print(merged_old)
        ```
        
        Later values overwrite earlier ones.
        
        ## Real-world example: count words
        
        ```python
        text = "apple banana apple orange banana apple"
        counts = {}
        
        for word in text.split():
            counts[word] = counts.get(word, 0) + 1
        
        print(counts)
        ```
        
        ## Graph: dictionary concept
        
        ```mermaid
        flowchart LR
          A[Key] --> B[Dictionary]
          B --> C[Value]
          A2[Another Key] --> B
          B --> C2[Another Value]
        ```
        
        ## Key points
        
        - Fast lookup by key
        - Keys must be immutable
        - Use get() for safety
        - Great for structured data
        
        In the next lesson, you will learn enumerate and zip, which make loops cleaner and more readable.

Understand Python dictionaries deeply: how key-value storage works, safe access patterns, updates, merging, and real-world use cases.

When looping in Python, beginners often write complex loops using indexes. Python gives you tools to make loops cleaner and safer.
        
        Two such tools are:
        - enumerate() → index + value
        - zip() → combine multiple iterables
        
        ## enumerate(): index with value
        
        ```python
        fruits = ["apple", "banana", "orange"]
        
        for index, fruit in enumerate(fruits):
            print(index, fruit)
        ```
        
        Expected output:
        ```
        0 apple
        1 banana
        2 orange
        ```
        
        Start from custom number:
        
        ```python
        for index, fruit in enumerate(fruits, start=1):
            print(index, fruit)
        ```
        
        ## Why enumerate is better
        
        Instead of:
        ```python
        for i in range(len(fruits)):
            print(i, fruits[i])
        ```
        
        Use:
        ```python
        for i, fruit in enumerate(fruits):
            print(i, fruit)
        ```
        
        Cleaner and safer.
        
        ## zip(): combine sequences
        
        ```python
        names = ["Tom", "Sarah", "Mike"]
        ages = [25, 28, 30]
        
        for name, age in zip(names, ages):
            print(name, age)
        ```
        
        zip stops at the shortest list.
        
        ## zip into dictionary
        
        ```python
        keys = ["name", "age", "city"]
        values = ["Tom", 25, "Austin"]
        
        person = dict(zip(keys, values))
        print(person)
        ```
        
        ## Unzip values
        
        ```python
        pairs = [(1, "a"), (2, "b"), (3, "c")]
        nums, letters = zip(*pairs)
        
        print(nums)
        print(letters)
        ```
        
        ## Practical example: leaderboard
        
        ```python
        students = ["Tom", "Sarah", "Mike"]
        scores = [85, 92, 78]
        
        leaderboard = list(zip(students, scores))
        leaderboard.sort(key=lambda x: x[1], reverse=True)
        
        for rank, (name, score) in enumerate(leaderboard, start=1):
            print(f"{rank}. {name}: {score}")
        ```
        
        ## Graph: enumerate vs zip
        
        ```mermaid
        flowchart LR
          A[List] --> B[enumerate]
          B --> C[Index + Value]
        
          D[List 1] --> E[zip]
          F[List 2] --> E
          E --> G[Paired Values]
        ```
        
        ## Key points
        
        - enumerate for index + value
        - zip to combine iterables
        - Makes loops readable and bug-free
        
        In the next lesson, you will explore map, filter, and reduce, which introduce functional-style data processing.

Learn enumerate and zip to write clean loops, avoid index bugs, and combine multiple sequences safely.

Python Enumerate and Zip

map, filter, and reduce come from functional programming. They let you process collections in a declarative way.
        
        General idea:
        - map → transform
        - filter → select
        - reduce → combine
        
        ## map(): transform items
        
        ```python
        numbers = [1, 2, 3, 4, 5]
        squared = list(map(lambda x: x ** 2, numbers))
        print(squared)
        ```
        
        Equivalent with list comprehension:
        ```python
        squared = [x ** 2 for x in numbers]
        ```
        
        ## filter(): select items
        
        ```python
        numbers = [1,2,3,4,5,6,7,8,9,10]
        evens = list(filter(lambda x: x % 2 == 0, numbers))
        print(evens)
        ```
        
        Equivalent:
        ```python
        evens = [x for x in numbers if x % 2 == 0]
        ```
        
        ## reduce(): combine items
        
        ```python
        from functools import reduce
        
        numbers = [1, 2, 3, 4, 5]
        total = reduce(lambda x, y: x + y, numbers)
        print(total)
        ```
        
        ## Real examples
        
        ```python
        names = ["tom", "sarah", "mike"]
        upper = list(map(str.upper, names))
        
        words = ["hi", "hello", "hey", "goodbye"]
        long_words = list(filter(lambda w: len(w) > 3, words))
        
        nums = [2, 3, 4]
        product = reduce(lambda x, y: x * y, nums)
        
        print(upper, long_words, product)
        ```
        
        ## Graph: data flow
        
        ```mermaid
        flowchart LR
          A[Data] --> B[map: transform]
          B --> C[filter: select]
          C --> D[reduce: combine]
          D --> E[Single result]
        ```
        
        ## Best practice
        
        - Prefer list comprehensions for clarity
        - Use reduce only when logic is truly combining
        - Keep lambdas simple
        
        In the next lesson, you will master sorting in Python, including custom keys and multi-level sorting.

Understand functional tools map, filter, and reduce, when to use them, and when list comprehensions are clearer.

Python Map Filter Reduce

Sorting is a core skill. You will use it for rankings, reports, logs, and UI displays.
        
        Two main tools:
        - list.sort() → modifies list
        - sorted() → returns new list
        
        ## Basic sorting
        
        ```python
        numbers = [5, 2, 8, 1, 9]
        numbers.sort()
        print(numbers)
        ```
        
        ```python
        numbers = [5, 2, 8, 1, 9]
        new_list = sorted(numbers)
        print(new_list)
        print(numbers)
        ```
        
        ## Reverse order
        
        ```python
        numbers.sort(reverse=True)
        print(numbers)
        ```
        
        ## Custom key sorting
        
        ```python
        words = ["apple", "hi", "banana", "kiwi"]
        words.sort(key=len)
        print(words)
        ```
        
        ```python
        numbers = [-5, 3, -2, 8, -1]
        numbers.sort(key=abs)
        print(numbers)
        ```
        
        ## Sorting complex data
        
        ```python
        students = [
            {"name": "Tom", "grade": 85},
            {"name": "Sarah", "grade": 92},
            {"name": "Mike", "grade": 78}
        ]
        
        students.sort(key=lambda s: s["grade"], reverse=True)
        for s in students:
            print(s)
        ```
        
        ## Multiple keys
        
        ```python
        data = [("Tom", 25), ("Sarah", 25), ("Mike", 30)]
        data.sort(key=lambda x: (x[1], x[0]))
        print(data)
        ```
        
        ## Graph: sorting logic
        
        ```mermaid
        flowchart LR
          A[Original list] --> B[Key function]
          B --> C[Comparison]
          C --> D[Sorted list]
        ```
        
        ## Key points
        
        - sort modifies, sorted returns new
        - Use key for custom logic
        - Stable sorting preserves order
        
        In the next lesson, you will learn pathlib, a modern way to handle file paths and directories.

Learn how sorting works in Python: sort vs sorted, reverse order, key functions, and sorting complex data.

Python Sorting

pathlib gives an object-oriented way to work with file paths. It replaces old os.path style and is more readable.
        
        ## Creating paths
        
        ```python
        from pathlib import Path
        
        print(Path.cwd())
        print(Path.home())
        
        path = Path("data/files/info.txt")
        print(path)
        ```
        
        ## Path properties
        
        ```python
        path = Path("data/files/report.txt")
        
        print(path.name)
        print(path.stem)
        print(path.suffix)
        print(path.parent)
        ```
        
        ## Checking paths
        
        ```python
        print(path.exists())
        print(path.is_file())
        print(path.is_dir())
        ```
        
        ## Create directories
        
        ```python
        Path("new_folder").mkdir(exist_ok=True)
        Path("data/reports/2025").mkdir(parents=True, exist_ok=True)
        ```
        
        ## Listing files
        
        ```python
        folder = Path("data")
        
        for f in folder.iterdir():
            print(f)
        
        for f in folder.glob("*.txt"):
            print(f)
        ```
        
        ## Reading and writing
        
        ```python
        path = Path("example.txt")
        
        path.write_text("Hello Python!")
        print(path.read_text())
        ```
        
        ## Joining paths
        
        ```python
        base = Path("data")
        file = base / "reports" / "2025" / "jan.txt"
        print(file)
        ```
        
        ## Graph: pathlib usage
        
        ```mermaid
        flowchart LR
          A[Path object] --> B[Check exists]
          A --> C[Create dirs]
          A --> D[Read/Write]
          A --> E[Join paths]
        ```
        
        ## Key points
        
        - Cleaner than os.path
        - Cross-platform
        - Use / to join paths
        - Path objects have many helpers
        
        In the next lesson, you will move into async and await, opening the door to high-performance I/O programs.

Work with files and folders using pathlib: paths, checks, creation, reading, writing, and cross-platform handling.

Python Pathlib

Async programming helps when your program spends time waiting, like:
          - calling APIs
          - reading files from disk
          - talking to databases
          - downloading images
          
          Instead of waiting and doing nothing, async lets Python start another task while the first one is waiting.
          
          ## First, understand the idea (very important)
          
          ### Synchronous (normal code)
          One task runs at a time. If task A is waiting, everything waits.
          
          ### Asynchronous (async code)
          Task A can pause (await) and Python can run task B during that pause.
          
          ## Concurrency vs Parallelism
          
          - **Concurrency**: tasks take turns (great for I/O waiting)
          - **Parallelism**: tasks truly run at the same time (great for CPU-heavy work)
          
          Async is mainly for **concurrency** (I/O work).
          
          ## Your first async function
          
          ```python
          import asyncio
          
          async def greet(name):
              print(f"Hello {name}!")
              await asyncio.sleep(1)  # pretend we are waiting for network
              print(f"Goodbye {name}!")
          
          asyncio.run(greet("Tom"))
          ```
          
          Expected output:
          ```
          Hello Tom!
          (wait 1 second)
          Goodbye Tom!
          ```
          
          ### Why do we need 'await'?
          Because it tells Python: "I am waiting here. You can run other tasks."
          
          ## Running multiple tasks at once
          
          ```python
          import asyncio
          
          async def fetch_data(task_id):
              print(f"Task {task_id}: start")
              await asyncio.sleep(2)
              print(f"Task {task_id}: end")
              return f"data-{task_id}"
          
          async def main():
              results = await asyncio.gather(
                  fetch_data(1),
                  fetch_data(2),
                  fetch_data(3),
              )
              print(results)
          
          asyncio.run(main())
          ```
          
          Expected output (order may vary):
          ```
          Task 1: start
          Task 2: start
          Task 3: start
          (wait ~2 seconds total)
          Task 1: end
          Task 2: end
          Task 3: end
          ['data-1', 'data-2', 'data-3']
          ```
          
          Notice: total time is about 2 seconds, not 6 seconds. That is the power of async.
          
          ## Real-world example: async HTTP requests
          
          For real async HTTP, we usually use `aiohttp`.
          
          ```python
          import asyncio
          import aiohttp
          
          async def fetch_url(session, url):
              async with session.get(url) as resp:
                  return await resp.text()
          
          async def main():
              async with aiohttp.ClientSession() as session:
                  html = await fetch_url(session, "https://example.com")
                  print(html[:120])
          
          asyncio.run(main())
          ```
          
          ## Common beginner mistakes
          
          ### Mistake 1: forgetting await
          ```python
          # wrong idea:
          # result = fetch_data(1)  # this returns a coroutine, not the final data
          ```
          
          ### Mistake 2: using blocking code inside async
          ```python
          # Avoid time.sleep() inside async code
          # Use: await asyncio.sleep()
          ```
          
          ## Graph: how async scheduling works
          
          ```mermaid
          flowchart LR
            A[Task 1 starts] --> B[await: waiting]
            B --> C[Event loop runs Task 2]
            C --> D[Task 2 await]
            D --> E[Event loop runs Task 3]
            E --> F[Task 3 await]
            F --> G[Resume Task 1 when ready]
          ```
          
          ## Key points
          
          - Use async for I/O-bound work
          - await = pause here, let others run
          - asyncio.gather runs tasks concurrently
          - For CPU-heavy work use multiprocessing (not async)
          

Learn async and await with a clear mental model, understand concurrency vs parallelism, and write faster I/O programs like API callers and web scrapers.

Python Async Await

Metaclasses are an advanced topic. You should learn them only after you are comfortable with:
          - classes
          - inheritance
          - decorators
          - class methods and static methods
          
          But once you understand them, you will see how frameworks like Django do powerful things automatically.
          
          ## The core idea
          
          - An object is created by a class.
          - A class is created by a **metaclass**.
          
          In Python, most classes are created by the built-in metaclass named `type`.
          
          ```python
          class MyClass:
              pass
          
          print(type(MyClass))  # <class 'type'>
          ```
          
          So yes, Python’s `type` is the “class that creates classes”.
          
          ## When metaclasses are useful
          
          Metaclasses are useful when you want to control class creation, for example:
          - enforce that a class must contain specific methods
          - automatically add attributes/methods to every class
          - register classes (plugin systems)
          - build ORM-like behavior
          
          ## Example 1: Inject a method into every class
          
          ```python
          class Meta(type):
              def __new__(cls, name, bases, attrs):
                  # add a greet method to every class built with this metaclass
                  def greet(self):
                      print(f"Hi, I am an instance of {name}")
                  attrs["greet"] = greet
                  return super().__new__(cls, name, bases, attrs)
          
          class User(metaclass=Meta):
              pass
          
          u = User()
          u.greet()
          ```
          
          Expected output:
          ```
          Hi, I am an instance of User
          ```
          
          ## Example 2: Enforce a rule (validation metaclass)
          
          Imagine you want every repository class to have a `save()` method.
          
          ```python
          class ValidationMeta(type):
              def __new__(cls, name, bases, attrs):
                  if name != "BaseRepo" and "save" not in attrs:
                      raise TypeError(f"{name} must define a save() method")
                  return super().__new__(cls, name, bases, attrs)
          
          class BaseRepo(metaclass=ValidationMeta):
              pass
          
          class UserRepo(BaseRepo):
              def save(self):
                  print("Saving user")
          
          repo = UserRepo()
          repo.save()
          ```
          
          If someone forgets `save()`, Python raises the error at class creation time.
          
          ## Example 3: Singleton with metaclass
          
          ```python
          class Singleton(type):
              _instances = {}
          
              def __call__(cls, *args, **kwargs):
                  if cls not in cls._instances:
                      cls._instances[cls] = super().__call__(*args, **kwargs)
                  return cls._instances[cls]
          
          class Database(metaclass=Singleton):
              def __init__(self):
                  self.connected = True
          
          db1 = Database()
          db2 = Database()
          print(db1 is db2)  # True
          ```
          
          ## Safer alternatives you should consider first
          
          Before metaclasses, usually you can solve problems using:
          - decorators
          - inheritance
          - class decorators
          - __init_subclass__ (modern and simpler)
          
          Metaclasses are powerful, but they can make code harder for other developers to read.
          
          ## Graph: class creation pipeline
          
          ```mermaid
          flowchart LR
            A[Metaclass (type)] --> B[Creates Class]
            B --> C[Class creates Objects]
            C --> D[Instances]
          ```
          
          ## Key points
          
          - Metaclass creates the class
          - Python default metaclass is type
          - Use only when you truly need class-creation control
          - Prefer simpler alternatives when possible
          

Understand what metaclasses are, why they exist, and how they can enforce rules or inject behavior at class creation time (with safer alternatives).

Python Metaclasses

Properties let you access methods like attributes.
          
          Instead of:
          - person.get_name()
          - person.set_name("Sarah")
          
          You can write:
          - person.name
          - person.name = "Sarah"
          
          But still run validation behind the scenes.
          
          ## Why properties matter
          
          They help you:
          - validate inputs
          - create read-only attributes
          - compute values dynamically
          - keep your API clean
          
          ## Basic property (getter + setter)
          
          ```python
          class Person:
              def __init__(self, name):
                  self._name = name  # underscore = internal
          
              @property
              def name(self):
                  return self._name
          
              @name.setter
              def name(self, value):
                  if not value or not value.strip():
                      raise ValueError("Name cannot be empty")
                  self._name = value.strip()
          
          p = Person("Tom")
          print(p.name)
          
          p.name = " Sarah "
          print(p.name)
          ```
          
          Expected output:
          ```
          Tom
          Sarah
          ```
          
          ## Read-only property
          
          ```python
          import math
          
          class Circle:
              def __init__(self, radius):
                  self.radius = radius
          
              @property
              def area(self):
                  return math.pi * (self.radius ** 2)
          
          c = Circle(5)
          print(round(c.area, 2))
          ```
          
          Here, `area` has no setter, so it cannot be directly changed.
          
          ## Computed property with two-way conversion
          
          ```python
          class Temperature:
              def __init__(self, celsius):
                  self._celsius = celsius
          
              @property
              def celsius(self):
                  return self._celsius
          
              @property
              def fahrenheit(self):
                  return (self._celsius * 9/5) + 32
          
              @fahrenheit.setter
              def fahrenheit(self, value):
                  self._celsius = (value - 32) * 5/9
          
          t = Temperature(25)
          print(t.fahrenheit)
          
          t.fahrenheit = 86
          print(round(t.celsius, 2))
          ```
          
          Expected output:
          ```
          77.0
          30.0
          ```
          
          ## Real-world example: bank account validation
          
          ```python
          class BankAccount:
              def __init__(self, balance):
                  self.balance = balance
          
              @property
              def balance(self):
                  return self._balance
          
              @balance.setter
              def balance(self, value):
                  if value < 0:
                      raise ValueError("Balance cannot be negative")
                  self._balance = value
          
          acc = BankAccount(1000)
          acc.balance = 1200
          print(acc.balance)
          
          # acc.balance = -10  # would raise error
          ```
          
          ## Graph: property access
          
          ```mermaid
          flowchart LR
            A[Read: obj.name] --> B[@property getter]
            C[Write: obj.name = value] --> D[@name.setter]
            B --> E[Return data]
            D --> F[Validate + store]
          ```
          
          ## Key points
          
          - Properties look like attributes, behave like methods
          - Great for validation and computed values
          - Keeps public API stable even if internals change
          

Use @property to create clean getter/setter logic with validation, computed attributes, and read-only fields, without breaking your public API.

Python Properties

You already know `with open(...)` closes files automatically.
          
          A context manager guarantees:
          - setup happens before your code runs
          - cleanup happens after your code finishes
          Even if an exception happens.
          
          This is critical in production code.
          
          ## Class-based context manager (Timer)
          
          ```python
          import time
          
          class Timer:
              def __enter__(self):
                  self.start = time.time()
                  return self
          
              def __exit__(self, exc_type, exc_val, exc_tb):
                  end = time.time()
                  print(f"Time taken: {end - self.start:.4f}s")
          
          with Timer():
              total = sum(i for i in range(1_000_000))
          ```
          
          ## Handling exceptions inside context managers
          
          Sometimes you want to catch errors and continue.
          
          ```python
          class SafeDivision:
              def __enter__(self):
                  return self
          
              def __exit__(self, exc_type, exc_val, exc_tb):
                  if exc_type:
                      print("Handled error:", exc_val)
                      return True  # suppress exception
                  return False
          
          with SafeDivision():
              x = 10 / 0
          
          print("Program continues...")
          ```
          
          ## Using ExitStack (manage multiple resources)
          
          ExitStack is useful when you open dynamic number of resources.
          
          ```python
          from contextlib import ExitStack
          
          files = ["a.txt", "b.txt", "c.txt"]
          
          with ExitStack() as stack:
              handles = [stack.enter_context(open(name, "w")) for name in files]
              for h in handles:
                  h.write("Hello\n")
          ```
          
          All files are closed properly, even if something fails halfway.
          
          ## Using contextlib to build a context manager (cleaner)
          
          ```python
          from contextlib import contextmanager
          import time
          
          @contextmanager
          def timer():
              start = time.time()
              try:
                  yield
              finally:
                  end = time.time()
                  print(f"Time taken: {end - start:.4f}s")
          
          with timer():
              sum(i for i in range(1_000_000))
          ```
          
          ## Graph: context manager lifecycle
          
          ```mermaid
          flowchart LR
            A[Enter with-block] --> B[__enter__ setup]
            B --> C[Run your code]
            C --> D[__exit__ cleanup]
            C --> E[Exception occurs]
            E --> D
          ```
          
          ## Key points
          
          - Context managers guarantee cleanup
          - __exit__ can suppress exceptions (return True)
          - ExitStack helps manage many resources safely
          

Build reliable resource-handling with advanced context managers: custom __enter__/__exit__, error suppression, and ExitStack for multiple resources.

Python Context Managers Advanced

Multiprocessing is for **CPU-heavy** tasks such as:
          - image processing
          - video encoding
          - large computations
          - machine learning preprocessing
          
          Threads are limited in Python for CPU work (because of the GIL), but processes bypass that because each process has its own interpreter.
          
          ## Basic Process
          
          ```python
          from multiprocessing import Process
          
          def worker(name):
              result = sum(i * i for i in range(1_000_000))
              print(f"{name} finished with result {result}")
          
          if __name__ == "__main__":
              p1 = Process(target=worker, args=("Worker-1",))
              p2 = Process(target=worker, args=("Worker-2",))
          
              p1.start()
              p2.start()
          
              p1.join()
              p2.join()
          
              print("All processes done!")
          ```
          
          ## Why the if __name__ == "__main__" guard matters
          
          On Windows and some environments, without this guard, your process can restart itself infinitely.
          
          Always include it.
          
          ## Using Pool for many items
          
          ```python
          from multiprocessing import Pool
          
          def square(n):
              return n * n
          
          if __name__ == "__main__":
              with Pool(4) as pool:
                  results = pool.map(square, range(10))
              print(results)
          ```
          
          ## Sharing results using Queue
          
          ```python
          from multiprocessing import Process, Queue
          
          def worker(q, name):
              q.put(f"Done by {name}")
          
          if __name__ == "__main__":
              q = Queue()
              procs = []
          
              for i in range(3):
                  p = Process(target=worker, args=(q, f"P{i}"))
                  p.start()
                  procs.append(p)
          
              for p in procs:
                  p.join()
          
              while not q.empty():
                  print(q.get())
          ```
          
          ## Simple performance mental model
          
          ```mermaid
          flowchart LR
            A[CPU Work] --> B[Threading]
            B --> C[GIL limitation]
            A --> D[Multiprocessing]
            D --> E[Multiple CPU cores]
          ```
          
          ## Key points
          
          - Use multiprocessing for CPU-heavy tasks
          - Use async for I/O-heavy tasks
          - Always use main guard
          - Pool is great for batch processing
          

Use multiple CPU cores with multiprocessing: processes, pools, safe guards, and sharing results. Perfect for CPU-heavy workloads.

Python Multiprocessing

Dataclasses make it easy to create classes that mainly store data.
          
          Without dataclasses, you write a lot of boilerplate:
          - __init__
          - __repr__
          - comparisons
          
          With dataclasses, Python generates these for you automatically.
          
          ## Basic dataclass
          
          ```python
          from dataclasses import dataclass
          
          @dataclass
          class Person:
              name: str
              age: int
              city: str
          
          p = Person("Tom", 25, "Austin")
          print(p)
          ```
          
          Expected output:
          ```
          Person(name='Tom', age=25, city='Austin')
          ```
          
          ## Default values
          
          ```python
          from dataclasses import dataclass
          
          @dataclass
          class Product:
              name: str
              price: float
              quantity: int = 0
          
          item = Product("Laptop", 999.99)
          print(item)
          ```
          
          ## Frozen dataclass (immutable)
          
          ```python
          from dataclasses import dataclass
          
          @dataclass(frozen=True)
          class Point:
              x: int
              y: int
          
          pt = Point(10, 20)
          print(pt)
          # pt.x = 99  # would fail
          ```
          
          ## __post_init__ for validation or computed fields
          
          ```python
          from dataclasses import dataclass, field
          
          @dataclass
          class Rectangle:
              width: float
              height: float
              area: float = field(init=False)
          
              def __post_init__(self):
                  if self.width <= 0 or self.height <= 0:
                      raise ValueError("Width and height must be positive")
                  self.area = self.width * self.height
          
          r = Rectangle(10, 5)
          print(r.area)
          ```
          
          ## Sorting dataclasses
          
          ```python
          from dataclasses import dataclass
          
          @dataclass(order=True)
          class Student:
              grade: int
              name: str
          
          students = [
              Student(85, "Tom"),
              Student(92, "Sarah"),
              Student(78, "Mike")
          ]
          
          students.sort(reverse=True)
          for s in students:
              print(s)
          ```
          
          ## Graph: dataclass benefit
          
          ```mermaid
          flowchart LR
            A[Regular class] --> B[Write __init__]
            A --> C[Write __repr__]
            A --> D[Write comparisons]
            E[Dataclass] --> F[Auto-generates boilerplate]
          ```
          
          ## Key points
          
          - Best for data containers
          - Reduces boilerplate code
          - Use frozen=True for immutability
          - Use __post_init__ for validation
          

Write clean data-holding classes using dataclasses: auto __init__, defaults, immutability, sorting, and validation with __post_init__.

Python Dataclasses

Descriptors are a low-level feature that powers many high-level tools in Python.
          
          Important fact:
          - `@property` is implemented using descriptors.
          
          A descriptor is any object that defines:
          - __get__
          - __set__
          - __delete__ (optional)
          
          ## Example: Positive-only descriptor
          
          ```python
          class Positive:
              def __init__(self, name):
                  self.name = name
          
              def __get__(self, obj, objtype=None):
                  return obj.__dict__.get(self.name, 0)
          
              def __set__(self, obj, value):
                  if value < 0:
                      raise ValueError("Value must be positive")
                  obj.__dict__[self.name] = value
          
          class Account:
              balance = Positive("balance")
          
              def __init__(self, balance):
                  self.balance = balance
          
          acc = Account(1000)
          print(acc.balance)
          # acc.balance = -50  # error
          ```
          
          ## Example: type validation descriptor
          
          ```python
          class Typed:
              def __init__(self, name, expected_type):
                  self.name = name
                  self.expected_type = expected_type
          
              def __get__(self, obj, objtype=None):
                  return obj.__dict__.get(self.name)
          
              def __set__(self, obj, value):
                  if not isinstance(value, self.expected_type):
                      raise TypeError(f"Expected {self.expected_type.__name__}")
                  obj.__dict__[self.name] = value
          
          class Person:
              name = Typed("name", str)
              age = Typed("age", int)
          
              def __init__(self, name, age):
                  self.name = name
                  self.age = age
          
          p = Person("Tom", 25)
          print(p.name, p.age)
          ```
          
          ## Example: caching descriptor (simple cached property)
          
          ```python
          class CachedProperty:
              def __init__(self, func):
                  self.func = func
                  self.name = func.__name__
          
              def __get__(self, obj, objtype=None):
                  if obj is None:
                      return self
                  if self.name in obj.__dict__:
                      return obj.__dict__[self.name]
                  value = self.func(obj)
                  obj.__dict__[self.name] = value
                  return value
          
          class DataProcessor:
              @CachedProperty
              def expensive(self):
                  print("Computing...")
                  return sum(range(1_000_000))
          
          dp = DataProcessor()
          print(dp.expensive)
          print(dp.expensive)
          ```
          
          Expected output:
          ```
          Computing...
          499999500000
          499999500000
          ```
          
          ## Graph: descriptor role
          
          ```mermaid
          flowchart LR
            A[Access obj.attr] --> B[Descriptor __get__]
            C[Assign obj.attr = x] --> D[Descriptor __set__]
            B --> E[Return value]
            D --> F[Validate + store]
          ```
          
          ## Key points
          
          - Descriptors control attribute access deeply
          - Properties are built on descriptors
          - Powerful but advanced, use only when needed
          

Learn descriptors (the engine behind properties): define __get__ and __set__ to control attribute access, validation, and caching.

Python Descriptors

Abstract Base Classes (ABCs) help you define an interface.
          
          If you are building a project with a team, ABCs are very useful because they:
          - enforce a contract
          - prevent incomplete classes
          - make code easier to maintain
          
          ## Basic ABC example
          
          ```python
          from abc import ABC, abstractmethod
          
          class Animal(ABC):
              @abstractmethod
              def speak(self):
                  pass
          
              @abstractmethod
              def move(self):
                  pass
          
          class Dog(Animal):
              def speak(self):
                  return "Woof!"
          
              def move(self):
                  return "Running"
          
          d = Dog()
          print(d.speak())
          print(d.move())
          ```
          
          Trying to instantiate Animal will fail.
          
          ## ABC with abstract properties
          
          ```python
          from abc import ABC, abstractmethod
          
          class Shape(ABC):
              @property
              @abstractmethod
              def area(self):
                  pass
          
          class Rectangle(Shape):
              def __init__(self, w, h):
                  self.w = w
                  self.h = h
          
              @property
              def area(self):
                  return self.w * self.h
          
          r = Rectangle(10, 20)
          print(r.area)
          ```
          
          ## Real-world example: database interface
          
          ```python
          from abc import ABC, abstractmethod
          
          class Database(ABC):
              @abstractmethod
              def connect(self):
                  pass
          
              @abstractmethod
              def query(self, sql):
                  pass
          
              @abstractmethod
              def close(self):
                  pass
          
          class PostgreSQL(Database):
              def connect(self):
                  print("Connected")
          
              def query(self, sql):
                  print("Running:", sql)
          
              def close(self):
                  print("Closed")
          
          db = PostgreSQL()
          db.connect()
          db.query("SELECT * FROM users")
          db.close()
          ```
          
          ## Graph: contract enforcement
          
          ```mermaid
          flowchart LR
            A[ABC Interface] --> B[Concrete class must implement]
            B --> C[Implementation exists]
            C --> D[Safe to use in codebase]
          ```
          
          ## Key points
          
          - ABC enforces required methods
          - Useful for big projects and team work
          - Prevents incomplete implementations
          

Use ABCs to design clean interfaces, enforce required methods, and build maintainable code for teams and large projects.

Python Abstract Base Classes

A lot of Python power comes from iteration.
          
          When you write:
          `for x in something:`
          Python is using the iterator protocol behind the scenes.
          
          ## Definitions (clear and simple)
          
          - **Iterable**: an object you can loop over (it has __iter__)
          - **Iterator**: an object that returns values one by one (it has __next__)
          
          Many objects (like lists) are iterables, but not iterators.
          
          ## Example: list is iterable
          
          ```python
          nums = [1, 2, 3]
          it = iter(nums)
          
          print(next(it))
          print(next(it))
          print(next(it))
          ```
          
          Expected output:
          ```
          1
          2
          3
          ```
          
          ## Custom iterator (Counter)
          
          ```python
          class Counter:
              def __init__(self, max_value):
                  self.max_value = max_value
                  self.current = 0
          
              def __iter__(self):
                  return self
          
              def __next__(self):
                  if self.current < self.max_value:
                      self.current += 1
                      return self.current
                  raise StopIteration
          
          for n in Counter(5):
              print(n)
          ```
          
          ## Fibonacci iterator (classic interview + real use)
          
          ```python
          class Fibonacci:
              def __init__(self, count):
                  self.count = count
          
              def __iter__(self):
                  self.a, self.b = 0, 1
                  self.i = 0
                  return self
          
              def __next__(self):
                  if self.i >= self.count:
                      raise StopIteration
                  value = self.a
                  self.a, self.b = self.b, self.a + self.b
                  self.i += 1
                  return value
          
          for n in Fibonacci(10):
              print(n)
          ```
          
          ## How a for-loop works internally (simplified)
          
          ```python
          # Python roughly does:
          iterator = iter(iterable)
          while True:
              try:
                  item = next(iterator)
                  # body
              except StopIteration:
                  break
          ```
          
          ## Graph: iteration pipeline
          
          ```mermaid
          flowchart LR
            A[Iterable] --> B[iter()]
            B --> C[Iterator]
            C --> D[next()]
            D --> E[Value]
            D --> F[StopIteration when done]
          ```
          
          ## Key points
          
          - Iterable gives an iterator
          - Iterator produces values with next()
          - for loop stops on StopIteration
          - Custom iterators can model streaming data
          

Master iterables and iterators: understand __iter__ and __next__, build custom iteration like Fibonacci, and learn how for-loops really work.

Python Iterators and Iterables

Python manages memory automatically, but as your programs grow, you must understand memory basics to avoid crashes and slowdowns.
          
          This lesson will help you build a strong mental model.
          
          ## The big idea
          
          When you create objects (lists, dicts, class instances), they live in memory.
          Python frees memory when objects are no longer referenced.
          
          Key mechanisms:
          - reference counting
          - garbage collection (for cycles)
          
          ## Reference counting (simple example)
          
          ```python
          a = [1, 2, 3]
          b = a  # now two variables reference the same list
          del a  # list still exists because b still references it
          ```
          
          The object is freed only when references drop to zero.
          
          ## Memory size comparison (list vs tuple)
          
          ```python
          import sys
          
          x = [1, 2, 3, 4, 5]
          y = (1, 2, 3, 4, 5)
          
          print(sys.getsizeof(x))
          print(sys.getsizeof(y))
          ```
          
          Tuples often use less memory because they are immutable and simpler internally.
          
          ## Garbage collection (cycles)
          
          Sometimes objects reference each other in a loop (cycle). Reference counting alone can’t clean that, so Python uses garbage collection.
          
          ```python
          import gc
          
          print(gc.isenabled())
          
          gc.collect()  # force cleanup
          ```
          
          ## Big memory mistake: building huge lists
          
          ```python
          # memory heavy
          nums = [i for i in range(10_000_000)]
          print(nums[0], nums[-1])
          ```
          
          Better: generator (lazy)
          
          ```python
          # memory friendly
          nums = (i for i in range(10_000_000))
          print(next(nums))
          ```
          
          ## Why generators help (concept)
          
          A list stores ALL values.
          A generator produces one value at a time.
          
          ## __slots__ to reduce object memory (advanced but practical)
          
          ```python
          class Person:
              __slots__ = ["name", "age"]
          
              def __init__(self, name, age):
                  self.name = name
                  self.age = age
          ```
          
          This removes the normal per-object __dict__, saving memory when you create many instances.
          
          ## Weak references (prevent memory leaks)
          
          ```python
          import weakref
          
          class Data:
              def __init__(self, value):
                  self.value = value
          
          obj = Data(42)
          ref = weakref.ref(obj)
          
          print(ref().value)
          
          del obj
          print(ref())  # None
          ```
          
          ## Graph: list vs generator memory model
          
          ```mermaid
          flowchart LR
            A[List] --> B[Allocates all items in memory]
            C[Generator] --> D[Produces one item at a time]
            D --> E[Low memory usage]
          ```
          
          ## Key points
          
          - Python frees objects when references end
          - Garbage collector handles cycles
          - Generators reduce memory for large data
          - __slots__ helps when you create many objects
          - Weak references can prevent certain memory issues
          

Understand how Python manages memory, when objects are freed, why generators save memory, and how to avoid common memory-heavy patterns.

Python Memory Management

Performance optimization means: **same output, less time and less memory**.
            
            But the golden rule is:
            ✅ **Measure first, optimize second.**  
            Because sometimes the “slow part” you guess is not the real slow part.
            
            ## What you will learn in this lesson
            
            - Why Python code becomes slow
            - How to find the slow lines (profiling)
            - High-impact optimizations that keep code readable
            - When you should use libraries like NumPy
            - Common performance mistakes beginners make
            
            ## The performance mindset (simple)
            
            Think of performance like this:
            
            1) **Algorithm matters most** (O(n) vs O(n²))  
            2) **Data structures matter** (set membership vs list membership)  
            3) **Micro-optimizations matter last** (local variables, tiny tweaks)
            
            ## Step 1: Profile before optimizing (most important)
            
            ### Time a function quickly
            ```python
            import time
            
            def work():
                return sum(i*i for i in range(1000000))
            
            start = time.time()
            work()
            end = time.time()
            print("Seconds:", end - start)
            ```
            
            ### Use cProfile for real profiling
            ```python
            import cProfile
            
            def my_function():
                result = sum(i ** 2 for i in range(10000))
                return result
            
            cProfile.run("my_function()")
            ```
            
            This tells you:
            - which function is slow
            - how many calls happened
            - how much time each part used
            
            ## Step 2: Prefer built-in functions (they are optimized in C)
            
            ### Example: sum is faster than manual loop
            ```python
            # Slow
            total = 0
            for i in range(1000):
                total += i
            
            # Fast
            total = sum(range(1000))
            ```
            
            Reason: built-ins run in optimized C code internally.
            
            ## Step 3: List comprehension vs loop (often faster and cleaner)
            
            ```python
            # Slower
            squares = []
            for i in range(1000):
                squares.append(i ** 2)
            
            # Faster (and readable)
            squares = [i ** 2 for i in range(1000)]
            ```
            
            ### But don’t overdo it
            If logic becomes confusing, prefer a normal loop.
            
            ## Step 4: Use sets for membership checks
            
            This is a very common real-world optimization.
            
            ```python
            # Slow (searching takes O(n))
            items_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
            print(5 in items_list)
            
            # Fast (searching takes ~O(1))
            items_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
            print(5 in items_set)
            ```
            
            When you need “contains?” many times, sets can be a huge win.
            
            ## Step 5: Avoid repeated lookups in tight loops
            
            ```python
            import math
            
            # Slow: attribute lookup each time
            def slow():
                for i in range(1000):
                    result = math.sqrt(i)
            
            # Faster: local reference
            def fast():
                sqrt = math.sqrt
                for i in range(1000):
                    result = sqrt(i)
            ```
            
            This is a **micro-optimization**, use it only in hot loops.
            
            ## Step 6: Choose the right algorithm (biggest wins)
            
            Example:
            - Sorting once then binary searching can be faster than repeated linear searches.
            - Using dict to map IDs is faster than scanning a list.
            
            ## Step 7: Use NumPy for heavy numeric work
            
            Python loops are slow for large numeric arrays.
            NumPy is extremely fast because it uses optimized native code.
            
            ```python
            import numpy as np
            
            arr = np.array([1, 2, 3, 4, 5])
            result = arr * 2
            print(result)
            ```
            
            ## Graph: performance decision guide
            
            ```mermaid
            flowchart TD
              A[Code is slow] --> B[Profile first]
              B --> C{What is slow?}
              C -->|Algorithm/data structure| D[Change approach: set/dict, better algorithm]
              C -->|I/O waiting| E[Use async or batching]
              C -->|Numeric heavy| F[Use NumPy / vectorization]
              C -->|Small hotspot loop| G[Micro-optimizations]
            ```
            
            ## Practical checklist (use in real projects)
            
            - Measure with cProfile or simple timers
            - Optimize algorithm first
            - Replace list membership with set when needed
            - Prefer built-ins and comprehensions
            - Avoid unnecessary work inside loops
            - Use NumPy for large numeric computations
            
            ## Remember
            
            - Profile before optimizing
            - Algorithm choices give the biggest wins
            - Built-ins and sets are common easy wins
            - Keep code readable and maintainable
            

Write faster Python by learning where time is spent, how to measure it, and which optimizations give real wins (without making code messy).

Python Performance Optimization

Testing means: you write code that checks your code.
            
            Why it matters:
            - it prevents bugs
            - it protects you when you refactor
            - it makes your project trustworthy for teams and clients
            
            Pytest is popular because it is:
            - simple syntax
            - powerful features
            - easy to read and maintain
            
            ## Install pytest
            
            ```bash
            pip install pytest
            ```
            
            ## Your first test (the pytest style)
            
            Create a file named: `test_math.py`
            
            ```python
            def add(a, b):
                return a + b
            
            def test_add():
                assert add(2, 3) == 5
                assert add(0, 0) == 0
                assert add(-1, 1) == 0
            ```
            
            Run:
            ```bash
            pytest
            ```
            
            ### What is assert?
            `assert` means: “This must be true.”  
            If false, the test fails.
            
            ## Test a class
            
            ```python
            class Calculator:
                def add(self, a, b):
                    return a + b
            
                def multiply(self, a, b):
                    return a * b
            
            def test_calculator():
                calc = Calculator()
                assert calc.add(2, 3) == 5
                assert calc.multiply(2, 3) == 6
            ```
            
            ## Fixtures (setup for tests)
            
            Fixtures are reusable setup functions.
            
            ```python
            import pytest
            
            @pytest.fixture
            def sample_data():
                return [1, 2, 3, 4, 5]
            
            def test_sum(sample_data):
                assert sum(sample_data) == 15
            
            def test_length(sample_data):
                assert len(sample_data) == 5
            ```
            
            Benefit:
            - no repeated setup code
            - cleaner tests
            
            ## Parametrize (test many cases quickly)
            
            ```python
            import pytest
            
            def is_even(n):
                return n % 2 == 0
            
            @pytest.mark.parametrize("number,expected", [
                (2, True),
                (3, False),
                (4, True),
                (5, False)
            ])
            def test_is_even(number, expected):
                assert is_even(number) == expected
            ```
            
            This is excellent for:
            - edge cases
            - boundary values
            - input variations
            
            ## Testing exceptions
            
            ```python
            import pytest
            
            def divide(a, b):
                if b == 0:
                    raise ValueError("Cannot divide by zero")
                return a / b
            
            def test_divide_by_zero():
                with pytest.raises(ValueError):
                    divide(10, 0)
            ```
            
            ## Mocking (when external dependency exists)
            
            Mocking helps when your function depends on:
            - API calls
            - database
            - payment gateway
            - file system
            
            ```python
            from unittest.mock import Mock
            
            def get_user_data(api):
                return api.fetch_user(123)
            
            def test_get_user_data():
                mock_api = Mock()
                mock_api.fetch_user.return_value = {"name": "Tom"}
            
                result = get_user_data(mock_api)
                assert result["name"] == "Tom"
            ```
            
            ## Graph: testing flow
            
            ```mermaid
            flowchart LR
              A[Write feature code] --> B[Write tests]
              B --> C[Run pytest]
              C --> D{All tests pass?}
              D -->|Yes| E[Ship confidently]
              D -->|No| F[Fix bug + rerun]
            ```
            
            ## Best practices (student-friendly)
            
            - Write tests for your core logic first
            - Add edge case tests (empty lists, None, zero, negative)
            - Keep tests independent
            - Use fixtures for setup
            - Mock external services
            
            ## Remember
            
            - Tests reduce bugs and fear of change
            - pytest is simple: function name starts with test_
            - Use fixtures for setup, parametrize for many cases
            

Learn pytest to verify your code automatically, catch bugs early, and ship confidently using fixtures, parametrized tests, and mocking.

Python Testing with Pytest

A design pattern is a proven solution to a common coding problem.
            
            Important:
            Patterns are not “rules”. They are tools.
            Use a pattern only when it makes the code simpler and clearer.
            
            ## When patterns help most
            
            - when code is growing
            - when many developers work together
            - when you need flexibility and extension
            - when you want cleaner architecture
            
            ## 1) Singleton Pattern (one instance only)
            
            Purpose:
            - ensure only one object exists (like a DB connection manager)
            
            ```python
            class Database:
                _instance = None
            
                def __new__(cls):
                    if cls._instance is None:
                        cls._instance = super().__new__(cls)
                    return cls._instance
            
            db1 = Database()
            db2 = Database()
            print(db1 is db2)  # True
            ```
            
            Benefit:
            - shared global state safely (but use carefully)
            
            ## 2) Factory Pattern (create objects based on input)
            
            Purpose:
            - create different objects without repeating if/else everywhere
            
            ```python
            class Dog:
                def speak(self):
                    return "Woof!"
            
            class Cat:
                def speak(self):
                    return "Meow!"
            
            class AnimalFactory:
                @staticmethod
                def create(animal_type):
                    if animal_type == "dog":
                        return Dog()
                    if animal_type == "cat":
                        return Cat()
                    raise ValueError("Unknown animal")
            
            animal = AnimalFactory.create("dog")
            print(animal.speak())
            ```
            
            Benefit:
            - easy to add new types later
            
            ## 3) Observer Pattern (notify subscribers)
            
            Purpose:
            - when many parts need updates after one change
            Examples:
            - UI updates
            - notifications
            - event systems
            
            ```python
            class Subject:
                def __init__(self):
                    self._observers = []
            
                def attach(self, observer):
                    self._observers.append(observer)
            
                def notify(self, message):
                    for obs in self._observers:
                        obs.update(message)
            
            class Observer:
                def __init__(self, name):
                    self.name = name
            
                def update(self, message):
                    print(f"{self.name} received: {message}")
            
            subject = Subject()
            subject.attach(Observer("User1"))
            subject.attach(Observer("User2"))
            subject.notify("New update!")
            ```
            
            Benefit:
            - loose coupling (components don’t directly depend on each other)
            
            ## 4) Strategy Pattern (swap behavior at runtime)
            
            Purpose:
            - choose an algorithm/behavior dynamically
            Example:
            - multiple payment methods
            
            ```python
            class CreditCard:
                def pay(self, amount):
                    print(f"Paid ${amount} with credit card")
            
            class PayPal:
                def pay(self, amount):
                    print(f"Paid ${amount} with PayPal")
            
            class Cart:
                def __init__(self, strategy):
                    self.strategy = strategy
            
                def checkout(self, amount):
                    self.strategy.pay(amount)
            
            cart = Cart(CreditCard())
            cart.checkout(100)
            
            cart = Cart(PayPal())
            cart.checkout(50)
            ```
            
            Benefit:
            - no big if/else inside your checkout logic
            
            ## Graph: how patterns reduce complexity
            
            ```mermaid
            flowchart TD
              A[Problem grows] --> B[Many if/else and duplicated logic]
              B --> C[Hard to maintain]
              A --> D[Use pattern where it fits]
              D --> E[Cleaner structure]
              E --> F[Easier extension]
            ```
            
            ## Remember
            
            - Patterns are reusable solutions
            - Use when it improves readability and scaling
            - Don’t force patterns into small/simple code
            

Understand common design patterns so you can structure code cleanly, avoid messy spaghetti logic, and build scalable systems like real applications.

Python Design Patterns

Web scraping means collecting data from web pages automatically.
            
            Examples:
            - product prices
            - job listings
            - news headlines
            - research datasets
            
            ## Before you scrape (very important)
            
            1) Check **website terms** and **robots.txt**  
            2) Add delays to avoid overloading servers  
            3) Do not scrape private or login-protected data without permission
            
            This keeps your scraping ethical and safe.
            
            ## Install libraries
            
            ```bash
            pip install beautifulsoup4 requests
            ```
            
            ## Step 1: Download a page (requests)
            
            ```python
            import requests
            
            url = "https://example.com"
            response = requests.get(url, timeout=10)
            
            print(response.status_code)
            print(response.text[:200])
            ```
            
            ## Step 2: Parse HTML (BeautifulSoup)
            
            ```python
            from bs4 import BeautifulSoup
            
            html = "<html><title>Hello</title></html>"
            soup = BeautifulSoup(html, "html.parser")
            
            print(soup.title.text)
            ```
            
            ## Real scraping example: title + all links
            
            ```python
            import requests
            from bs4 import BeautifulSoup
            
            url = "https://example.com"
            response = requests.get(url, timeout=10)
            soup = BeautifulSoup(response.text, "html.parser")
            
            print("Title:", soup.title.text)
            
            for link in soup.find_all("a"):
                print(link.get("href"))
            ```
            
            ## Finding specific elements (id, class, tag)
            
            ```python
            from bs4 import BeautifulSoup
            
            html = """
            <div class="container">
              <h1 id="main-title">Welcome</h1>
              <p class="text">Hello World</p>
            </div>
            """
            soup = BeautifulSoup(html, "html.parser")
            
            print(soup.find("h1").text)
            print(soup.find(id="main-title").text)
            print(soup.find(class_="text").text)
            ```
            
            ## Extracting table data (common use case)
            
            ```python
            import requests
            from bs4 import BeautifulSoup
            
            url = "https://example.com/table"
            response = requests.get(url, timeout=10)
            soup = BeautifulSoup(response.text, "html.parser")
            
            table = soup.find("table")
            rows = table.find_all("tr")
            
            for row in rows:
                cols = [c.get_text(strip=True) for c in row.find_all(["td", "th"])]
                if cols:
                    print(cols)
            ```
            
            ## Pagination (scraping multiple pages)
            
            ```python
            import requests
            import time
            from bs4 import BeautifulSoup
            
            base_url = "https://example.com/page/"
            
            for page in range(1, 6):
                url = f"{base_url}{page}"
                response = requests.get(url, timeout=10)
                soup = BeautifulSoup(response.text, "html.parser")
            
                items = soup.find_all(class_="item")
                for item in items:
                    print(item.get_text(strip=True))
            
                time.sleep(2)  # respectful delay
            ```
            
            ## Graph: scraping pipeline
            
            ```mermaid
            flowchart LR
              A[URL list] --> B[requests.get()]
              B --> C[HTML response]
              C --> D[BeautifulSoup parse]
              D --> E[Extract data]
              E --> F[Save to CSV/DB]
            ```
            
            ## Remember
            
            - Always add timeouts and delays
            - Handle errors gracefully
            - robots.txt and website rules matter
            - For JavaScript-heavy sites, you may need browser automation (Playwright/Selenium)
            

Learn ethical web scraping using requests and BeautifulSoup: extract titles, links, tables, handle pagination safely, and store data for analysis.

Python Web Scraping

Flask is a lightweight Python web framework.
            
            Why people use Flask:
            - easy to learn
            - flexible
            - great for APIs and small web apps
            - lets you understand how backend works (routes, requests, responses)
            
            ## Install Flask
            
            ```bash
            pip install flask
            ```
            
            ## Your first Flask app
            
            Create `app.py`:
            
            ```python
            from flask import Flask
            
            app = Flask(__name__)
            
            @app.route("/")
            def home():
                return "Hello from Flask!"
            
            if __name__ == "__main__":
                app.run(debug=True)
            ```
            
            Run:
            ```bash
            python app.py
            ```
            
            Open:
            `http://127.0.0.1:5000/`
            
            ## Routing (multiple pages)
            
            ```python
            @app.route("/about")
            def about():
                return "About Page"
            ```
            
            ## Dynamic routes (very common)
            
            ```python
            @app.route("/user/<name>")
            def user(name):
                return f"Hello {name}!"
            
            @app.route("/post/<int:post_id>")
            def post(post_id):
                return f"Post ID: {post_id}"
            ```
            
            ## Templates (HTML pages)
            
            Install Jinja is included with Flask.
            
            ```python
            from flask import render_template
            
            @app.route("/")
            def home():
                users = ["Tom", "Sarah", "Mike"]
                return render_template("index.html", users=users)
            ```
            
            Create file: `templates/index.html`
            
            ```html
            <ul>
              {% for u in users %}
                <li>{{ u }}</li>
              {% endfor %}
            </ul>
            ```
            
            ## Forms (GET and POST)
            
            ```python
            from flask import request
            
            @app.route("/login", methods=["GET", "POST"])
            def login():
                if request.method == "POST":
                    username = request.form["username"]
                    password = request.form["password"]
                    return f"Logged in as {username}"
            
                return """
                  <form method="post">
                    <input name="username" />
                    <input name="password" type="password" />
                    <button type="submit">Login</button>
                  </form>
                """
            ```
            
            ## JSON API (backend for frontend/mobile)
            
            ```python
            from flask import jsonify
            
            @app.route("/api/users")
            def get_users():
                users = [
                    {"name": "Tom", "city": "Austin"},
                    {"name": "Sarah", "city": "Miami"}
                ]
                return jsonify(users)
            ```
            
            ## Graph: Flask request flow
            
            ```mermaid
            flowchart LR
              A[Browser/API call] --> B[Flask route]
              B --> C[Your function logic]
              C --> D[Response: HTML/JSON]
            ```
            
            ## Remember
            
            - debug=True only for development
            - templates go in templates/
            - static files go in static/
            - Flask is great for APIs and small apps
            

Build your first web app using Flask: routing, templates, forms, and JSON APIs. Great for learning backend fundamentals and creating small production apps.

Python Flask Basics

SQLAlchemy is an ORM (Object Relational Mapper).
            
            Meaning:
            - you work with Python classes
            - SQLAlchemy converts that into SQL queries
            - it helps prevent SQL injection
            - it makes code easier to maintain
            
            ## Install SQLAlchemy
            
            ```bash
            pip install sqlalchemy
            ```
            
            ## Step 1: Create a model (table as class)
            
            ```python
            from sqlalchemy import create_engine, Column, Integer, String
            from sqlalchemy.orm import declarative_base, sessionmaker
            
            Base = declarative_base()
            
            class User(Base):
                __tablename__ = "users"
            
                id = Column(Integer, primary_key=True)
                name = Column(String)
                email = Column(String)
            
            engine = create_engine("sqlite:///users.db")
            Base.metadata.create_all(engine)
            
            Session = sessionmaker(bind=engine)
            session = Session()
            ```
            
            ## Step 2: Insert data
            
            ```python
            user = User(name="Tom", email="tom@example.com")
            session.add(user)
            session.commit()
            ```
            
            ## Step 3: Query data
            
            ```python
            users = session.query(User).all()
            for u in users:
                print(u.name, u.email)
            
            tom = session.query(User).filter_by(name="Tom").first()
            print(tom.email)
            ```
            
            ## Step 4: Update
            
            ```python
            tom = session.query(User).filter_by(name="Tom").first()
            tom.email = "tom_new@example.com"
            session.commit()
            ```
            
            ## Step 5: Delete
            
            ```python
            tom = session.query(User).filter_by(name="Tom").first()
            session.delete(tom)
            session.commit()
            ```
            
            ## Relationships (one-to-many)
            
            ```python
            from sqlalchemy import ForeignKey
            from sqlalchemy.orm import relationship
            
            class Post(Base):
                __tablename__ = "posts"
                id = Column(Integer, primary_key=True)
                title = Column(String)
                user_id = Column(Integer, ForeignKey("users.id"))
            
                user = relationship("User", backref="posts")
            ```
            
            ## Graph: ORM mapping concept
            
            ```mermaid
            flowchart LR
              A[Python class User] --> B[Table users]
              C[User object] --> D[Row in users]
              E[session.query] --> F[SQL executed safely]
            ```
            
            ## Remember
            
            - Session is your DB work unit
            - Always commit after changes
            - ORM keeps code cleaner than raw SQL in many apps
            

Use SQLAlchemy to work with databases safely: define models, insert/query/update/delete data, and build real applications without writing raw SQL everywhere.

Python SQLAlchemy

Logging is how real applications “talk” about what they are doing.
            
            Why logging is important:
            - in production you cannot rely on print()
            - logs help you debug issues after they happen
            - logs help you see user behavior and system failures
            
            ## Logging levels (simple meaning)
            
            - DEBUG: detailed developer info
            - INFO: normal operations
            - WARNING: something unexpected but not fatal
            - ERROR: operation failed
            - CRITICAL: app is in danger
            
            ## Basic logging
            
            ```python
            import logging
            
            logging.basicConfig(level=logging.INFO)
            
            logging.debug("Debug message")
            logging.info("Info message")
            logging.warning("Warning message")
            logging.error("Error message")
            logging.critical("Critical message")
            ```
            
            ## Log to a file (production friendly)
            
            ```python
            import logging
            
            logging.basicConfig(
                filename="app.log",
                level=logging.INFO,
                format="%(asctime)s - %(levelname)s - %(message)s"
            )
            
            logging.info("Application started")
            logging.error("An error occurred")
            ```
            
            ## Multiple handlers (console + file)
            
            ```python
            import logging
            
            logger = logging.getLogger(__name__)
            logger.setLevel(logging.DEBUG)
            
            console_handler = logging.StreamHandler()
            console_handler.setLevel(logging.INFO)
            
            file_handler = logging.FileHandler("errors.log")
            file_handler.setLevel(logging.ERROR)
            
            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)
            
            logger.info("Visible in console")
            logger.error("Saved in errors.log and also shown if console level allows")
            ```
            
            ## Log full exception details
            
            ```python
            import logging
            
            logging.basicConfig(level=logging.ERROR)
            
            try:
                10 / 0
            except Exception:
                logging.error("Crash happened", exc_info=True)
            ```
            
            ## Graph: where logs go
            
            ```mermaid
            flowchart LR
              A[Your code] --> B[logger.info/error]
              B --> C[Console]
              B --> D[Log file]
              D --> E[Monitoring / Debugging]
            ```
            
            ## Remember
            
            - Use logging instead of print() in real apps
            - Log files are critical for production debugging
            - Never log secrets (passwords, tokens, API keys)
            

Add professional logging to your apps: track errors, understand behavior in production, and replace print() with structured logs and log files.

Python Logging

Environment variables are settings stored outside your code.
            
            Examples:
            - DB_HOST
            - API_KEY
            - SECRET_KEY
            - DEBUG mode
            
            ### Why they matter
            If you hardcode secrets in code:
            - they can leak in GitHub
            - they are hard to change per environment
            - your app becomes unsafe
            
            Environment variables solve that.
            
            ## Read environment variables
            
            ```python
            import os
            
            db_host = os.environ.get("DB_HOST", "localhost")
            db_port = os.environ.get("DB_PORT", "5432")
            
            print(f"Connecting to {db_host}:{db_port}")
            ```
            
            ## Setting environment variables (concept)
            
            You typically set env vars in:
            - terminal
            - Docker
            - CI/CD pipeline
            - server environment
            
            Example (Linux/macOS):
            ```bash
            export DB_HOST=localhost
            ```
            
            Example (Windows PowerShell):
            ```powershell
            $env:DB_HOST="localhost"
            ```
            
            ## Using .env file (common in development)
            
            ```bash
            pip install python-dotenv
            ```
            
            Create `.env`:
            ```
            DB_HOST=localhost
            DB_PORT=5432
            API_KEY=secret123
            ```
            
            Load it:
            ```python
            from dotenv import load_dotenv
            import os
            
            load_dotenv()
            
            db_host = os.getenv("DB_HOST")
            api_key = os.getenv("API_KEY")
            print(db_host)
            ```
            
            ## Config class pattern (clean and organized)
            
            ```python
            import os
            from dotenv import load_dotenv
            
            load_dotenv()
            
            class Config:
                DB_HOST = os.getenv("DB_HOST", "localhost")
                DB_PORT = int(os.getenv("DB_PORT", "5432"))
                API_KEY = os.getenv("API_KEY")
                DEBUG = os.getenv("DEBUG", "False").lower() == "true"
            
            config = Config()
            print(config.DB_HOST, config.DB_PORT)
            ```
            
            ## Graph: config flow
            
            ```mermaid
            flowchart LR
              A[.env / server env vars] --> B[os.getenv]
              B --> C[Config class]
              C --> D[App uses settings safely]
            ```
            
            ## Remember
            
            - Never commit .env files to Git
            - Keep secrets in env vars
            - Use defaults for non-secret config
            - Different env vars for dev vs production
            

Store configuration safely using environment variables so you can keep secrets out of code, run the same app in dev and production, and deploy with confidence.

Python Environment Variables

Python is dynamically typed, so many type errors appear only when code runs.
            
            MyPy helps by checking types before execution.
            This is especially helpful in:
            - large projects
            - team projects
            - long-term maintainable code
            
            ## Install MyPy
            
            ```bash
            pip install mypy
            ```
            
            ## Simple example (type error is caught early)
            
            ```python
            def add(a: int, b: int) -> int:
                return a + b
            
            result = add("5", "3")  # wrong types
            ```
            
            Run:
            ```bash
            mypy code.py
            ```
            
            ## Optional types (None handling)
            
            ```python
            from typing import Optional
            
            def find_user(user_id: int) -> Optional[str]:
                if user_id == 1:
                    return "Tom"
                return None
            
            user = find_user(2)
            if user is not None:
                print(user.upper())
            ```
            
            ## Collections types
            
            ```python
            from typing import List, Dict, Tuple, Set
            
            names: List[str] = ["Tom", "Sarah"]
            scores: Dict[str, int] = {"Tom": 90}
            point: Tuple[int, int] = (10, 20)
            unique: Set[int] = {1, 2, 3}
            ```
            
            ## Generics example (Stack)
            
            ```python
            from typing import TypeVar, Generic, List
            
            T = TypeVar("T")
            
            class Stack(Generic[T]):
                def __init__(self) -> None:
                    self.items: List[T] = []
            
                def push(self, item: T) -> None:
                    self.items.append(item)
            
                def pop(self) -> T:
                    return self.items.pop()
            
            s = Stack[int]()
            s.push(10)
            ```
            
            ## Graph: bug prevention
            
            ```mermaid
            flowchart LR
              A[Write code] --> B[Run mypy]
              B --> C{Types OK?}
              C -->|Yes| D[Run program safely]
              C -->|No| E[Fix type errors early]
            ```
            
            ## Remember
            
            - Type hints improve readability
            - MyPy catches many bugs before runtime
            - Best for medium/large codebases
            

Catch type mistakes before runtime using MyPy, make your code easier to understand, and reduce bugs in large codebases with static type checks.

Python Type Checking with MyPy

Packaging means converting your project into a reusable installable library.
            
            Purpose:
            - share code across projects
            - publish on PyPI
            - make installation easy: pip install yourpackage
            
            ## Recommended project structure
            
            ```
            mypackage/
            ├── mypackage/
            │   ├── __init__.py
            │   └── module.py
            ├── tests/
            ├── README.md
            ├── LICENSE
            └── pyproject.toml
            ```
            
            Note: modern Python uses **pyproject.toml** (recommended).
            
            ## Minimal pyproject.toml (modern standard)
            
            ```toml
            [build-system]
            requires = ["setuptools>=68", "wheel"]
            build-backend = "setuptools.build_meta"
            
            [project]
            name = "mypackage"
            version = "0.1.0"
            description = "A short description"
            readme = "README.md"
            requires-python = ">=3.9"
            dependencies = ["requests>=2.25.0"]
            ```
            
            ## __init__.py (clean exports)
            
            ```python
            from .module import function1, function2
            __all__ = ["function1", "function2"]
            __version__ = "0.1.0"
            ```
            
            ## Build package
            
            ```bash
            pip install build twine
            python -m build
            ```
            
            This creates files in `dist/`:
            - .whl (wheel)
            - .tar.gz (source)
            
            ## Upload to PyPI
            
            ```bash
            twine upload --repository testpypi dist/*
            # then real PyPI:
            twine upload dist/*
            ```
            
            ## Install package
            
            ```bash
            pip install mypackage
            pip install -e .  # editable install for development
            ```
            
            ## Graph: packaging lifecycle
            
            ```mermaid
            flowchart LR
              A[Write reusable code] --> B[Add pyproject.toml]
              B --> C[Build dist/]
              C --> D[Upload to PyPI]
              D --> E[Others install with pip]
            ```
            
            ## Remember
            
            - Packaging makes code reusable
            - Use pyproject.toml (modern)
            - Always include README and LICENSE
            - Test on TestPyPI first
            

Learn how to package Python code so others can install it with pip, reuse your modules cleanly, and publish projects to PyPI like professional libraries.

Python Packaging

Security is not optional. Even small apps can be attacked.
            
            This lesson teaches safe habits that every developer should follow.
            
            ## 1) Validate input (never trust user input)
            
            ```python
            def parse_age(age_str: str) -> int:
                try:
                    age = int(age_str)
                except ValueError:
                    raise ValueError("Age must be a number")
            
                if age < 0 or age > 150:
                    raise ValueError("Age out of range")
            
                return age
            ```
            
            ## 2) Prevent SQL injection (parameterized queries)
            
            ```python
            import sqlite3
            
            conn = sqlite3.connect("app.db")
            cur = conn.cursor()
            
            user_id = input("User ID: ")
            
            # Good: safe parameterization
            cur.execute("SELECT * FROM users WHERE id = ?", (user_id,))
            ```
            
            ## 3) Hash passwords (never store plain text)
            
            ```python
            from werkzeug.security import generate_password_hash, check_password_hash
            
            password = "user_password"
            hashed = generate_password_hash(password)
            
            print(check_password_hash(hashed, "user_password"))
            ```
            
            ## 4) Keep secrets out of code (use env vars)
            
            ```python
            import os
            
            api_key = os.getenv("API_KEY")
            if not api_key:
                raise ValueError("API_KEY not set")
            ```
            
            ## 5) Safe file paths (avoid directory traversal)
            
            ```python
            import os
            
            def safe_read(filename: str) -> str:
                base_dir = "/safe/directory"
                safe_path = os.path.abspath(os.path.join(base_dir, filename))
            
                if not safe_path.startswith(os.path.abspath(base_dir)):
                    raise ValueError("Invalid path")
            
                with open(safe_path, "r") as f:
                    return f.read()
            ```
            
            ## 6) HTTPS verification (do not disable SSL)
            
            ```python
            import requests
            
            response = requests.get("https://api.example.com", timeout=10, verify=True)
            ```
            
            ## Graph: security mindset
            
            ```mermaid
            flowchart LR
              A[User input] --> B[Validate + sanitize]
              B --> C[Process safely]
              C --> D[Store safely]
              D --> E[Log safely]
            ```
            
            ## Remember
            
            - Validate all input
            - Use parameterized SQL
            - Hash passwords, never store plain
            - Keep secrets in env vars
            - Don’t log sensitive data
            

Learn practical security habits in Python: validate input, prevent SQL injection, protect secrets, hash passwords, and avoid common vulnerabilities in real apps.

Python Security Best Practices

CSV is one of the most common file formats for data sharing.
            
            You will use CSV when:
            - exporting reports
            - moving data between systems
            - working with spreadsheets
            - doing analytics
            
            ## Reading CSV using csv.reader
            
            ```python
            import csv
            
            with open("data.csv", "r", newline="") as file:
                reader = csv.reader(file)
                header = next(reader)  # skip header
                for row in reader:
                    print(row)
            ```
            
            ## Writing CSV using csv.writer
            
            ```python
            import csv
            
            rows = [
                ["Name", "Age", "City"],
                ["Tom", 25, "Austin"],
                ["Sarah", 28, "Miami"]
            ]
            
            with open("output.csv", "w", newline="") as file:
                writer = csv.writer(file)
                writer.writerows(rows)
            ```
            
            ## DictReader and DictWriter (best for real apps)
            
            ```python
            import csv
            
            with open("data.csv", "r", newline="") as file:
                reader = csv.DictReader(file)
                for row in reader:
                    print(row["Name"], row["Age"])
            ```
            
            ```python
            import csv
            
            data = [
                {"Name": "Tom", "Age": 25, "City": "Austin"},
                {"Name": "Sarah", "Age": 28, "City": "Miami"}
            ]
            
            with open("output.csv", "w", newline="") as file:
                writer = csv.DictWriter(file, fieldnames=["Name", "Age", "City"])
                writer.writeheader()
                writer.writerows(data)
            ```
            
            ## Custom delimiter (TSV or pipe-separated)
            
            ```python
            import csv
            
            with open("data.tsv", "r", newline="") as file:
                reader = csv.reader(file, delimiter="\t")
                for row in reader:
                    print(row)
            ```
            
            ## Pandas (best for analysis + big data)
            
            ```python
            import pandas as pd
            
            df = pd.read_csv("data.csv")
            print(df.head())
            
            df.to_csv("cleaned.csv", index=False)
            ```
            
            ## Graph: CSV workflow
            
            ```mermaid
            flowchart LR
              A[CSV file] --> B[Read: csv/pandas]
              B --> C[Clean/transform]
              C --> D[Write new CSV]
              D --> E[Share/report/import]
            ```
            
            ## Remember
            
            - Use newline="" when writing CSV (important)
            - DictReader is easier in apps
            - Pandas is best for large datasets and analysis
            

Read and write CSV files correctly using csv module and pandas, handle headers, delimiters, and large datasets for data analysis and automation.

Python Working with CSV

Command-line arguments let you run a Python program with inputs like:
            
            `python script.py input.txt --verbose`
            
            This is used in:
            - automation scripts
            - DevOps tasks
            - data processing tools
            - CLI utilities
            
            ## Option 1: sys.argv (simple but limited)
            
            ```python
            import sys
            
            print("Script:", sys.argv[0])
            print("Args:", sys.argv[1:])
            ```
            
            Run:
            ```bash
            python script.py hello world
            ```
            
            ## Option 2: argparse (recommended for real tools)
            
            ```python
            import argparse
            
            parser = argparse.ArgumentParser(description="Process some data")
            parser.add_argument("name", help="Your name")
            parser.add_argument("--age", type=int, help="Your age")
            parser.add_argument("--city", default="Austin", help="Your city")
            
            args = parser.parse_args()
            
            print(args.name, args.age, args.city)
            ```
            
            Run:
            ```bash
            python script.py Tom --age 25 --city Miami
            ```
            
            ## Flags (true/false switches)
            
            ```python
            import argparse
            
            parser = argparse.ArgumentParser()
            parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
            args = parser.parse_args()
            
            if args.verbose:
                print("Verbose mode ON")
            ```
            
            ## Choices validation
            
            ```python
            import argparse
            
            parser = argparse.ArgumentParser()
            parser.add_argument("--format", choices=["json", "xml", "csv"], default="json")
            args = parser.parse_args()
            
            print("Format:", args.format)
            ```
            
            ## Graph: CLI execution flow
            
            ```mermaid
            flowchart LR
              A[User runs command] --> B[argparse parses args]
              B --> C[Validate + defaults]
              C --> D[Your program logic]
              D --> E[Output result]
            ```
            
            ## Remember
            
            - sys.argv is quick but basic
            - argparse is best for real tools
            - Provide help text and defaults
            - Use choices and types for validation
            

Build real command-line tools by reading arguments, adding help text, validating input, and supporting flags using argparse like professional scripts.

Python Command Line Arguments

Excel automation is very common in real jobs:
            - reporting
            - finance sheets
            - data cleaning
            - exporting results for clients
            
            Python can:
            - read Excel
            - create Excel
            - format Excel (colors, bold headers)
            - write multiple sheets
            
            ## Install libraries
            
            ```bash
            pip install openpyxl pandas
            ```
            
            ## Pandas: read Excel (fastest for analysis)
            
            ```python
            import pandas as pd
            
            df = pd.read_excel("data.xlsx")
            print(df.head())
            
            df2 = pd.read_excel("data.xlsx", sheet_name="Sheet1")
            ```
            
            ## Pandas: write Excel
            
            ```python
            import pandas as pd
            
            df.to_excel("output.xlsx", index=False)
            
            with pd.ExcelWriter("output.xlsx") as writer:
                df.to_excel(writer, sheet_name="Users", index=False)
                df.to_excel(writer, sheet_name="Backup", index=False)
            ```
            
            ## openpyxl: read cells (more control)
            
            ```python
            from openpyxl import load_workbook
            
            wb = load_workbook("data.xlsx")
            sheet = wb["Sheet1"]
            
            for row in sheet.iter_rows(min_row=2, values_only=True):
                print(row)
            ```
            
            ## openpyxl: write + format (best for styling)
            
            ```python
            from openpyxl import Workbook
            from openpyxl.styles import Font, PatternFill
            
            wb = Workbook()
            sheet = wb.active
            
            sheet.append(["Name", "Age", "City"])
            sheet.append(["Tom", 25, "Austin"])
            sheet.append(["Sarah", 28, "Miami"])
            
            header_font = Font(bold=True, color="FFFFFF")
            header_fill = PatternFill(start_color="0070C0", fill_type="solid")
            
            for cell in sheet[1]:
                cell.font = header_font
                cell.fill = header_fill
            
            wb.save("formatted.xlsx")
            ```
            
            ## Graph: choose pandas vs openpyxl
            
            ```mermaid
            flowchart TD
              A[Excel Task] --> B{Goal?}
              B -->|Analysis + filtering| C[Pandas]
              B -->|Formatting + styling| D[openpyxl]
              B -->|Both| E[Use pandas then style with openpyxl]
            ```
            
            ## Remember
            
            - pandas is best for data work
            - openpyxl is best for formatting
            - For professional reports, you often use both
            

Automate Excel files using pandas and openpyxl: read sheets, write reports, format headers, and generate Excel outputs for business and data workflows.

Python Working with Excel

Deployment means running your Python app reliably on a server so real users can use it.
            
            This lesson focuses on practical deployment habits:
            - stable installs
            - production servers
            - environment-based configuration
            - monitoring basics
            
            ## Step 1: Requirements file
            
            ```bash
            pip freeze > requirements.txt
            pip install -r requirements.txt
            ```
            
            Purpose:
            - repeatable installs
            - same versions on dev and production
            
            ## Step 2: Production server (Gunicorn for Flask)
            
            ```bash
            pip install gunicorn
            gunicorn -w 4 -b 0.0.0.0:8000 app:app
            ```
            
            Why:
            - Flask dev server is not designed for production traffic
            
            ## Step 3: Docker (portable deployment)
            
            ```dockerfile
            FROM python:3.11-slim
            WORKDIR /app
            
            COPY requirements.txt .
            RUN pip install --no-cache-dir -r requirements.txt
            
            COPY . .
            CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
            ```
            
            ```bash
            docker build -t myapp .
            docker run -p 8000:8000 myapp
            ```
            
            Benefit:
            - same behavior on every machine
            
            ## Step 4: Configuration by environment
            
            ```python
            import os
            
            class Config:
                DEBUG = False
                DATABASE_URI = os.getenv("DATABASE_URI")
            ```
            
            Never hardcode secrets, use env vars.
            
            ## Step 5: Systemd service (Linux server)
            
            ```ini
            [Unit]
            Description=My Python App
            After=network.target
            
            [Service]
            User=www-data
            WorkingDirectory=/var/www/myapp
            Environment="PATH=/var/www/myapp/venv/bin"
            ExecStart=/var/www/myapp/venv/bin/gunicorn -w 4 app:app
            
            [Install]
            WantedBy=multi-user.target
            ```
            
            This keeps your app running after reboot.
            
            ## Step 6: Health check endpoint
            
            ```python
            from flask import Flask
            
            app = Flask(__name__)
            
            @app.route("/health")
            def health():
                return {"status": "healthy"}, 200
            ```
            
            This helps monitoring tools verify the app is alive.
            
            ## Graph: deployment pipeline
            
            ```mermaid
            flowchart LR
              A[Code] --> B[requirements.txt]
              B --> C[Build Docker / Setup server]
              C --> D[Run gunicorn]
              D --> E[Health check + logs]
              E --> F[Stable production app]
            ```
            
            ## Remember
            
            - Use a real server (gunicorn/uvicorn) for production
            - Keep secrets in environment variables
            - Add health checks and logs
            - Docker makes deployment consistent
            
            > Congratulations! You've completed all Python tutorials from beginner to advanced!
            

Deploy Python apps the right way: lock dependencies, run with a production server, use environment variables, add health checks, and keep releases stable.

Python Deployment

This comprehensive guide covers 50 essential Python interview questions that every Python developer should know. These questions cover fundamental concepts, data structures, object-oriented programming, advanced features, and best practices commonly asked in technical interviews.

## Core Concepts

Understanding Python's core concepts is essential for any Python developer. These questions test your knowledge of data types, variables, operators, and Python's unique features.

## Data Structures

Python provides powerful built-in data structures. Master these questions to demonstrate your understanding of lists, dictionaries, tuples, sets, and their use cases.

## Object-Oriented Programming

Python supports OOP with classes, inheritance, polymorphism, and encapsulation. These questions cover class design, method resolution order, and Python's OOP features.

## Advanced Features

Python's advanced features include decorators, generators, context managers, and metaprogramming. These questions test your ability to use Python's powerful features effectively.

## Best Practices & Libraries

Production-ready Python code requires understanding best practices, popular libraries, and Pythonic code style. These questions cover PEP guidelines, testing, and common libraries.

Comprehensive collection of 50 essential Python interview questions covering data structures, OOP, decorators, generators, and advanced Python concepts. Free Python interview questions with answers. Python interview prep guide.

Python Interview Questions: 50 Essential Questions for Developers

FastAPI is probably the best thing that happened to Python web development in recent years. If you're building APIs in 2025, you should definitely know FastAPI.

## Why FastAPI is Awesome

FastAPI is built on modern Python features. It uses type hints (which you probably already know), async/await for handling multiple requests, and automatically creates API documentation for you. The best part? It's incredibly fast - almost as fast as Node.js.

## Getting Started is Super Easy

Setting up FastAPI takes just a few minutes. You install it, write a simple function, and boom - you have a working API. No complicated setup, no confusing configuration files.

## Building Your First API

Let's create a simple todo API. I'll show you how easy it is to create endpoints, handle requests, and return responses. You'll be surprised how little code you need.

## Real-World Features

FastAPI handles authentication, database connections, file uploads, and more. I'll show you practical examples that you can actually use in your projects.

Learn how to build fast, modern APIs with FastAPI. Perfect for 2025 - it's fast, easy to use, and automatically generates documentation. Build production-ready APIs in minutes.

Building APIs with FastAPI: The Modern Python Way

Pandas is the tool that makes working with data in Python actually enjoyable. If you're dealing with CSV files, databases, or any structured data, Pandas is your best friend.

## What is Pandas?

Pandas gives you DataFrames - think of them as super-powered Excel spreadsheets in Python. You can filter, group, analyze, and transform data with just a few lines of code.

## Reading Data

Pandas can read almost anything - CSV files, Excel files, JSON, SQL databases. One line of code and your data is ready to work with.

## Cleaning Data

Real data is messy. Missing values, duplicates, wrong formats - Pandas has tools for all of it. I'll show you the most common problems and how to fix them.

## Analyzing Data

Once your data is clean, the fun begins. Group by categories, calculate averages, find patterns - Pandas makes it all easy.

Learn Pandas the easy way. Clean data, analyze it, and make sense of it. Whether you're working with CSV files or databases, Pandas makes data analysis simple and fun.

Python Resources - Programming Guide

Browse Python Content

Tutorials

Interview Questions

Practice Problems

Articles & Blog