# int — arbitrary precision, NO overflow!
print(10 ** 100)   # googol — no problem in Python
binary = 0b1010    # 10
octal  = 0o17      # 15
hexa   = 0xFF      # 255
big    = 1_000_000 # underscores for readability

# float — IEEE 754 double (64-bit)
print(0.1 + 0.2)         # 0.30000000000000004 ← floating point!
print(0.1 + 0.2 == 0.3)  # False!

import math
print(math.isclose(0.1 + 0.2, 0.3))  # True — correct comparison

# For money: use Decimal, NOT float
from decimal import Decimal, getcontext
getcontext().prec = 28
price = Decimal("19.99")   # ALWAYS pass as string!
tax   = Decimal("0.18")
print(price * tax)         # 3.5982 (exact!)

# Division types
print(7 / 2)     # 3.5   — true division (always float)
print(7 // 2)    # 3     — floor division
print(-7 // 2)   # -4    — floors towards -infinity!
print(7 % 2)     # 1     — modulo
print(2 ** 10)   # 1024  — power

# int() truncates (towards zero), // floors (towards -inf)
print(int(-3.9))   # -3  (truncate)
print(-3.9 // 1)   # -4  (floor)

# Falsy values in Python:
# False, None, 0, 0.0, 0j, "", [], {}, set(), ()
# Everything else is truthy!

print(bool([]))      # False — empty list
print(bool([0]))     # True  — list with ONE item
print(bool(""))      # False — empty string
print(bool("0"))     # True  — non-empty string
print(bool(0))       # False
print(bool(0.0))     # False
print(bool(None))    # False

# bool is a subclass of int!
print(isinstance(True, int))   # True
print(True + True)             # 2
print(True * 5)                # 5
print(True == 1)               # True
print(False == 0)              # True

# short-circuit evaluation
x = None
name = x or "default"    # "default" — x is falsy
y = [1,2,3]
first = y and y[0]       # 1 — y is truthy, returns y[0]

# and/or return values, not booleans!
print(0 or "hello")    # "hello"
print(5 and "hello")   # "hello"
print([] or {})        # {}  — both falsy, returns last

# Variable = label pointing to an object in memory
a = [1, 2, 3]   # a → list object at memory 0x1234
b = a           # b → SAME list object at 0x1234
b.append(4)
print(a)        # [1, 2, 3, 4] — BOTH see the change!

# Assignment creates a new binding, not a copy
b = [99]        # b now → different list at 0x5678
print(a)        # [1, 2, 3, 4] — a unchanged

# Augmented assignment on immutable creates new object
x = 5
print(id(x))   # some memory address
x += 1         # x now points to NEW int(6)!
print(id(x))   # different address

# Augmented assignment on mutable modifies in-place
lst = [1, 2]
print(id(lst))
lst += [3]     # calls lst.__iadd__([3]) — in-place
print(id(lst)) # SAME address!

# Multiple assignment, swap (no temp variable needed)
a, b = 1, 2
a, b = b, a    # swap — Python evaluates right side first

# Chained assignment
x = y = z = 0  # all point to SAME int(0) object
x = y = z = [] # ⚠️ all point to SAME list! (gotcha)

s = "Python"
print(s[0])       # 'P'
print(s[-1])      # 'n'  — negative = from end
print(s[0:3])     # 'Pyt'  — stop is EXCLUSIVE
print(s[2:])      # 'thon' — to end
print(s[:4])      # 'Pyth' — from start
print(s[::2])     # 'Pto'  — every 2nd char
print(s[::-1])    # 'nohtyP' ← REVERSE!

# Strings are immutable
s[0] = "J"     # TypeError!
s = "J" + s[1:]  # must create new string

# String repetition
print("ha" * 3)         # "hahaha"
print("-" * 40)         # separator line

# Efficient joining
parts = ["Hello", "World", "Python"]
result = " ".join(parts)  # O(n) — correct!
# result = ""; for p in parts: result += p  ← O(n²)!

# Check membership
print("Py" in "Python")  # True
print("py" in "Python")  # False — case sensitive

s = "  Hello, World!  "

# Case
s.upper(); s.lower(); s.title(); s.swapcase()

# Strip
s.strip()       # "Hello, World!"  (both ends)
s.lstrip()      # strip left only
s.rstrip()      # strip right only
s.strip("!")    # strip specific char

# Search
s.find("World")     # 9 — index, or -1 if not found
s.index("World")    # 9 — index, raises ValueError if not found
s.count("l")        # 3
s.startswith("  H") # True
s.endswith("  ")    # True

# Split & replace
"a,b,c".split(",")         # ['a', 'b', 'c']
"a,b,c".split(",", 1)      # ['a', 'b,c'] — max 1 split
"a b c".split()            # ['a', 'b', 'c'] — split on whitespace
"hello".replace("l", "L")  # "heLLo"
"hello".replace("l","L",1) # "heLlo" — max 1 replacement

# Check content
"123".isdigit()    # True
"abc".isalpha()    # True
"abc123".isalnum() # True
"  ".isspace()     # True
"abc".islower()    # True

# Encoding
"Hello".encode("utf-8")         # b'Hello'
b"Hello".decode("utf-8")        # 'Hello'

name = "Ravi"; score = 95.678

# 1. % formatting (legacy, avoid)
"Hello %s, score %.2f" % (name, score)

# 2. .format()
"Hello {}, score {:.2f}".format(name, score)
"Hello {n}, score {s:.2f}".format(n=name, s=score)

# 3. f-strings (Python 3.6+) — FASTEST
f"Hello {name}, score {score:.2f}"
f"{name!r}"           # repr: 'Ravi'
f"{score:010.3f}"     # 000095.678
f"{1_000_000:,}"      # 1,000,000
f"{'center':^20}"     # centered in 20 chars
f"{'left':<20}"       # left-aligned
f"{'right':>20}"      # right-aligned

# Python 3.8+ — self-documenting expressions
x = 42
print(f"{x = }")       # x = 42
print(f"{2 + 2 = }")   # 2 + 2 = 4

# 4. Template strings (safe for user input)
from string import Template
t = Template("Hello $name")
t.substitute(name="Ravi")   # "Hello Ravi"

# Raw strings — backslash NOT processed
path = r"C:\Users\name\docs"   # no need to escape \
regex = r"\d+\.\d+"            # regex patterns

import re

text = "My email is ravi@example.com and priya@test.org"

# search — find FIRST match anywhere
m = re.search(r"\w+@\w+\.\w+", text)
print(m.group())     # "ravi@example.com"
print(m.start())     # 12
print(m.end())       # 28

# findall — ALL matches as list
emails = re.findall(r"\w+@\w+\.\w+", text)
print(emails)        # ['ravi@example.com', 'priya@test.org']

# match — only matches at START of string
re.match(r"\d+", "123abc")   # Match
re.match(r"\d+", "abc123")   # None

# sub — replace matches
result = re.sub(r"\w+@\w+\.\w+", "[REDACTED]", text)

# Groups
m = re.search(r"(\w+)@(\w+)\.(\w+)", text)
print(m.group(0))   # full match
print(m.group(1))   # "ravi"
print(m.group(2))   # "example"

# Named groups
m = re.search(r"(?P<user>\w+)@(?P<domain>\w+)", text)
print(m.group("user"))    # "ravi"

# Compile for reuse (faster in loops)
pattern = re.compile(r"\d+", re.IGNORECASE)
pattern.findall("abc123def456")   # ['123', '456']

# Flags: re.IGNORECASE, re.MULTILINE, re.DOTALL

a = [1, 2, 3]
a.append(4)                   # [1,2,3,4]
a.insert(1, 99)               # [1,99,2,3,4]
a.extend([5, 6])              # add multiple
a.remove(99)                  # remove first occurrence
a.pop()                       # remove+return last
a.pop(0)                      # remove+return index 0 — O(n)!
del a[1:3]                    # delete slice

# Sorting
a.sort()                      # in-place, returns None
a.sort(key=lambda x: -x)      # sort by key
a.sort(key=lambda x: x%3, reverse=True)
b = sorted(a)                 # returns NEW list
b = sorted(a, key=len)        # for strings

# shallow vs deep copy
b = a[:]                      # shallow copy
b = a.copy()                  # shallow copy
import copy
b = copy.deepcopy(a)          # deep copy

# Unpacking
first, *rest = [1, 2, 3, 4]  # first=1, rest=[2,3,4]
a, b, c = [1, 2, 3]

d = {"name": "Ravi", "age": 25}
d = dict(name="Ravi", age=25)
d = {i: i**2 for i in range(5)}  # comprehension
d = dict(zip(["a","b"], [1,2]))   # {'a':1,'b':2}

# Safe access
d["name"]                  # "Ravi" — KeyError if missing
d.get("name")              # "Ravi" — None if missing
d.get("phone", "N/A")      # "N/A" — default

# Modify
d["email"] = "r@r.com"     # add or update
d.update({"city": "MUM"})  # merge dict
d |= {"x": 1}              # merge operator (3.9+)
merged = d1 | d2           # new merged dict (3.9+)

# Delete
del d["age"]               # KeyError if missing
d.pop("age")               # remove + return
d.pop("age", None)         # safe — no error
d.popitem()                # remove + return last item

# Iteration
for k in d:                # keys (default)
    pass
for k, v in d.items():     # key-value pairs
    pass

# setdefault
d.setdefault("scores", []).append(95)
# If "scores" missing, create []; then append

# defaultdict
from collections import defaultdict
wc = defaultdict(int)      # auto 0 for missing keys
wc["hello"] += 1           # no KeyError!
groups = defaultdict(list)
groups["even"].append(2)   # no KeyError!

s = {1, 2, 3}
s = set([1,2,2,3])  # {1,2,3} — deduplicates
s = set()           # ⚠️ NOT {} — that's a dict!

s.add(4); s.update([5,6])
s.remove(4)         # KeyError if missing
s.discard(99)       # safe — no error

# Set math
a = {1,2,3,4}; b = {3,4,5,6}
a | b   # {1,2,3,4,5,6} — union
a & b   # {3,4}          — intersection
a - b   # {1,2}          — difference
a ^ b   # {1,2,5,6}      — symmetric diff
a.issubset(b); a.issuperset(b); a.isdisjoint(b)

# O(1) membership — use set, not list!
valid = {"MUM","DEL","BLR"}
if "MUM" in valid:   # O(1) vs O(n) for list
    pass

# frozenset — immutable, hashable set
fs = frozenset([1,2,3])
d = {fs: "value"}    # ✅ can be dict key

# Deduplicate preserving order (3.7+)
data = [3,1,4,1,5,9,2,6,5,3]
unique = list(dict.fromkeys(data))  # [3,1,4,5,9,2,6]

from collections import Counter, deque, namedtuple, ChainMap, OrderedDict

# Counter — count occurrences
c = Counter(["a","b","a","c","a","b"])
print(c)                 # Counter({'a':3,'b':2,'c':1})
print(c.most_common(2))  # [('a',3),('b',2)]
print(c["z"])            # 0 — not KeyError!
c1 = Counter("abcc"); c2 = Counter("abc")
print(c1 - c2)           # Counter({'c':1})
print(c1 + c2)           # Counter({'c':3,'a':2,'b':2})

# deque — O(1) on BOTH ends (list.pop(0) is O(n)!)
dq = deque([1,2,3], maxlen=5)
dq.appendleft(0)          # add to left O(1)
dq.popleft()              # remove from left O(1)
dq.rotate(1)              # rotate right
# maxlen: auto-drops oldest — sliding window!

# namedtuple — tuple with field names
Point = namedtuple("Point", ["x","y"])
p = Point(3, 4)
print(p.x, p.y)           # attribute access
print(p[0], p[1])         # index access still works
print(p._asdict())        # {'x':3,'y':4}

# ChainMap — search multiple dicts as one
defaults = {"color":"blue","size":"md"}
overrides = {"color":"red"}
cm = ChainMap(overrides, defaults)
print(cm["color"])        # "red" — overrides first
print(cm["size"])         # "md"  — from defaults

score = 85
if score >= 90: grade = "A"
elif score >= 80: grade = "B"
else: grade = "F"

# Ternary
status = "pass" if score >= 50 else "fail"

# Chained comparisons (Python-specific!)
if 0 <= score <= 100:    # cleaner than x>=0 and x<=100
    print("valid")

# match statement (Python 3.10+)
command = "quit"
match command:
    case "quit":
        print("Quitting")
    case "go north" | "go south":  # OR pattern
        print("Moving")
    case str(s) if s.startswith("load"):  # guard
        print(f"Loading: {s}")
    case _:                        # wildcard
        print("Unknown")

# match with destructuring
point = (0, 5)
match point:
    case (0, 0): print("origin")
    case (0, y): print(f"y-axis at {y}")
    case (x, 0): print(f"x-axis at {x}")
    case (x, y): print(f"({x},{y})")

# enumerate — index + value
fruits = ["apple","banana","cherry"]
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}: {fruit}")

# zip — parallel iteration
names = ["Ravi","Priya"]
scores = [95, 88]
for name, score in zip(names, scores):
    print(f"{name}: {score}")
# zip stops at shortest — use zip_longest for unequal

# for...else — else runs if NO break occurred
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(f"{n} composite"); break
    else:
        print(f"{n} is prime")  # only when no break

# while...else — else runs when condition becomes False
i = 0
while i < 5:
    i += 1
else:
    print("done")   # always runs unless break

# itertools — lazy combinatorial tools
import itertools

list(itertools.chain([1,2],[3,4]))       # [1,2,3,4]
list(itertools.islice(range(100),5))    # [0,1,2,3,4]
list(itertools.product("AB",[1,2]))     # cartesian product
list(itertools.combinations("ABCD",2)) # all 2-combos
list(itertools.permutations("ABC",2))  # all 2-perms
list(itertools.groupby(sorted("aabbc"),
    key=lambda x:x))   # groups same consecutive
# accumulate — running sum
list(itertools.accumulate([1,2,3,4]))  # [1,3,6,10]

# Lambda — anonymous one-liner
square = lambda x: x**2
add = lambda x, y: x + y

# Best use: key= argument
people = [("Ravi",25), ("Priya",22), ("Aman",28)]
people.sort(key=lambda p: p[1])         # sort by age
oldest = max(people, key=lambda p: p[1])

# Sort by multiple keys
data = [{"name":"A","age":25},{"name":"B","age":25,"score":90}]
data.sort(key=lambda x: (x["age"], x.get("score",0)))

# map — apply function to each item (returns iterator)
nums = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, nums))
# Prefer: [x**2 for x in nums]

# filter — keep where function is True (returns iterator)
evens = list(filter(lambda x: x%2==0, nums))
# Prefer: [x for x in nums if x%2==0]

# functools.reduce — fold
from functools import reduce
product = reduce(lambda acc, x: acc*x, nums)  # 24

# functools.partial — fix some arguments
from functools import partial
def power(base, exp): return base ** exp
square = partial(power, exp=2)
cube   = partial(power, exp=3)
square(5)   # 25
cube(3)     # 27

from functools import lru_cache, cache, wraps

# lru_cache — memoization (Least Recently Used)
@lru_cache(maxsize=128)
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

print(fib(50))   # instant! (without cache: 2^50 calls)
print(fib.cache_info())   # hits, misses, currsize
fib.cache_clear()         # clear cache

# cache (Python 3.9+) — like lru_cache(maxsize=None)
@cache
def expensive(n):
    return n * 2

# wraps — preserve function metadata in decorators
def my_decorator(func):
    @wraps(func)           # ← ALWAYS include this!
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

# Without @wraps: func.__name__ == "wrapper" (wrong)
# With @wraps:    func.__name__ == "original" (correct)

# total_ordering — define < and == only, get all comparisons
from functools import total_ordering

@total_ordering
class Student:
    def __init__(self, grade): self.grade = grade
    def __eq__(self, other): return self.grade == other.grade
    def __lt__(self, other): return self.grade < other.grade
    # <=, >, >= are auto-generated!

class A:
    def method(self): return "A"

class B(A):
    def method(self): return "B→" + super().method()

class C(A):
    def method(self): return "C→" + super().method()

class D(B, C):    # Diamond inheritance
    pass

d = D()
print(d.method())    # "B→C→A" — MRO: D, B, C, A, object
print(D.__mro__)     # (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)
print(D.mro())       # same as list

# super() uses MRO — NOT just the direct parent!
# That's why B.super() calls C, not A, in this diamond

# isinstance and issubclass
print(isinstance(d, B))      # True
print(isinstance(d, A))      # True — A is ancestor
print(issubclass(D, C))      # True
print(issubclass(int, object)) # True — everything is object

# Abstract base classes
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: pass    # must implement
    @abstractmethod
    def perimeter(self) -> float: pass

    def describe(self):              # concrete method — can use!
        return f"Area={self.area()}"

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r**2
    def perimeter(self): return 2 * 3.14159 * self.r

# Shape() → TypeError: Can't instantiate abstract class

from dataclasses import dataclass, field
from typing import ClassVar

@dataclass
class User:
    name: str
    email: str
    age: int = 0
    # mutable default MUST use field(default_factory=...)
    tags: list = field(default_factory=list)
    _id: str = field(init=False, repr=False)  # not in __init__
    count: ClassVar[int] = 0   # class variable, not a field

    def __post_init__(self):   # runs after auto __init__
        self._id = f"user_{self.name.lower()}"
        User.count += 1

# frozen=True — immutable (auto __hash__ too)
@dataclass(frozen=True)
class Point:
    x: float
    y: float

# order=True — auto __lt__, __le__, __gt__, __ge__
@dataclass(order=True)
class Version:
    major: int
    minor: int
    patch: int

v1 = Version(1,2,0); v2 = Version(1,3,0)
print(v1 < v2)     # True — compares field by field!

# slots=True (Python 3.10+) — memory efficient
@dataclass(slots=True)
class FastPoint:
    x: float
    y: float

class Regular:
    def __init__(self, x, y):
        self.x = x; self.y = y
    # has __dict__ — flexible but heavy

class Slotted:
    __slots__ = ['x', 'y']   # declare allowed attributes
    def __init__(self, x, y):
        self.x = x; self.y = y
    # NO __dict__ — fast, memory-efficient

import sys
r = Regular(1, 2)
s = Slotted(1, 2)
print(sys.getsizeof(r))   # ~168 bytes
print(sys.getsizeof(s))   # ~56 bytes

# Slotted cannot have dynamic attributes
s.z = 3   # AttributeError!

# Use case: ML data rows, game objects, anything with millions of instances

# Inheritance with slots
class Base:
    __slots__ = ['x']

class Child(Base):
    __slots__ = ['y']  # add y; x inherited from Base
    # if Child omits __slots__, it gets __dict__ back!

# Descriptor — reusable validation for any attribute
class PositiveNumber:
    def __set_name__(self, owner, name):
        self.name = name            # called when class is created

    def __get__(self, obj, objtype=None):
        if obj is None: return self  # accessed from class
        return getattr(obj, f"_{self.name}", 0)

    def __set__(self, obj, value):
        if value <= 0:
            raise ValueError(f"{self.name} must be positive")
        setattr(obj, f"_{self.name}", value)

class Product:
    price  = PositiveNumber()   # descriptor instance
    weight = PositiveNumber()   # reused for different attr

    def __init__(self, price, weight):
        self.price = price     # triggers PositiveNumber.__set__
        self.weight = weight

p = Product(10.0, 2.5)
p.price = -5    # ValueError: price must be positive

# How property is implemented (roughly)
class property_impl:
    def __init__(self, fget, fset=None, fdel=None):
        self.fget = fget
        self.fset = fset

    def __get__(self, obj, objtype=None):
        if obj is None: return self
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError("can't set attribute")
        self.fset(obj, value)

# Iterable: has __iter__ → returns an iterator
# Iterator: has __iter__ AND __next__

lst = [1, 2, 3]
it = iter(lst)        # create iterator
print(next(it))       # 1
print(next(it))       # 2
print(next(it))       # 3
print(next(it))       # StopIteration!

# for loop is just sugar for this:
it = iter(lst)
while True:
    try:
        item = next(it)
        print(item)
    except StopIteration:
        break

# Custom iterator class
class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):   # makes it iterable
        return self

    def __next__(self):   # makes it an iterator
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

for n in Countdown(3):
    print(n)    # 3, 2, 1

# Generator function — uses yield
def countdown(start):
    while start > 0:
        yield start       # pause here, return value
        start -= 1        # resume from here next time
    # StopIteration raised automatically when function ends

gen = countdown(3)
print(next(gen))   # 3
print(next(gen))   # 2
for n in countdown(5): print(n)  # 5,4,3,2,1

# Infinite generator — impossible with list!
def integers(start=0):
    while True:
        yield start
        start += 1

gen = integers()
print(next(gen))   # 0
print(next(gen))   # 1 — generates forever

# Generator pipeline — chained lazy evaluation
def read_large_file(path):
    with open(path) as f:
        for line in f:        # reads ONE line at a time
            yield line.strip()

def filter_errors(lines):
    for line in lines:
        if "ERROR" in line:   # processes one line at a time
            yield line

def parse_error(lines):
    for line in lines:
        yield line.split("|") # processes one at a time

# Memory: O(1) — only one line in memory at any time!
errors = parse_error(filter_errors(read_large_file("app.log")))

# yield from — delegate to sub-generator
def chain(*iterables):
    for it in iterables:
        yield from it

list(chain([1,2], [3,4], [5]))  # [1,2,3,4,5]

# Generator send() — bidirectional
def accumulator():
    total = 0
    while True:
        value = yield total   # yield sends out, receives in
        total += value

acc = accumulator()
next(acc)          # prime the generator
print(acc.send(10))   # 10
print(acc.send(20))   # 30

import threading, queue, time

# Basic thread
def worker(name, delay):
    time.sleep(delay)
    print(f"{name} done")

t = threading.Thread(target=worker, args=("T1", 1), daemon=True)
t.start()
t.join()   # wait for thread to finish

# Thread pool — reuse threads
from concurrent.futures import ThreadPoolExecutor

urls = ["url1","url2","url3","url4","url5"]

with ThreadPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(fetch, url) for url in urls]
    results = [f.result() for f in futures]  # blocks until done

# Or use map (like Pool.map)
with ThreadPoolExecutor(max_workers=5) as ex:
    results = list(ex.map(fetch, urls))

# Thread safety — Race condition
counter = 0
lock = threading.Lock()

def increment():
    global counter
    with lock:         # acquire lock, auto-release
        counter += 1

threads = [threading.Thread(target=increment) for _ in range(100)]
for t in threads: t.start()
for t in threads: t.join()
print(counter)   # 100 — correct with lock

# Other synchronization
event = threading.Event()
event.set()     # signal all waiting threads
event.wait()    # block until event is set
event.clear()

sem = threading.Semaphore(5)  # allow 5 threads at once
with sem: pass  # auto acquire/release

# Thread-safe queue
q = queue.Queue(maxsize=10)
q.put("item")
item = q.get()   # blocks if empty
q.task_done()

from multiprocessing import Pool, Process, Queue, Value, Array, Manager
from concurrent.futures import ProcessPoolExecutor
import os

# Process pool — the right way
def cpu_work(n):
    return sum(i**2 for i in range(n))

with Pool(processes=4) as pool:    # 4 separate processes
    results = pool.map(cpu_work, [10**6]*4)  # parallel!

# ProcessPoolExecutor — modern API
with ProcessPoolExecutor(max_workers=4) as ex:
    futures = list(ex.map(cpu_work, [10**6]*4))

# Shared state between processes
shared_val = Value('i', 0)    # shared int
shared_arr = Array('d', 10)   # shared double[10]

def worker(val):
    with val.get_lock():
        val.value += 1

# Manager — more flexible shared state
with Manager() as manager:
    shared_list = manager.list([])
    shared_dict = manager.dict({})

# Process communication via Queue
def producer(q):
    for i in range(5):
        q.put(i)
    q.put(None)    # sentinel

def consumer(q):
    while (item := q.get()) is not None:
        print(item)

q = Queue()
p1 = Process(target=producer, args=(q,))
p2 = Process(target=consumer, args=(q,))
p1.start(); p2.start()
p1.join(); p2.join()

# Key: processes have SEPARATE memory — no shared state by default
# Each process is a full Python interpreter with its own GIL

# Always use 'with' — auto-closes file even on exception
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()          # entire file as string
    lines = content.splitlines() # list of lines (no \n)

# File modes
# "r"  — read (default)
# "w"  — write (overwrites!)
# "a"  — append
# "x"  — exclusive create (fails if exists)
# "r+" — read+write
# "rb" — binary read

# Efficient line-by-line (lazy — O(1) memory)
with open("large_file.txt") as f:
    for line in f:              # reads one line at a time
        process(line)

# Write
with open("out.txt", "w") as f:
    f.write("Hello\n")
    f.writelines(["line1\n","line2\n"])
    print("formatted", file=f)  # redirect print to file

# JSON
import json
with open("data.json") as f:
    data = json.load(f)         # file → dict
with open("out.json","w") as f:
    json.dump(data, f, indent=2, ensure_ascii=False)
json.loads('{"key":"val"}')     # string → dict
json.dumps({"key":"val"})       # dict → string

# CSV
import csv
with open("data.csv") as f:
    reader = csv.DictReader(f)    # row as dict
    for row in reader: print(row["name"])

with open("out.csv","w",newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["name","age"])
    writer.writeheader()
    writer.writerow({"name":"Ravi","age":25})

# pathlib (modern, preferred over os.path)
from pathlib import Path
p = Path("data") / "logs" / "app.log"
print(p.exists(), p.is_file(), p.suffix)  # .log
p.mkdir(parents=True, exist_ok=True)
text = p.read_text(encoding="utf-8")
p.write_text("content")
for f in Path(".").glob("*.py"): print(f)
list(Path(".").rglob("*.py"))   # recursive

# Context manager = __enter__ + __exit__
# 'with' guarantees __exit__ runs even on exception

# Class-based context manager
class DatabaseConnection:
    def __init__(self, url):
        self.url = url
        self.conn = None

    def __enter__(self):
        self.conn = connect(self.url)
        return self.conn          # what 'as' binds to

    def __exit__(self, exc_type, exc_val, traceback):
        self.conn.close()
        if exc_type: print(f"Error: {exc_val}")
        return False              # False = don't suppress exceptions
        # True = suppress exception (rarely want this)

with DatabaseConnection("sqlite:///db") as conn:
    conn.execute("SELECT * FROM users")

# @contextmanager — generator-based (simpler!)
from contextlib import contextmanager

@contextmanager
def timer(name):
    import time
    start = time.perf_counter()
    try:
        yield                     # code inside 'with' runs here
    finally:                      # always cleanup
        elapsed = time.perf_counter() - start
        print(f"{name}: {elapsed:.3f}s")

with timer("my operation"):
    time.sleep(0.1)              # "my operation: 0.100s"

# contextlib utilities
from contextlib import suppress, redirect_stdout, nullcontext
import io

with suppress(FileNotFoundError):       # ignore specific errors
    os.remove("maybe.txt")

f = io.StringIO()
with redirect_stdout(f):                # capture print output
    print("captured!")
output = f.getvalue()   # "captured!\n"

# Multiple context managers
with open("in.txt") as fin, open("out.txt","w") as fout:
    fout.write(fin.read())

# Type conversion
int("42"), float("3.14"), str(42), bool(0)
list("abc")     # ['a','b','c']
tuple([1,2,3])  # (1,2,3)
set([1,2,2,3])  # {1,2,3}
dict(a=1,b=2)   # {'a':1,'b':2}

# Numeric
abs(-5)         # 5
round(3.14159, 2)  # 3.14
round(2.5)      # 2 — banker's rounding! (rounds to even)
round(3.5)      # 4
pow(2, 10)      # 1024
pow(2, 10, 100) # 1024 % 100 = 24 (modular exponentiation)
divmod(17, 5)   # (3, 2) — quotient and remainder

# Iterables
len([1,2,3])    # 3
sum([1,2,3])    # 6
sum([1,2,3], start=10)  # 16
min([3,1,2])    # 1
max([3,1,2])    # 3
min("Ravi","Priya", key=len)  # "Ravi" (shorter)
sorted([3,1,2])           # [1,2,3]
sorted("Python")          # ['P','h','n','o','t','y']
reversed([1,2,3])         # iterator
enumerate(["a","b"], 1)   # (1,'a'),(2,'b')
zip([1,2],[3,4])          # (1,3),(2,4)
map(str, [1,2,3])         # iterator of strings
filter(None, [0,1,False,"",2])  # [1,2] — filter falsy
any([False,0,True])       # True
all([True,1,"yes"])       # True
all([True,0,"yes"])       # False

# Object inspection
type(42)           # <class 'int'>
isinstance(42,int) # True
id(42)             # memory address
hash("hello")      # integer hash
dir([])            # list of attributes/methods
vars(obj)          # obj.__dict__
hasattr(obj,"x")   # True if obj.x exists
getattr(obj,"x",42) # obj.x or default 42
setattr(obj,"x",5) # obj.x = 5
delattr(obj,"x")   # del obj.x
callable(func)     # True if callable
repr(obj)          # obj.__repr__()

# Input/Output
input("Enter: ")   # always returns string
print("a","b","c", sep="-", end="\n")
open("file.txt","r")
print(*[1,2,3])    # unpack: 1 2 3

# os — operating system interface
import os
os.getcwd()                    # current working directory
os.listdir(".")                # list files/dirs
os.makedirs("a/b/c", exist_ok=True)
os.remove("file.txt")
os.rename("old.txt","new.txt")
os.environ.get("API_KEY","default")
os.path.join("dir","file.txt")  # platform-safe path
os.path.exists("file.txt")
os.path.basename("/path/to/file.txt")  # "file.txt"

# sys — interpreter info
import sys
sys.argv           # command line args
sys.exit(0)        # exit program
sys.path           # module search paths
sys.version        # Python version string
sys.getsizeof(obj) # memory size in bytes
sys.setrecursionlimit(10000)

# datetime
from datetime import datetime, date, timedelta
now = datetime.now()
today = date.today()
fmt = now.strftime("%Y-%m-%d %H:%M:%S")
parsed = datetime.strptime("2024-01-15", "%Y-%m-%d")
tomorrow = today + timedelta(days=1)
diff = datetime(2024,12,31) - datetime.now()
print(diff.days)

# math
import math
math.sqrt(16)       # 4.0
math.floor(3.7)     # 3
math.ceil(3.2)      # 4
math.log(100, 10)   # 2.0
math.pi, math.e, math.inf, math.nan
math.isclose(a,b,rel_tol=1e-9)

# random
import random
random.random()             # float [0.0, 1.0)
random.randint(1, 10)       # int [1, 10] inclusive
random.choice(["a","b","c"])
random.choices(lst, k=3)    # sample WITH replacement
random.sample(lst, k=3)     # sample WITHOUT replacement
random.shuffle(lst)          # in-place shuffle
random.seed(42)              # reproducible results

# copy
import copy
copy.copy(obj)       # shallow copy
copy.deepcopy(obj)   # deep copy (recursive)

# hashlib — hashing
import hashlib
h = hashlib.sha256(b"hello").hexdigest()
hashlib.md5(b"data").digest()   # raw bytes

# timeit — benchmark small snippets
import timeit

t = timeit.timeit(
    setup="data=[1,2,3,4,5]*100",
    stmt="sum(data)",
    number=100_000
)
print(f"{t:.4f}s")

# Quick one-liner timing
%timeit sum(range(1000))   # Jupyter magic

# cProfile — full program profiling
import cProfile
cProfile.run("my_function()")

# Or as context manager
with cProfile.Profile() as pr:
    my_function()
pr.print_stats(sort="cumulative")

# line_profiler — line-by-line (pip install line_profiler)
# @profile decorator on function, then: kernprof -l script.py

# memory_profiler — memory usage per line
# @profile decorator, then: python -m memory_profiler script.py

# tracemalloc — built-in memory tracing
import tracemalloc
tracemalloc.start()

create_many_objects()

snapshot = tracemalloc.take_snapshot()
top = snapshot.statistics("lineno")
for stat in top[:5]:
    print(stat)

# ✅ FAST vs ❌ SLOW patterns

# String building
parts = ["a", "b", "c"] * 1000
fast = "".join(parts)          # ✅ O(n)
slow = ""
for p in parts: slow += p      # ❌ O(n²)

# Membership test
valid = {"a","b","c"}
"a" in valid                   # ✅ O(1) — set
"a" in ["a","b","c"]           # ❌ O(n) — list

# Dict access
d.get("key", default)          # ✅ one lookup
if "key" in d: d["key"]        # ❌ two lookups

# Local vs global variable lookup
import math
def fast_sqrt():
    local_sqrt = math.sqrt     # ✅ local lookup is faster
    for i in range(10000):
        local_sqrt(i)

# List comprehension vs loop
squares = [x**2 for x in range(1000)]  # ✅ ~2x faster

# numpy for numeric data (releases GIL!)
import numpy as np
arr = np.array([1.0]*1_000_000)
arr * 2                        # ✅ C-speed, releases GIL

# Generator for large sequences
total = sum(x**2 for x in range(10**7))  # ✅ O(1) memory
total = sum([x**2 for x in range(10**7)]) # ❌ O(n) memory

# Slots for many instances
class Point:
    __slots__ = ["x","y"]     # ✅ 40-60% less memory

# lru_cache for repeated computation
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n): return n if n<2 else fib(n-1)+fib(n-2)

# bytes vs str for binary data
with open("file.bin","rb") as f:  # ✅ read as bytes
    data = f.read()