fruits = ["apple", "banana", "cherry"]

# Access -- O(1), instant lookup by index
print(fruits[0])   # apple
print(fruits[-1])  # cherry (Negative indexing: -1 is last, -2 is second-to-last)

# Modify
fruits.append("date")      # O(1) amortized -- add to end
fruits.insert(1, "berry")  # O(n) -- shifts everything after index 1
fruits.pop()               # O(1) -- remove and return last item
fruits.pop(0)              # O(n) -- remove from front shifts everything

# If you need fast insert/remove from both ends, use collections.deque instead

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

print(nums[0:5])   # [0, 1, 2, 3, 4] (Start is inclusive, End is exclusive)
print(nums[:5])    # [0, 1, 2, 3, 4] (Start defaults to 0)
print(nums[5:])    # [5, 6, 7, 8, 9] (End defaults to length)
print(nums[::2])   # [0, 2, 4, 6, 8] (Step 2: every second item)
print(nums[::-1])  # [9, 8, ..., 0]  (Reverse the list!)

# The Old Way (explicit loop with append)
squares = []
for x in range(10):
    squares.append(x**2)

# The Pythonic Way -- list comprehension
# Pattern: [expression for item in iterable]
squares = [x**2 for x in range(10)]

# With a condition (filter items)
evens = [x for x in range(10) if x % 2 == 0]

# Nested comprehension (flatten a matrix)
matrix = [[1, 2], [3, 4], [5, 6]]
flat = [num for row in matrix for num in row]  # [1, 2, 3, 4, 5, 6]
# Read it as: "for each row in matrix, for each num in row, give me num"

# With if-else (note: goes BEFORE the for, not after)
labels = ["even" if x % 2 == 0 else "odd" for x in range(5)]
# ["even", "odd", "even", "odd", "even"]

user = {
    "name": "Alice",
    "age": 30,
    "is_admin": True
}

# Access -- O(1) average case
print(user["name"])
# print(user["email"])  # KeyError! Key does not exist.

# Safe Access -- the Pythonic way to handle missing keys
print(user.get("email"))          # Returns None (no crash)
print(user.get("email", "N/A"))   # Returns "N/A" (custom default)

# Modify
user["email"] = "alice@example.com"  # Add or overwrite a key
del user["is_admin"]                  # Remove a key (KeyError if missing)
user.pop("is_admin", None)            # Safer remove -- returns None if missing

# Iterate -- .items() gives (key, value) pairs
for key, value in user.items():
    print(f"{key}: {value}")

defaults = {"color": "blue", "size": "medium"}
overrides = {"size": "large", "weight": "heavy"}

# Python 3.9+ -- the merge operator (cleanest)
merged = defaults | overrides  # {"color": "blue", "size": "large", "weight": "heavy"}

# Python 3.5+ -- unpacking (works everywhere)
merged = {**defaults, **overrides}

# In-place update (mutates defaults)
defaults.update(overrides)

# setdefault: get a value, or insert a default if missing (one atomic operation)
# Useful for building up groups without checking "is key present?"
groups = {}
for name, dept in [("Alice", "Eng"), ("Bob", "Eng"), ("Carol", "Sales")]:
    groups.setdefault(dept, []).append(name)
# {"Eng": ["Alice", "Bob"], "Sales": ["Carol"]}

# Walrus operator (:=) with dict -- Python 3.8+
# Assign and test in one expression
if (email := user.get("email")) is not None:
    send_notification(email)

# Map number to its square
squares = {x: x**2 for x in range(5)}
# Result: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

numbers = {1, 2, 2, 3, 3, 3}
print(numbers)  # {1, 2, 3} (Duplicates removed automatically)

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)  # Union: {1, 2, 3, 4, 5} (Items in either)
print(a & b)  # Intersection: {3} (Items in both)
print(a - b)  # Difference: {1, 2} (Items in a but not b)
print(a ^ b)  # Symmetric difference: {1, 2, 4, 5} (Items in one but not both)

# Membership testing: set is O(1), list is O(n)
# This matters when checking against large collections in a loop
valid_ids = {1001, 1002, 1003, 1004, 1005}  # Use a set, not a list
if user_id in valid_ids:                      # O(1) lookup
    grant_access()

# Deduplication while preserving order (Python 3.7+)
items = [3, 1, 4, 1, 5, 9, 2, 6, 5]
unique_ordered = list(dict.fromkeys(items))  # [3, 1, 4, 5, 9, 2, 6]
# dict.fromkeys preserves insertion order and drops duplicates (keys are unique)

point = (10, 20)
# point[0] = 30  # TypeError! Tuples are immutable.

# Unpacking -- assign tuple elements to individual variables
x, y = point
print(x, y)  # 10 20

# Unpacking with * (star) to capture the rest
first, *rest = (1, 2, 3, 4, 5)
print(first)  # 1
print(rest)   # [2, 3, 4, 5] -- note: rest is a list, not a tuple

# Named Tuples -- give your tuples readable field names
from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
print(p.x, p.y)  # 10, 20 -- much clearer than p[0], p[1]

# Modern alternative: typing.NamedTuple (Python 3.6+)
from typing import NamedTuple

class Point(NamedTuple):
    x: float
    y: float
    z: float = 0.0  # Default values supported

p = Point(1.0, 2.0)
print(p)  # Point(x=1.0, y=2.0, z=0.0)

from collections import Counter

colors = ["red", "blue", "red", "green", "blue", "blue"]
c = Counter(colors)

print(c) # Counter({'blue': 3, 'red': 2, 'green': 1})
print(c.most_common(1)) # [('blue', 3)]

from collections import defaultdict

# Default value is list() -> [] (called each time a missing key is accessed)
groups = defaultdict(list)

groups["A"].append("Alice")  # Key "A" did not exist -- created [], then appended
groups["B"].append("Bob")

# Common patterns:
word_count = defaultdict(int)     # Missing keys default to 0
nested = defaultdict(dict)         # Missing keys default to {}

# Counting pattern -- cleaner than manual if/else
for word in ["apple", "banana", "apple", "cherry", "banana", "apple"]:
    word_count[word] += 1
# defaultdict(<class 'int'>, {'apple': 3, 'banana': 2, 'cherry': 1})