# Lists hold ordered, changeable collections
fares = [450.0, 320.5, 210.0, 580.0, 275.0]

# Access by index — zero-based
print(fares[0])     # 450.0  — first element
print(fares[-1])    # 275.0  — last element (negative counts from end)
print(fares[1:3])   # [320.5, 210.0]  — slice: index 1 up to (not including) 3
print(fares[:3])    # [450.0, 320.5, 210.0]  — first 3  (like SQL LIMIT 3)
print(fares[-2:])   # [580.0, 275.0]         — last 2

# Four aggregate functions you will use every single day
print(len(fares))    # 5       — number of elements
print(sum(fares))    # 1835.5  — total fare revenue
print(min(fares))    # 210.0   — cheapest trip
print(max(fares))    # 580.0   — most expensive trip

fares = [450.0, 320.5, 210.0]

fares.append(580.0)       # add one item to END            → [..., 580.0]
fares.insert(0, 999.0)    # insert at specific index 0    → [999.0, 450.0, ...]
print(fares)               # [999.0, 450.0, 320.5, 210.0, 580.0]

fares.pop()                # remove & return LAST element  → 580.0
fares.pop(0)              # remove & return at index 0    → 999.0
fares.remove(210.0)       # remove FIRST occurrence of this value
print(fares)               # [450.0, 320.5]

fares = [450.0, 320.5, 210.0, 320.5]

print(fares.index(320.5))   # 1     — index of first occurrence
print(fares.count(320.5))   # 2     — how many times this value appears
print(320.5 in fares)       # True  — membership check
print(999.0 in fares)       # False

# Round brackets — type is 'tuple', not 'list'
pickup = (27.7172, 85.3240)   # (latitude, longitude)
print(type(pickup))             # <class 'tuple'>

# Access by index — identical to lists
print(pickup[0])   # 27.7172
print(pickup[1])   # 85.3240

# len, count, index work the same as lists
print(len(pickup))             # 2
print(pickup.count(27.7172))   # 1
print(pickup.index(85.3240))   # 1

# Tuples are immutable — modifying them raises an error:
# pickup[0] = 99   → TypeError: 'tuple' object does not support item assignment

# Unpack into named variables
lat, lon = (27.7172, 85.3240)
print(f"lat={lat}, lon={lon}")

# psycopg2 default cursor returns each row as a tuple
db_row = (1, "Sita Rai", "Kathmandu", 450.0)
trip_id, driver_name, city, fare = db_row
print(f"Trip {trip_id} by {driver_name} in {city}: NPR {fare}")

# Unpack inside a for loop — the most common ETL pattern
rows = [(1, "Alice", 450.0), (2, "Bob", 320.5)]
for trip_id, driver, fare in rows:
    print(f"  {trip_id}: {driver} — NPR {fare}")

# Lists CANNOT be dict keys — they're mutable, so their hash can change
# Tuples CAN be dict keys — they're immutable, so their hash is stable

city_stats = {}
city_stats[("Kathmandu", "completed")] = 142
city_stats[("Pokhara",   "completed")] = 88

print(city_stats[("Kathmandu", "completed")])   # 142

# Useful for grouping by multiple columns at once —
# the same idea as GROUP BY city, status in SQL

# Curly braces with no key:value pairs (those would be a dict)
driver_ids = {101, 102, 103, 101, 102}   # duplicates removed automatically
print(driver_ids)      # {101, 102, 103}  — order is NOT guaranteed
print(type(driver_ids)) # <class 'set'>

# Adding
driver_ids.add(104)
print(driver_ids)      # {101, 102, 103, 104}

# Removing
driver_ids.discard(999)   # safe — no error if 999 is not in the set
driver_ids.remove(104)    # raises KeyError if 104 is not found
print(driver_ids)          # {101, 102, 103}

active_ids = {101, 102, 103, 104, 105}

print(101 in active_ids)   # True  — same syntax as list, but O(1) speed
print(999 in active_ids)   # False

# Why it matters in a 1,000,000-row ETL loop:
#
#   list  with 10,000 IDs → up to 10,000 comparisons per row check
#   set   with 10,000 IDs → ~1 comparison regardless of set size
#
# At 1,000,000 rows: list = ~10 billion comparisons
#                    set  = ~1 million comparisons

active    = {101, 102, 103}
completed = {101, 103, 105}

print(active | completed)   # UNION:        {101, 102, 103, 105}  — in either
print(active & completed)   # INTERSECTION: {101, 103}            — in both
print(active - completed)   # DIFFERENCE:   {102}    — active but no completed trip
print(active ^ completed)   # SYMMETRIC Δ:  {102, 105}  — in one but not both

# Think of | as SQL UNION, & as SQL INNER JOIN on IDs, - as LEFT ANTI JOIN

trip = {
    "trip_id":     1,
    "driver_id":   101,
    "fare_amount": 450.0,
    "status":      "completed",
}

# Access by key
print(trip["trip_id"])       # 1
print(trip["fare_amount"])   # 450.0

# trip["rating"]  → KeyError: 'rating'  — crashes if key doesn't exist

# Safe access with .get()
print(trip.get("rating"))        # None  — no crash
print(trip.get("rating", 0))     # 0     — with a default value

trip = {"trip_id": 1, "driver_id": 101, "fare_amount": 450.0}

print(list(trip.keys()))    # ['trip_id', 'driver_id', 'fare_amount']
print(list(trip.values()))  # [1, 101, 450.0]
print(list(trip.items()))   # [('trip_id', 1), ('driver_id', 101), ...]

# Loop over key-value pairs — the most useful pattern
for key, value in trip.items():
    print(f"  {key}: {value}")

trip = {"trip_id": 1, "fare_amount": 450.0}

trip["status"]      = "completed"          # add a new key
trip["fare_amount"] = 500.0               # overwrite an existing key

trip.update({"tip": 50.0, "rating": 4.8}) # merge another dict in
removed = trip.pop("tip")                  # remove and return the value
print(removed)   # 50.0

# Python 3.9+: merge operator — returns a new dict, originals unchanged
extras = {"city": "Kathmandu"}
merged = trip | extras
print(merged)

drivers = [
    {"driver_id": 101, "driver_key": 1, "name": "Sita Rai"},
    {"driver_id": 102, "driver_key": 2, "name": "Ram Thapa"},
    {"driver_id": 103, "driver_key": 3, "name": "Gita Magar"},
]

id_to_key  = {d["driver_id"]: d["driver_key"] for d in drivers}
id_to_name = {d["driver_id"]: d["name"]       for d in drivers}

print(id_to_key)    # {101: 1, 102: 2, 103: 3}
print(id_to_name)   # {101: 'Sita Rai', 102: 'Ram Thapa', 103: 'Gita Magar'}

# Now resolve a driver_id in O(1) — no database call:
print(id_to_name.get(101, "Unknown"))   # "Sita Rai"

raw = "  Kathmandu  "

print(raw.strip())    # "Kathmandu"    — remove both sides
print(raw.lstrip())   # "Kathmandu  "  — left side only
print(raw.rstrip())   # "  Kathmandu"  — right side only

city = raw.strip()    # clean first, then transform
print(city.upper())   # "KATHMANDU"
print(city.lower())   # "kathmandu"
print(city.title())   # "Kathmandu"  — first letter of each word capitalised

# In ETL: strip().lower() normalises values before comparison
cities = ["Kathmandu", "kathmandu", "  KATHMANDU  "]
normalised = [c.strip().lower() for c in cities]
print(normalised)   # ['kathmandu', 'kathmandu', 'kathmandu']

status = "trip_completed_ok"
city   = "Kathmandu"

print(city.startswith("Kath"))    # True
print(city.endswith("andu"))     # True
print("ath" in city)            # True  — substring membership
print(city.isdigit())            # False
print("12345".isdigit())         # True

print(status.find("completed"))  # 5   — index of first match; -1 if not found
print(status.replace("_", " "))  # "trip completed ok"

# Parsing a CSV line
csv_line = "1,Sita Rai,Kathmandu,450.0,completed"
parts    = csv_line.split(",")
print(parts)
# ['1', 'Sita Rai', 'Kathmandu', '450.0', 'completed']

# zip() headers with values to get a dict
headers  = ["trip_id", "driver_name", "city", "fare_amount", "status"]
row_dict = dict(zip(headers, parts))
print(row_dict)
# {'trip_id': '1', 'driver_name': 'Sita Rai', 'city': 'Kathmandu', ...}

# join() to build SQL INSERT placeholders
placeholders = ", ".join(["%s"] * len(headers))
print(placeholders)   # %s, %s, %s, %s, %s

fare   = 1000450.75
count  = 1500000
driver = "Sita Rai"

print(f"Fare: {fare:.2f}")         # "Fare: 1000450.75"   — 2 decimal places
print(f"Fare: {fare:,.2f}")        # "Fare: 1,000,450.75" — with comma separators
print(f"Rows: {count:,}")          # "Rows: 1,500,000"    — whole number with commas

# Column alignment — useful in log messages and text reports
print(f"{'Driver':<15}{'Fare':>12}")         # headers
print(f"{driver:<15}{fare:>12,.2f}")           # data row
# Driver             1,000,450.75

fares = [450.0, 320.5, 210.0, 580.0]

# Basic for — when you just need the values
for fare in fares:
    print(fare)

# enumerate — when you also need the position (start=1 for human-readable row numbers)
for i, fare in enumerate(fares, start=1):
    print(f"  [{i}] {fare}")

# enumerate over a list of dicts — the core ETL loop
trips = [
    {"trip_id": 1, "fare_amount": 450.0, "status": "completed"},
    {"trip_id": 2, "fare_amount": 320.5, "status": "cancelled"},
]
for row_num, trip in enumerate(trips, start=1):
    if trip["status"] != "completed":
        continue   # skip to next row
    print(f"Row {row_num}: trip {trip['trip_id']} = {trip['fare_amount']}")

# while — consuming a queue or processing rows in batches
rows       = list(range(100))
batch_size = 20

while rows:
    batch = rows[:batch_size]
    rows  = rows[batch_size:]
    print(f"  Processing {len(batch)} rows, {len(rows)} remaining")

# zip — walk two lists in parallel (headers + values from a cursor row)
headers = ["trip_id", "fare_amount", "status"]
values  = [1, 450.0, "completed"]

for key, val in zip(headers, values):
    print(f"  {key}: {val}")

# One-liner to build a row dict from headers + values:
row_dict = dict(zip(headers, values))   # {'trip_id': 1, 'fare_amount': 450.0, ...}

trips = [
    {"trip_id": 1, "fare_amount": 450.0, "status": "completed"},
    {"trip_id": 2, "fare_amount": 320.5, "status": "cancelled"},
    {"trip_id": 3, "fare_amount": 580.0, "status": "completed"},
]

# List comprehension — filter + transform in one line
completed_fares = [t["fare_amount"] for t in trips if t["status"] == "completed"]
print(completed_fares)   # [450.0, 580.0]

# Dict comprehension — build a lookup in one line
id_to_fare = {t["trip_id"]: t["fare_amount"] for t in trips}
print(id_to_fare)        # {1: 450.0, 2: 320.5, 3: 580.0}

# Set comprehension — unique values from a column
statuses = {t["status"] for t in trips}
print(statuses)          # {'completed', 'cancelled'}

# any() / all() — aggregate boolean checks
print(any(t["status"] == "cancelled" for t in trips))   # True
print(all(t["fare_amount"] > 100       for t in trips))   # True