# You can see the bytecode!
import dis

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

dis.dis(add)
# Output:
#   2           0 LOAD_FAST                0 (a)
#               2 LOAD_FAST                1 (b)
#               4 BINARY_ADD
#               6 RETURN_VALUE

myproject/
├── main.py
├── utils.py
└── __pycache__/
    └── utils.cpython-311.pyc  ← Compiled bytecode

# GIL impact: threading does NOT speed up CPU-bound work
import threading

def cpu_work():
    total = sum(range(10_000_000))  # CPU-bound -- GIL is held

# Two threads will NOT run in parallel for this task.
# Use multiprocessing instead for true CPU parallelism:
from multiprocessing import Pool

def cpu_work(n):
    return sum(range(n))

# Each process gets its own GIL -- true parallelism
with Pool(4) as p:
    results = p.map(cpu_work, [10_000_000] * 4)

x = 10          # x points to an int object with value 10
price = 19.99   # price points to a float object
name = "Alice"  # name points to a str object
is_active = True # is_active points to a bool object
nothing = None  # nothing points to the singleton None object

# The "name tag" analogy in action:
x = 10          # x is attached to int(10)
x = "hello"     # x is now attached to str("hello") -- the int(10) still exists
                # until garbage collected. The name moved, the objects did not.

age: int = 25
name: str = "Bob"

# This is valid Python code (no runtime error), but a linter will warn you.
age = "Twenty" 

# Immutable -- strings cannot be modified in place
s = "hello"
# s[0] = "H"  # TypeError! You cannot change a string. You must create a new one.
s = "H" + s[1:]  # Creates a NEW string "Hello". The old "hello" is garbage collected.

# Mutable -- lists can be modified in place
nums = [1, 2, 3]
nums[0] = 100  # OK. The list object is modified in place. No new list is created.

# Why this matters: function arguments
def add_to_list(items, value):
    items.append(value)  # Mutates the ORIGINAL list -- the caller's list changes!

def try_to_change_string(text):
    text = text.upper()  # Creates a new string. The caller's variable is unaffected.

my_list = [1, 2]
add_to_list(my_list, 3)
print(my_list)  # [1, 2, 3] -- the original was modified

my_str = "hello"
try_to_change_string(my_str)
print(my_str)   # "hello" -- unchanged, because strings are immutable

# Output
print("Hello", "World") # Prints "Hello World" (space separated by default)
print("Hello", "World", sep="-") # Prints "Hello-World"

# Input
# input() ALWAYS returns a string. You must convert it if you need a number.
name = input("Enter your name: ")
age_str = input("Enter your age: ")
age = int(age_str) # Convert to integer

name = "Alice"
age = 30
print(f"Hello, {name}. You are {age} years old.")

# You can embed expressions, not just variables
print(f"In 5 years, you'll be {age + 5}.")

# Format numbers with precision
pi = 3.14159265
print(f"Pi is approximately {pi:.2f}")  # "Pi is approximately 3.14"

# Debugging trick (Python 3.8+): Add = to see variable name AND value
x = 42
print(f"{x = }")  # "x = 42" -- extremely useful for quick debugging

score = 85

if score >= 90:
    print("A")
elif score >= 80:
    print("B")
else:
    print("C")

# Ternary expression (Python's one-line if-else)
status = "adult" if age >= 18 else "minor"

# Truthiness -- Python treats these as False (called "falsy"):
#   None, 0, 0.0, "", [], {}, set(), False
# Everything else is "truthy". Use this to write cleaner checks:

# Non-Pythonic
if len(my_list) > 0:
    process(my_list)

# Pythonic -- rely on truthiness
if my_list:
    process(my_list)

# Chained comparisons (unique to Python, reads like math)
if 0 < x < 100:      # Equivalent to: 0 < x and x < 100
    print("In range")

# range(5) generates: 0, 1, 2, 3, 4
for i in range(5):
    print(i)

# Iterate over a list directly -- no indexing needed
names = ["Alice", "Bob"]
for name in names:
    print(name)

# Need the index AND the value? Use enumerate() instead of range(len(...))
for i, name in enumerate(names):
    print(f"Index {i}: {name}")

# Iterating over two lists in parallel? Use zip()
scores = [85, 92]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

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

# Type hints are optional but recommended
def add(a: int, b: int) -> int:
    """
    Returns the sum of two numbers.
    This is a docstring - used for documentation.
    """
    return a + b

result = add(5, 3)

def greet(name="Guest"):
    print(f"Hello, {name}")

greet()         # Hello, Guest
greet("Alice")  # Hello, Alice

def log(message, *args, **kwargs):
    print(f"MSG: {message}")
    print(f"Extra Args: {args}")     # Tuple of extra positional args
    print(f"Config: {kwargs}")       # Dict of extra keyword args

log("Error", 1, 2, user="admin", code=500)
# Output:
# MSG: Error
# Extra Args: (1, 2)
# Config: {'user': 'admin', 'code': 500}

# Everything after * must be passed by name
def connect(host, port, *, timeout=30, retries=3):
    print(f"Connecting to {host}:{port}, timeout={timeout}")

connect("localhost", 5432, timeout=10)    # OK
# connect("localhost", 5432, 10)          # TypeError! timeout is keyword-only

# This pattern is extremely common in well-designed Python APIs.
# It makes call sites self-documenting and prevents positional mixups.

# Lambda: good for short, one-off operations
users = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]
users.sort(key=lambda u: u["age"])  # Sort by age

# Equivalent with def (use this if the logic is complex)
def get_age(user):
    return user["age"]
users.sort(key=get_age)

# Anti-pattern: assigning a lambda to a variable. Just use def instead.
# Bad:  square = lambda x: x ** 2
# Good: def square(x): return x ** 2