🐍 The Python Bible

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

print("Hello, World!")  # That's it. One line.

python --version

# This is your very first Python program!
# The pound sign (#) starts a comment — Python ignores everything after it
# Comments are notes for humans, not instructions for the computer

print("Hello, World!")   # print() displays text on the screen
print("My name is Python.")  # You can have multiple print() calls
print("I am a programming language.")

python hello.py

Hello, World!
My name is Python.
I am a programming language.

python

Python 3.11.5 (default, ...)
Type "help", "copyright", "credits" or "license" for more information.
>>> 

>>> 2 + 2
4
>>> print("Hello from the REPL!")
Hello from the REPL!
>>> 10 * 5
50

# Basic print — displays text (called a "string") to the screen
print("Hello, World!")

# Print a number — no quotes needed for numbers
print(42)

# Print multiple things at once — separate them with commas
# Python automatically adds a space between each item
print("My age is", 25, "years old")
# Output: My age is 25 years old

# Change the separator (the character between items)
# By default, sep=" " (a space), but we can change it
print("2024", "01", "15", sep="-")
# Output: 2024-01-15

# Change the end character (what's printed at the very end)
# By default, end="\n" which means "new line"
# Using end="" means: don't go to a new line after printing
print("Hello", end=" ")  # stays on same line
print("World")           # continues on same line
# Output: Hello World

# Print a blank line (useful for spacing output)
print()
# Output: (empty line)

# Print the result of a calculation directly
print(10 + 5)   # Output: 15
print(3 * 4)   # Output: 12

# This is a single-line comment
# Everything after # on this line is ignored by Python

print("Hello")  # Comments can also go at the END of a line of code

# Python doesn't have a special "multi-line comment" syntax
# Instead, just use multiple # lines
# Like this.
# And this.

# HOWEVER — triple-quoted strings are sometimes used as multi-line "comments"
# (they're technically strings, but if you don't store or use them, they do nothing)
"""
This is a triple-quoted string.
It spans multiple lines.
When used at the top of a function or file, it becomes a "docstring"
which documents what the code does. More on this in Part VII.
"""

# Good comment: explains WHY, not just what
# BAD comment example (don't do this — it's obvious):
x = 5  # set x to 5   <-- useless, the code already says this

# GOOD comment example:
max_retries = 3  # API calls sometimes fail; retry up to 3 times before giving up

# This is a simple "if statement" (covered in depth in Part V)
# The key lesson here is: the INDENTED code belongs to the if

temperature = 35  # this line is NOT indented — it's at the top level

if temperature > 30:     # the colon (:) means "a block is starting"
    print("It's hot!")   # 4 spaces indent — this belongs to the if block
    print("Stay hydrated") # also 4 spaces — also belongs to the if block

print("This runs no matter what")  # back to 0 indent — NOT inside the if

# Here's what WRONG indentation looks like (this would cause an error):
# if temperature > 30:
# print("It's hot!")   <-- ERROR! This should be indented

# The standard in Python is 4 spaces per level of indentation
# Most editors (including VS Code) automatically do this when you press Tab

# Nested indentation (code inside code inside code):
if temperature > 30:            # level 0 (no indent)
    print("Hot day")             # level 1 (4 spaces)
    if temperature > 40:        # level 1 (4 spaces)
        print("Dangerously hot")  # level 2 (8 spaces)

# Creating (declaring) a variable
# Format: variable_name = value
age = 25               # 'age' is the label, 25 is the value inside
name = "Alice"          # 'name' holds the text "Alice"
height = 5.9            # 'height' holds the decimal number 5.9
is_student = True       # 'is_student' holds the value True

# Using (reading) a variable
print(age)              # prints: 25
print(name)             # prints: Alice
print("My name is", name, "and I am", age, "years old.")
# prints: My name is Alice and I am 25 years old.

# Changing (reassigning) a variable — the box gets new contents
age = 26               # 25 is gone, 26 is now inside the box
print(age)              # prints: 26

# You can even change what TYPE of data is in the variable
# (Python allows this — more on "dynamic typing" shortly)
age = "twenty-six"     # now 'age' holds text instead of a number
print(age)              # prints: twenty-six

# Variables can be used in calculations
price = 100
discount = 20
final_price = price - discount  # store the result of a calculation
print(final_price)              # prints: 80

# Integers are whole numbers — no decimal point
age = 25            # positive integer
temperature = -10  # negative integer
count = 0           # zero is also an integer

# Python integers can be ARBITRARILY LARGE — no overflow!
# (Unlike some other languages, Python handles huge numbers natively)
big_number = 999999999999999999999999999999
print(big_number)   # Python handles this fine

# Underscores in numbers — makes large numbers readable (Python 3.6+)
population = 8_000_000_000   # same as 8000000000 but much easier to read
one_million = 1_000_000       # Python ignores underscores in numbers

# Basic arithmetic with integers
a = 10
b = 3

print(a + b)   # Addition:         13
print(a - b)   # Subtraction:       7
print(a * b)   # Multiplication:   30
print(a / b)   # Division:         3.3333... (always returns a float!)
print(a // b)  # Floor division:   3 (divides and throws away the remainder)
print(a % b)   # Modulo:           1 (the REMAINDER after dividing)
print(a ** b)  # Exponent:      1000 (10 to the power of 3)

# Check the type of a variable using type()
print(type(age))   # Output: <class 'int'>

# Floats have a decimal point
price = 9.99
pi = 3.14159
temperature = -23.5

# Scientific notation works too
speed_of_light = 3e8    # 3 × 10^8 = 300,000,000.0
tiny = 1.5e-4           # 1.5 × 10^-4 = 0.00015

print(type(price))      # Output: <class 'float'>

# IMPORTANT: Floats are not perfectly precise!
# This is a fundamental limitation of how computers store decimal numbers
print(0.1 + 0.2)        # Output: 0.30000000000000004 (not 0.3!)

# For money and financial calculations, use the 'decimal' module instead
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3 (precise!)

# Dividing two integers ALWAYS gives a float in Python 3
result = 10 / 2
print(result)           # Output: 5.0  (not 5)
print(type(result))    # Output: <class 'float'>

# Rounding floats
print(round(3.14159, 2))  # Round to 2 decimal places: 3.14
print(round(3.7))          # Round to nearest whole number: 4

# Strings can use single quotes OR double quotes — both are fine
name1 = 'Alice'          # single quotes
name2 = "Bob"            # double quotes
# Both work identically. Pick one style and stay consistent.

# Use the OTHER type of quote when your string contains quotes
message = "I'm learning Python!"     # string has ' inside, so we use ""
quote = 'She said "hello" to me.'   # string has "" inside, so we use ''

# Strings can contain anything — letters, numbers, symbols
email = "[email protected]"
address = "123 Main St, Anytown, USA"
empty = ""              # an empty string is a valid string (no characters)

# String length — how many characters are in it?
word = "Python"
print(len(word))        # Output: 6 (P-y-t-h-o-n = 6 characters)

# String concatenation — joining strings together with +
first = "Hello"
second = "World"
combined = first + " " + second  # adds a space in the middle
print(combined)                   # Output: Hello World

# Repeating strings with *
print("ha" * 3)          # Output: hahaha
print("-" * 30)          # prints a line of 30 dashes

# The number 5 and the string "5" are DIFFERENT things
num = 5           # integer
text = "5"        # string
print(num + num)  # Output: 10 (math addition)
print(text + text) # Output: 55 (string joining, not addition!)

# Booleans — note the capital T and F!
is_raining = True         # True — capital T, no quotes
is_sunny = False           # False — capital F, no quotes

# Booleans come from comparisons (more in Part IV)
age = 20
can_vote = age >= 18       # Is 20 >= 18? Yes! So can_vote = True
print(can_vote)             # Output: True

is_teenager = age < 20    # Is 20 < 20? No! So is_teenager = False
print(is_teenager)         # Output: False

# Boolean values in Python ARE actually integers underneath:
# True == 1, False == 0  (this is useful for counting True values)
print(True + True)          # Output: 2
print(True + False)         # Output: 1
print(type(True))           # Output: <class 'bool'>

# None represents "no value" — note the capital N!
result = None
print(result)           # Output: None
print(type(result))    # Output: <class 'NoneType'>

# None is often used as a placeholder until you have real data
user_input = None       # We haven't asked the user yet
# ... later in the program ...
user_input = "Alice"    # Now we have real data

# Functions that don't explicitly return a value return None
def say_hi():
    print("Hi!")     # this function prints but doesn't RETURN anything

output = say_hi()       # Output: Hi!
print(output)           # Output: None  (because say_hi() returned nothing)

# Check if something is None using 'is' (not ==)
if result is None:
    print("No value yet")   # This will print

if result is not None:
    print("We have a value!")  # This won't print

# type() tells you what kind of data something is
print(type(42))        # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type("hello")) # <class 'str'>
print(type(True))    # <class 'bool'>
print(type(None))    # <class 'NoneType'>

# ── TYPE CONVERSION (CASTING) ──────────────────────────────────
# Convert to integer with int()
num_text = "42"              # this is a string
num_int = int(num_text)      # now it's an integer
print(num_int + 8)           # Output: 50 (math works now!)

# Convert float to int — drops the decimal part (does NOT round!)
print(int(9.9))             # Output: 9  (not 10!)
print(int(3.14))            # Output: 3

# Convert to float with float()
print(float(5))             # Output: 5.0
print(float("3.14"))       # Output: 3.14

# Convert to string with str()
age = 25
message = "I am " + str(age) + " years old"  # must convert int to str to join
print(message)               # Output: I am 25 years old

# Convert to boolean with bool()
# Almost everything converts to True — except these falsy values:
print(bool(0))              # False  (zero)
print(bool(""))             # False  (empty string)
print(bool(None))           # False  (None)
print(bool(42))             # True   (any non-zero number)
print(bool("hello"))       # True   (any non-empty string)

# WATCH OUT: Some conversions will fail!
# int("hello")  <-- ERROR: "hello" can't become a number
# int("3.14")   <-- ERROR: strings with decimals must go through float first
print(int(float("3.14")))  # Works: "3.14" → 3.14 → 3

# ✅ VALID variable names
age = 25
first_name = "Alice"    # snake_case: words separated by underscores
_private = "secret"     # underscore prefix: convention for "private" variable
name2 = "Bob"           # numbers OK if not at the start
CONSTANT_VALUE = 3.14   # ALL_CAPS convention for values that never change

# ❌ INVALID variable names (these cause SyntaxError)
# 2name = "Bob"     <-- starts with a number
# first-name = ""   <-- hyphens not allowed
# my name = ""      <-- spaces not allowed
# for = 5           <-- 'for' is a Python keyword

# ── PYTHON NAMING CONVENTIONS (community standards) ───────────

# Variables and functions: snake_case (all lowercase, underscores)
user_name = "Alice"
total_price = 99.99
def calculate_tax(): pass   # function names: same as variables

# Constants: ALL_CAPS_WITH_UNDERSCORES (Python can't truly enforce constants,
# this is just a convention telling others "don't change this!")
MAX_CONNECTIONS = 100
PI = 3.14159
API_KEY = "abc123"

# Classes: PascalCase (capitalize first letter of each word, no underscores)
# class UserAccount:  <-- correct class naming (Part XII)
# class user_account: <-- wrong convention for classes

# Be descriptive! Good names make code self-documenting.
# BAD:  x = 86400
# GOOD:
seconds_per_day = 86400    # anyone can understand what this is

# Python vs statically-typed languages (like Java or C++)
# In Java, you must declare the type:
#   int age = 25;        <-- type declared explicitly
#   age = "twenty-five"  <-- ERROR in Java — can't change type!

# In Python, no type declaration needed:
age = 25                 # Python sees an integer
print(type(age))        # <class 'int'>

age = "twenty-five"     # Python now sees a string — no error!
print(type(age))        # <class 'str'>

age = 25.5               # Now a float
print(type(age))        # <class 'float'>

# THE DANGER: dynamic typing can hide bugs
# Example: user input always comes back as a string
user_age = "25"          # Pretend user typed "25" — it's a STRING
# user_age + 5            <-- TypeError! Can't add string + int

# You must convert it:
user_age = int("25")    # Now it's a real integer
print(user_age + 5)     # Output: 30 ✅

# SOLUTION for larger codebases: Type Hints (covered in Part XV)
# You can optionally annotate what type a variable SHOULD be:
def greet(name: str, age: int) -> str:  # these are hints, not enforced
    return f"Hello {name}, you are {age} years old"

# String indexing — accessing individual characters
word = "Python"
#       P  y  t  h  o  n
#       0  1  2  3  4  5    (positive indices, counting from left)
#      -6 -5 -4 -3 -2 -1   (negative indices, counting from right)

# Access a character using square brackets []
print(word[0])    # Output: P  (first character)
print(word[1])    # Output: y
print(word[5])    # Output: n  (last character, index = length - 1)

# Negative indexing — count from the END
print(word[-1])   # Output: n  (last character)
print(word[-2])   # Output: o  (second to last)
print(word[-6])   # Output: P  (same as word[0])

# IndexError: going out of bounds
# print(word[10])  <-- ERROR! "Python" only has indices 0-5

# ── SLICING — extracting a portion of a string ─────────────────
# Format: string[start:stop]
# Returns characters from 'start' UP TO BUT NOT INCLUDING 'stop'

sentence = "Hello, World!"

print(sentence[0:5])    # Output: Hello  (indices 0,1,2,3,4)
print(sentence[7:12])   # Output: World  (indices 7,8,9,10,11)

# Omitting start: defaults to 0
print(sentence[:5])     # Output: Hello  (same as [0:5])

# Omitting end: goes to the end of the string
print(sentence[7:])     # Output: World!

# Omitting both: copy the entire string
print(sentence[:])      # Output: Hello, World!

# ── STEP — the third slice argument ───────────────────────────
# Format: string[start:stop:step]
# step: how many characters to skip

text = "abcdefgh"
print(text[::2])       # Every 2nd character: abcdefgh → aceg
print(text[1:7:2])    # Start at 1, stop at 7, every 2nd: bdf

# The famous trick: reverse a string with [::-1]
# step of -1 means "go backwards"
print("Python"[::-1])  # Output: nohtyP
print("racecar"[::-1]) # Output: racecar (a palindrome!)

# Concatenation: joining strings together

# Method 1: The + operator
first = "Hello"
second = "World"
result = first + " " + second    # joins the strings
print(result)                    # Output: Hello World

# Remember: can only concatenate strings with strings
name = "Alice"
age = 25
# message = "My name is " + name + " and I'm " + age  <-- TypeError!
message = "My name is " + name + " and I'm " + str(age)  # convert first
print(message)

# Method 2: The % formatting (old style — you'll see this in older code)
message = "My name is %s and I'm %d years old" % (name, age)
# %s = string placeholder, %d = integer placeholder
print(message)

# Method 3: .format() (medium-age style)
message = "My name is {} and I'm {} years old".format(name, age)
print(message)

# Method 4: f-strings (modern, recommended — we'll cover next!)
message = f"My name is {name} and I'm {age} years old"
print(message)

# f-strings: put an 'f' before the opening quote
# Then use {curly braces} to embed variables or expressions

name = "Alice"
age = 25
score = 95.678

# Basic f-string
print(f"Hello, {name}!")          # Output: Hello, Alice!
print(f"{name} is {age} years old.") # Output: Alice is 25 years old.

# You can put EXPRESSIONS (calculations) inside the braces
print(f"Next year she'll be {age + 1}.")  # evaluates age + 1 = 26
print(f"Uppercase name: {name.upper()}")   # can call methods too!
print(f"2 to the power of 10 is {2**10}") # Output: 1024

# Format specifiers — control HOW values are displayed
# Format: {value:format_spec}

# Number formatting
print(f"Score: {score:.2f}")            # .2f = 2 decimal places: 95.68
print(f"Score: {score:.0f}")            # .0f = no decimals: 96
print(f"Big: {1234567:,}")             # comma separator: 1,234,567
print(f"Percent: {0.75:.1%}")           # percentage: 75.0%

# Width and alignment
print(f"{name:10}|")                   # left-align, 10 chars wide: "Alice     |"
print(f"{name:>10}|")                  # right-align: "     Alice|"
print(f"{name:^10}|")                  # center: "  Alice   |"

# Python 3.8+ bonus: the = specifier (debugging helper)
x = 42
print(f"{x=}")                         # Output: x=42  (shows name AND value!)

# Multiline f-strings
info = (
    f"Name: {name}\n"
    f"Age:  {age}\n"
    f"Score: {score:.1f}"
)
print(info)

# All string methods return a NEW string — they don't change the original
text = "  Hello, World!  "

# ── CASE METHODS ──────────────────────────────────────────────
print(text.upper())          # "  HELLO, WORLD!  " — all uppercase
print(text.lower())          # "  hello, world!  " — all lowercase
print(text.title())          # "  Hello, World!  " — first letter of each word capitalized
print(text.capitalize())     # first char of entire string capitalized
print(text.swapcase())       # UPPER→lower, lower→UPPER

# ── WHITESPACE METHODS ────────────────────────────────────────
print(text.strip())          # "Hello, World!" — removes leading/trailing spaces
print(text.lstrip())         # removes only LEFT (leading) whitespace
print(text.rstrip())         # removes only RIGHT (trailing) whitespace

# ── SEARCH METHODS ────────────────────────────────────────────
sentence = "Python is great. Python is fun."

print(sentence.find("Python"))    # 0 — index of FIRST occurrence
print(sentence.rfind("Python"))   # 17 — index of LAST occurrence
print(sentence.find("Java"))     # -1 — not found returns -1
print(sentence.count("Python"))  # 2 — how many times "Python" appears

# in keyword: check if substring exists (returns True/False)
print("Python" in sentence)     # True
print("Java" in sentence)       # False

# startswith and endswith
print(sentence.startswith("Python"))  # True
print(sentence.endswith("fun."))     # True

# ── REPLACE METHOD ────────────────────────────────────────────
new = sentence.replace("Python", "Java")  # replace ALL occurrences
print(new)  # Java is great. Java is fun.

new2 = sentence.replace("Python", "Ruby", 1)  # replace only FIRST occurrence
print(new2)  # Ruby is great. Python is fun.

# ── SPLIT AND JOIN ────────────────────────────────────────────
csv_line = "Alice,25,Engineer,New York"

# split(): break a string into a LIST of substrings
parts = csv_line.split(",")  # split at every comma
print(parts)  # ['Alice', '25', 'Engineer', 'New York']

# split() with no argument splits on ANY whitespace
words = "Hello   World  Python".split()
print(words)  # ['Hello', 'World', 'Python']

# join(): the REVERSE of split — combine a list into a string
fruits = ["apple", "banana", "cherry"]
print(", ".join(fruits))    # "apple, banana, cherry"
print(" | ".join(fruits))   # "apple | banana | cherry"
print("".join(fruits))     # "applebananacherry"

# ── CHECK METHODS ─────────────────────────────────────────────
print("hello".isalpha())    # True — only letters?
print("123".isdigit())     # True — only digits?
print("abc123".isalnum())  # True — only letters and digits?
print("   ".isspace())     # True — only whitespace?
print("HELLO".isupper())   # True — all uppercase?
print("hello".islower())   # True — all lowercase?

# ── PADDING ───────────────────────────────────────────────────
print("5".zfill(3))          # "005" — pad with zeros on left
print("hello".center(11))   # "   hello   " — center in given width
print("hello".ljust(10, "-")) # "hello-----" — pad right with dashes

# ── MULTI-LINE STRINGS ────────────────────────────────────────
# Triple quotes let you write strings that span multiple lines
# Can use ''' or """

poem = """Roses are red,
Violets are blue,
Python is awesome,
And so are you."""

print(poem)
# Output:
# Roses are red,
# Violets are blue,
# Python is awesome,
# And so are you.

# Triple-quoted strings preserve ALL whitespace including newlines
sql_query = """
    SELECT name, age, email
    FROM users
    WHERE age > 18
    ORDER BY name
"""  # great for embedding SQL, HTML, JSON templates in your code

# ── RAW STRINGS ───────────────────────────────────────────────
# A raw string treats backslashes (\) as literal characters
# Prefix the string with r or R

# The problem: backslash has special meaning in normal strings
normal = "C:\new_folder\test.txt"   # \n is "newline", \t is "tab"!
print(normal)
# Output:
# C:
# ew_folder	est.txt   <-- NOT what we wanted!

# The solution: raw strings (prefix with r)
raw_path = r"C:\new_folder\test.txt"  # backslashes are literal
print(raw_path)
# Output: C:\new_folder\test.txt  <-- correct!

# Raw strings are ESSENTIAL when working with:
# 1. Windows file paths
# 2. Regular expressions (regex patterns — very common!)
import re
pattern = r"\d{3}-\d{4}"  # without r, \d would be interpreted as escape
# With the r prefix, \d means "a digit" in regex (the correct interpretation)

# Escape characters in action
print("Line 1\nLine 2\nLine 3")
# Output:
# Line 1
# Line 2
# Line 3

print("Name:\tAlice")         # Output: Name:    Alice
print("Say \"hello\"")        # Output: Say "hello"
print('It\'s raining')        # Output: It's raining
print("C:\\Users\\Alice")     # Output: C:\Users\Alice

# Unicode characters — use \u followed by 4 hex digits
print("\u2764")               # Output: ❤ (heart symbol)
print("\U0001F600")           # Output: 😀 (emoji!)

# Practical uses of the less-obvious operators

# Floor division (//) — get whole number result, throw away remainder
minutes = 137
hours = minutes // 60      # How many full hours? 2
remaining = minutes % 60   # How many leftover minutes? 17
print(f"{minutes} minutes = {hours}h {remaining}m")  # 137 minutes = 2h 17m

# Modulo (%) — incredibly useful!
# Check if number is even (even numbers have no remainder when divided by 2)
for n in [1, 2, 3, 4, 5]:
    if n % 2 == 0:
        print(f"{n} is even")
    else:
        print(f"{n} is odd")

# Exponent (**) — powers and roots
print(2**8)    # 256 (2 to the 8th power)
print(9**0.5)  # 3.0  (square root of 9 = 9^0.5)
print(8**(1/3)) # 2.0  (cube root of 8)

# Built-in math functions (no import needed)
print(abs(-42))          # 42  — absolute value
print(max(3, 7, 1))      # 7   — largest value
print(min(3, 7, 1))      # 1   — smallest value
print(round(3.7))        # 4   — round to nearest integer
print(sum([1, 2, 3]))  # 6   — sum a list of numbers
print(pow(2, 10))        # 1024 — same as 2**10

a = 10
b = 5

print(a == b)   # Equal to:              False  (10 is not equal to 5)
print(a != b)   # Not equal to:          True   (they are different)
print(a > b)    # Greater than:          True   (10 > 5)
print(a < b)    # Less than:             False  (10 is not less than 5)
print(a >= b)   # Greater than or equal: True   (10 >= 5)
print(a <= b)   # Less than or equal:    False  (10 is not <= 5)

# Python allows CHAINED comparisons — very readable!
age = 25
print(18 <= age <= 65)    # True — is age between 18 and 65?
# This is equivalent to: (18 <= age) and (age <= 65)

# == vs is — a crucial distinction!
# == checks if VALUES are equal
# is  checks if they're the SAME OBJECT in memory
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2)    # True  — same values
print(list1 is list2)    # False — different objects in memory

# Use 'is' ONLY for None, True, False comparisons:
value = None
print(value is None)      # ✅ Correct way to check for None
print(value == None)     # Works, but is considered bad style

# Strings comparison — alphabetical/lexicographic
print("apple" < "banana")  # True — 'a' comes before 'b'
print("Z" < "a")           # True — uppercase letters come before lowercase in ASCII

age = 25
has_ticket = True
is_vip = False

# ── AND: both conditions must be True ─────────────────────────
print(age >= 18 and has_ticket)   # True AND True = True
print(age >= 18 and is_vip)       # True AND False = False
# AND truth table: T+T=T, T+F=F, F+T=F, F+F=F

# ── OR: at least one condition must be True ────────────────────
print(has_ticket or is_vip)       # True OR False = True
print(False or False)             # False OR False = False
# OR truth table: T+T=T, T+F=T, F+T=T, F+F=F

# ── NOT: reverses a boolean ────────────────────────────────────
print(not is_vip)                 # not False = True
print(not has_ticket)             # not True = False

# Practical example — entrance to an event
if (age >= 18 and has_ticket) or is_vip:
    print("Welcome in!")
else:
    print("Sorry, you can't enter.")

# 'not in' and 'not is' — clean negative checks
fruits = ["apple", "banana"]
print("mango" not in fruits)    # True — mango is NOT in the list
value = None
print(value is not None)        # False — it IS None

# Basic assignment
x = 10              # assign 10 to x

# ── AUGMENTED ASSIGNMENT — shorthand for x = x OPERATOR value ─
# Instead of writing x = x + 5, write x += 5

x += 5              # same as: x = x + 5    → x is now 15
x -= 3              # same as: x = x - 3    → x is now 12
x *= 2              # same as: x = x * 2    → x is now 24
x /= 4              # same as: x = x / 4    → x is now 6.0
x //= 2             # same as: x = x // 2   → x is now 3.0
x **= 3             # same as: x = x ** 3   → x is now 27.0
x %= 5              # same as: x = x % 5    → x is now 2.0

print(x)  # 2.0

# String and list augmented assignment works too
name = "Hello"
name += " World"    # name = name + " World" → "Hello World"

items = [1, 2]
items += [3, 4]    # items = items + [3, 4] → [1, 2, 3, 4]

# Walrus operator := (Python 3.8+) — assign AND use in one step
# Useful in while loops and comprehensions
# Version badge: requires Python 3.8+
import random
while (n := random.randint(1, 10)) != 5:  # assign n, then check if != 5
    print(f"Got {n}, trying again...")
print(f"Finally got {n}!")

# Python follows standard math order of operations
print(2 + 3 * 4)          # 14, not 20! (* before +)
print((2 + 3) * 4)        # 20 — parentheses override
print(2 ** 3 ** 2)         # 512 — ** is RIGHT associative: 2^(3^2) = 2^9
print(10 - 3 - 2)         # 5  — left to right: (10-3)-2

# ADVICE: When in doubt, use parentheses!
# This is clearer than relying on everyone knowing precedence rules:
result = (price * quantity) + (shipping_fee * (1 - discount_rate))

# Short-circuit with AND — prevents errors!
name = None
# Without short-circuit, this would crash:
# print(len(name) > 0)  ← TypeError: object of type 'NoneType' has no len()

# With short-circuit, the right side is never evaluated if left is False:
if name is not None and len(name) > 0:
    print(f"Name: {name}")
else:
    print("No name provided")
# Because name IS None, Python stops at 'name is not None' (False)
# It never tries to call len(None) — so no crash!

# Short-circuit with OR — provide default values
user_name = ""                          # empty string — falsy
display_name = user_name or "Anonymous"  # if user_name is falsy, use "Anonymous"
print(display_name)  # Output: Anonymous

user_name = "Alice"                     # truthy
display_name = user_name or "Anonymous"  # user_name is truthy, stop there
print(display_name)  # Output: Alice

# This "or default" pattern is very common in Python!
# It's a clean way to set fallback values
config_value = None
timeout = config_value or 30  # if no config, default to 30 seconds

# ── BASIC IF STATEMENT ─────────────────────────────────────────
temperature = 35

if temperature > 30:              # condition — must be True or False
    print("It's hot outside!")    # only runs if condition is True
    print("Drink water.")          # still part of this if block (indented)
# back to indent level 0 — this always runs:
print("Done checking temperature.")

# ── IF / ELSE ─────────────────────────────────────────────────
age = 16

if age >= 18:
    print("You can vote!")   # runs if age >= 18
else:
    print("Too young to vote.")  # runs if age < 18
# Exactly ONE of these will always run

# ── IF / ELIF / ELSE ──────────────────────────────────────────
# elif = "else if" — check another condition if the previous was False
score = 82

if score >= 90:
    grade = "A"               # only if score is 90 or higher
elif score >= 80:
    grade = "B"               # only if score is 80-89
elif score >= 70:
    grade = "C"               # only if score is 70-79
elif score >= 60:
    grade = "D"               # only if score is 60-69
else:
    grade = "F"               # if none of the above matched (score < 60)

print(f"Your grade: {grade}")  # Output: Your grade: B

# ── TERNARY / CONDITIONAL EXPRESSION ─────────────────────────
# A one-line way to write a simple if/else
# Format: value_if_true if condition else value_if_false
status = "adult" if age >= 18 else "minor"
print(status)  # Output: minor (because age is 16)

# This is equivalent to:
if age >= 18:
    status = "adult"
else:
    status = "minor"

# Only use the ternary for simple cases — readability matters!

# FALSY values — these all behave like False in conditions:
# False, None, 0, 0.0, "", '', [], {}, set(), ()

# TRUTHY values — everything else:
# True, any non-zero number, any non-empty string/list/dict/set

# Practical examples:
name = ""                    # empty string — falsy
if name:                     # if name is truthy (non-empty)...
    print(f"Hello, {name}!")
else:
    print("No name entered.")  # This runs — empty string is falsy

items = []                    # empty list — falsy
if items:                    # if list is non-empty...
    print(f"You have {len(items)} items")
else:
    print("Cart is empty.")   # This runs

# This is MUCH cleaner than: if len(items) > 0:
# Both work, but 'if items:' is more Pythonic

count = 0                     # zero — falsy
if count:
    print("Count is non-zero")
else:
    print("Count is zero.")    # This runs

# Falsy check: None
result = None
if result is None:              # explicit None check — preferred
    print("No result yet.")
# Alternatively: if not result: — but this would also catch 0, "", etc.
# Be explicit about None unless you want to catch all falsy values

# Nested if — an if statement inside another if statement
age = 20
has_id = True

if age >= 18:                    # outer if
    print("You're old enough.")
    if has_id:                    # inner if (only reached if outer is True)
        print("ID verified. Welcome!")
    else:                         # inner else
        print("Need to see your ID.")
else:
    print("Sorry, you must be 18+.")

# Often, nested ifs can be flattened with 'and' — more readable!
# BAD (too nested):
if age >= 18:
    if has_id:
        print("Welcome!")

# GOOD (flat with 'and'):
if age >= 18 and has_id:
    print("Welcome!")

# "Guard clauses" — return early to avoid deep nesting
def process_order(order):
    # Instead of deeply nested ifs, check failure conditions first and return
    if order is None:
        return "No order provided"  # early return!
    if not order.get("items"):
        return "Order has no items"  # early return!
    if order.get("total", 0) <= 0:
        return "Invalid total"       # early return!
    # If we reach here, the order is valid — process it
    return "Order processed successfully"

# Basic value matching — like a cleaner if/elif chain
command = "quit"

match command:
    case "quit":
        print("Exiting...")
    case "help":
        print("Showing help...")
    case "start":
        print("Starting...")
    case _:              # _ is the "wildcard" — matches anything else
        print(f"Unknown command: {command}")

# Multiple values in one case using |
day = "Saturday"
match day:
    case "Saturday" | "Sunday":
        print("Weekend!")
    case _:
        print("Weekday")

# Matching with guards (conditions)
point = (3, 7)
match point:
    case (0, 0):
        print("Origin")
    case (x, 0):
        print(f"On x-axis at {x}")     # x is captured from the match
    case (0, y):
        print(f"On y-axis at {y}")
    case (x, y) if x == y:              # guard condition
        print(f"On diagonal at {x}")
    case (x, y):
        print(f"At coordinates ({x}, {y})")   # this one matches (3, 7)

# ❌ MISTAKE 1: Using = instead of ==
x = 5
# if x = 10:    ← SyntaxError! = is assignment, == is comparison
if x == 10:    # ✅ correct
    print("ten")

# ❌ MISTAKE 2: Forgetting the colon after the condition
# if x > 3      ← SyntaxError! Missing colon
if x > 3:      # ✅ colon required
    print("big")

# ❌ MISTAKE 3: Wrong indentation
# if x > 3:
# print("big")  ← IndentationError! Must be indented
if x > 3:
    print("big")  # ✅ indented 4 spaces

# ❌ MISTAKE 4: Comparing with 'is' instead of ==
num = 1000
# if num is 1000:  ← Works sometimes but WRONG conceptually
# 'is' tests identity (same object), not equality (same value)
if num == 1000:  # ✅ correct for comparing values
    print("one thousand")

# ❌ MISTAKE 5: Thinking elif is checked even when if was True
# Python takes the FIRST matching branch and skips all others
score = 95
if score >= 60:
    print("Passing")   # This runs
elif score >= 90:
    print("Excellent") # This NEVER runs! The if above already matched!
# Put more specific conditions FIRST

# Basic for loop — iterate over a list
# Format: for variable in iterable:
# 'variable' takes on each value from the iterable, one at a time

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

for fruit in fruits:           # fruit = "apple", then "banana", then "cherry"
    print(f"I like {fruit}")   # runs once for each item
# Output:
# I like apple
# I like banana
# I like cherry

# You can loop over ANYTHING iterable — strings too!
for letter in "Python":
    print(letter, end=" ")    # prints each letter separated by space
# Output: P y t h o n
print()  # new line after the loop

# Loop over a dictionary
person = {"name": "Alice", "age": 25, "city": "NYC"}

for key in person:                 # iterates over KEYS by default
    print(f"{key}: {person[key]}")

for key, value in person.items():  # .items() gives (key, value) pairs
    print(f"{key} = {value}")

# Accumulating a result — running total
numbers = [1, 2, 3, 4, 5]
total = 0                          # start with 0

for num in numbers:
    total += num                   # add each number to total
    print(f"Added {num}, total is now {total}")

print(f"Final total: {total}")     # Output: 15

# Basic while loop
count = 0

while count < 5:               # keep looping while count is less than 5
    print(f"Count is: {count}")
    count += 1                  # CRITICAL: must update the condition variable!
                                # Without this, loop runs forever!
# Output: Count is: 0, 1, 2, 3, 4

# While loops are great for user input validation
while True:                     # infinite loop — but we'll break out of it
    user_input = input("Enter a number between 1-10: ")
    if user_input.isdigit():       # check it's actually a number
        number = int(user_input)
        if 1 <= number <= 10:      # check it's in range
            break                   # exit the loop — we have valid input!
    print("Invalid! Try again.")   # only prints if we didn't break
print(f"You chose: {number}")

# Countdown example
countdown = 10
while countdown > 0:
    print(countdown, end=" ")
    countdown -= 1
print("Blastoff! 🚀")

# range() generates a sequence of integers
# range(stop)           — 0 up to (not including) stop
# range(start, stop)    — start up to (not including) stop
# range(start, stop, step) — start to stop, counting by step

# Count from 0 to 4
for i in range(5):        # range(5) generates: 0, 1, 2, 3, 4
    print(i, end=" ")     # Output: 0 1 2 3 4
print()

# Count from 1 to 10
for i in range(1, 11):   # range(1, 11) generates: 1, 2, ..., 10
    print(i, end=" ")
print()

# Count by 2 (even numbers)
for i in range(0, 20, 2):  # step of 2: 0, 2, 4, 6, ..., 18
    print(i, end=" ")
print()

# Count backwards
for i in range(10, 0, -1): # step of -1: 10, 9, 8, ..., 1
    print(i, end=" ")
print()

# Using range to access list items by index
colors = ["red", "green", "blue"]
for i in range(len(colors)):     # range(3) = 0, 1, 2
    print(f"Color {i}: {colors[i]}")

# Run something N times
for _ in range(3):            # _ means "I don't care about the variable value"
    print("This repeats 3 times")

# range() is LAZY — it doesn't create the full list in memory
# range(1_000_000) uses almost no memory — it generates numbers one at a time
big = range(1_000_000)     # instant! no big list created
print(list(range(5)))       # convert to list if you need to see it: [0, 1, 2, 3, 4]

# ── ENUMERATE — loop with index AND value ─────────────────────
# Problem: you want to know BOTH the position and value of each item
fruits = ["apple", "banana", "cherry"]

# The old, clunky way:
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")

# The Pythonic way with enumerate():
for index, fruit in enumerate(fruits):  # gives (index, value) pairs
    print(f"{index}: {fruit}")
# Output:
# 0: apple
# 1: banana
# 2: cherry

# Start counting from 1 instead of 0
for num, fruit in enumerate(fruits, start=1):
    print(f"{num}. {fruit}")
# Output: 1. apple, 2. banana, 3. cherry

# ── ZIP — loop over multiple iterables simultaneously ──────────
# Pairs up elements from multiple iterables
names = ["Alice", "Bob", "Charlie"]
scores = [95, 87, 92]
grades = ["A", "B", "A"]

for name, score, grade in zip(names, scores, grades):
    print(f"{name}: {score} ({grade})")
# Output:
# Alice: 95 (A)
# Bob: 87 (B)
# Charlie: 92 (A)

# zip() stops at the SHORTEST iterable
a = [1, 2, 3]
b = ["x", "y"]      # shorter!
print(list(zip(a, b)))  # [(1, 'x'), (2, 'y')] — 3 is dropped!

# Create a dictionary from two parallel lists
keys = ["name", "age", "city"]
values = ["Alice", 25, "NYC"]
person = dict(zip(keys, values))
print(person)  # {'name': 'Alice', 'age': 25, 'city': 'NYC'}

# ── BREAK — exit the loop immediately ─────────────────────────
for i in range(10):
    if i == 5:
        break           # stop the loop when i is 5
    print(i, end=" ")  # prints: 0 1 2 3 4
print("Loop ended")     # this runs after break

# Practical: find first match and stop
names = ["Alice", "Bob", "Charlie", "Dave"]
search = "Charlie"
for name in names:
    if name == search:
        print(f"Found {search}!")
        break           # no need to keep looking once found

# ── CONTINUE — skip this iteration, go to next ────────────────
for i in range(10):
    if i % 2 == 0:
        continue        # skip even numbers — go to next iteration
    print(i, end=" ")  # prints only odd: 1 3 5 7 9

# Practical: skip invalid items
data = [1, None, 3, None, 5]
total = 0
for item in data:
    if item is None:
        continue        # skip None values
    total += item       # only add actual numbers
print(total)           # Output: 9

# ── PASS — do nothing (placeholder) ───────────────────────────
# pass is used when syntax requires a block but you don't want to do anything yet
for i in range(5):
    pass               # loop runs 5 times but does absolutely nothing

# Common use: placeholder while building code
def function_ill_write_later():
    pass               # without pass, Python requires something here — SyntaxError

class MyClass:
    pass               # empty class placeholder

# Loop else: runs if the loop finished WITHOUT a break

# Example: search for an item
items = ["apple", "banana", "cherry"]
target = "mango"

for item in items:
    if item == target:
        print(f"Found {target}!")
        break           # break exits — else does NOT run
else:
    print(f"{target} not found.")  # runs because no break occurred
# Output: mango not found.

# Without this feature, you'd need a flag variable:
found = False                        # messy way
for item in items:
    if item == target:
        found = True
        break
if not found:
    print("Not found.")             # the else clause is cleaner!

# While loop else works the same way
n = 2
while n < 100:
    if n % 7 == 0:
        print(f"Found multiple of 7: {n}")
        break
    n += 1
else:
    print("No multiples of 7 found below 100")  # won't print — 7 exists!

# A loop inside a loop = nested loop
# The inner loop runs COMPLETELY for each single iteration of the outer loop

# Multiplication table
for i in range(1, 4):          # outer loop: rows 1, 2, 3
    for j in range(1, 4):      # inner loop: columns 1, 2, 3
        print(f"{i}x{j}={i*j:2}", end="  ")
    print()  # new line after each row
# Output:
# 1x1= 1  1x2= 2  1x3= 3
# 2x1= 2  2x2= 4  2x3= 6
# 3x1= 3  3x2= 6  3x3= 9

# Nested loops with a list of lists (2D data)
matrix = [
    [1, 2, 3],    # row 0
    [4, 5, 6],    # row 1
    [7, 8, 9]     # row 2
]

for row in matrix:           # each row is a list
    for cell in row:        # each cell is a number
        print(cell, end=" ")
    print()
# Output: 1 2 3 / 4 5 6 / 7 8 9

# PERFORMANCE WARNING: nested loops multiply complexity
# One loop of 1000: 1,000 operations
# Two nested loops of 1000: 1,000,000 operations!
# Three nested loops: 1,000,000,000 — very slow!
# Think carefully before nesting more than 2 levels deep

# Define a function with 'def' keyword
# Format: def function_name(parameters):
def say_hello():
    """Print a greeting."""     # docstring — describes what function does
    print("Hello, World!")

# CALL the function (execute it)
say_hello()   # Output: Hello, World!
say_hello()   # Call as many times as needed

# Function with a parameter
def greet(name):               # 'name' is a parameter (placeholder)
    print(f"Hello, {name}!")

greet("Alice")   # 'Alice' is the argument
greet("Bob")

# Function that returns a value
def square(n):
    return n ** 2    # 'return' sends a value back to the caller

result = square(5)   # result = 25
print(result)

# Multiple parameters
def rectangle_area(width, height):
    """Calculate area of a rectangle."""
    return width * height

print(rectangle_area(5, 3))     # 15 — positional: order matters
print(rectangle_area(height=4, width=6))  # 24 — keyword: order doesn't matter

# Default values: used when caller doesn't provide that argument
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")                  # uses default: Hello, Alice!
greet("Bob", "Hi")             # overrides: Hi, Bob!
greet("Charlie", greeting="Hey") # keyword: Hey, Charlie!

# ⚠️ GOTCHA: Never use mutable objects (lists, dicts) as defaults!
def add_item_BAD(item, my_list=[]):   # [] is shared across ALL calls!
    my_list.append(item)
    return my_list

print(add_item_BAD("a"))  # ['a']     — seems fine
print(add_item_BAD("b"))  # ['a', 'b'] — WRONG! 'a' persists!

# Correct pattern: use None and create fresh inside
def add_item_GOOD(item, my_list=None):
    if my_list is None:
        my_list = []     # fresh list every time
    my_list.append(item)
    return my_list

# *args: collect unlimited POSITIONAL args into a TUPLE
def add_all(*args):
    print(f"args: {args}")        # it's a tuple
    return sum(args)

print(add_all(1, 2))             # args=(1,2)       → 3
print(add_all(1, 2, 3, 4, 5))   # args=(1,2,3,4,5) → 15

# **kwargs: collect unlimited KEYWORD args into a DICT
def print_info(**kwargs):
    print(f"kwargs: {kwargs}")     # it's a dict
    for key, val in kwargs.items():
        print(f"  {key} = {val}")

print_info(name="Alice", age=25, city="NYC")

# Combining all types — must be in this EXACT order:
# def f(positional, *args, keyword_only, **kwargs)
def full_example(required, *args, keyword_only="default", **kwargs):
    print(required, args, keyword_only, kwargs)

full_example(1, 2, 3, keyword_only="hi", x=10)
# Output: 1  (2, 3)  hi  {'x': 10}

# Unpacking with * and ** when CALLING a function
numbers = [1, 2, 3]
print(*numbers)         # same as: print(1, 2, 3)

config = {"end": "!\n", "sep": "-"}
print("a", "b", **config)  # unpacks dict as keyword args

company = "TechCorp"      # global variable

def show():
    print(company)         # ✅ can READ globals
    local_var = "local"   # this only lives inside show()
    print(local_var)

show()
# print(local_var)  ← NameError! Can't see inside the function

# Assigning inside function creates LOCAL, doesn't touch global
counter = 0
def bad_increment():
    counter = 10    # creates LOCAL counter — global unchanged!

bad_increment()
print(counter)       # still 0!

# To modify a global, declare with 'global'
def good_increment():
    global counter
    counter += 1      # now modifies the actual global

good_increment()
print(counter)       # 1 ✅

# Better approach: pass in, return out (avoid globals!)
def increment(n):
    return n + 1

counter = increment(counter)   # clean, testable, no hidden state

def calculate_bmi(weight_kg, height_m):
    """
    Calculate Body Mass Index (BMI).

    Args:
        weight_kg (float): Weight in kilograms
        height_m (float): Height in meters

    Returns:
        float: BMI value (weight / height^2)

    Example:
        >>> calculate_bmi(70, 1.75)
        22.86
    """
    return round(weight_kg / (height_m ** 2), 2)

# Access a function's docstring
print(calculate_bmi.__doc__)

# Or use the built-in help() function
help(calculate_bmi)    # prints nicely formatted docs

# Good docstrings answer:
# - WHAT does this function do?
# - WHAT does each parameter mean?
# - WHAT does it return?
# - Any caveats or examples

# Format: lambda parameters: expression
# The expression is automatically returned — no 'return' keyword

# Regular function vs lambda — same result
def square_regular(x):
    return x ** 2

square_lambda = lambda x: x ** 2    # anonymous function stored in a variable

print(square_regular(5))   # 25
print(square_lambda(5))    # 25 — same result

# Multiple parameters
add = lambda a, b: a + b
print(add(3, 4))           # 7

# The REAL power of lambdas: passing functions as arguments

# Sort a list of dicts by a specific key
students = [
    {"name": "Charlie", "grade": 85},
    {"name": "Alice",   "grade": 92},
    {"name": "Bob",     "grade": 78},
]

# sorted() takes a 'key' argument — a function that says "sort by THIS"
by_grade = sorted(students, key=lambda s: s["grade"])
for s in by_grade:
    print(f"{s['name']}: {s['grade']}")

# Sort by name length
words = ["banana", "apple", "kiwi", "strawberry"]
print(sorted(words, key=lambda w: len(w)))

# map() and filter() with lambdas
nums = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, nums))        # [1, 4, 9, 16, 25]
evens   = list(filter(lambda x: x%2==0, nums))    # [2, 4]
print(squared, evens)

# NOTE: For complex logic, use a regular function — lambdas are for simplicity

# PURE function — same input, always same output, no side effects
def add(a, b):
    return a + b   # predictable, testable, no surprises

# IMPURE function — has side effects (modifies external list)
data = [1, 2, 3]

def append_and_sum_impure(item):
    data.append(item)    # SIDE EFFECT: modifies external list
    return sum(data)

print(append_and_sum_impure(4))  # 10  — data is now [1,2,3,4]
print(append_and_sum_impure(4))  # 14  — data is now [1,2,3,4,4]!
# Same call with same argument, different output — unpredictable!

# Prefer pure: pass data in, return new data out
def append_and_sum_pure(lst, item):
    new_list = lst + [item]   # create NEW list, don't modify original
    return new_list, sum(new_list)

new_data, total = append_and_sum_pure(data, 5)
# data is unchanged; new_data is the modified version

# Creating lists — use square brackets []
fruits = ["apple", "banana", "cherry"]   # list of strings
numbers = [1, 2, 3, 4, 5]              # list of ints
mixed = ["Alice", 25, True, None]       # lists can hold ANYTHING
empty = []                              # empty list
nested = [[1, 2], [3, 4], [5, 6]]    # list of lists

# ── ACCESSING ITEMS ────────────────────────────────────────────
print(fruits[0])      # "apple"   — first item
print(fruits[-1])     # "cherry"  — last item
print(fruits[1:3])    # ['banana', 'cherry'] — slicing

# ── MODIFYING LISTS ────────────────────────────────────────────
fruits[1] = "blueberry"  # change item at index 1
print(fruits)             # ['apple', 'blueberry', 'cherry']

# Adding items
fruits.append("date")     # adds to the END — most common
fruits.insert(1, "avocado") # insert at index 1, shifts others right
fruits.extend(["elderberry", "fig"])  # add multiple items from another list

# Removing items
fruits.remove("banana")    # remove first occurrence of this value
popped = fruits.pop()     # remove and RETURN last item
popped2 = fruits.pop(0)  # remove and return item at index 0
del fruits[0]             # delete item at index 0 (no return)
fruits.clear()            # remove ALL items → []

# ── SEARCHING ──────────────────────────────────────────────────
colors = ["red", "green", "blue", "red"]
print("red" in colors)    # True — membership test
print(colors.index("green"))   # 1 — index of first match
print(colors.count("red"))    # 2 — how many times it appears

# ── SORTING ────────────────────────────────────────────────────
nums = [3, 1, 4, 1, 5, 9, 2]

nums.sort()                     # sort IN-PLACE — modifies the list
print(nums)                      # [1, 1, 2, 3, 4, 5, 9]

nums.sort(reverse=True)         # descending
print(nums)                      # [9, 5, 4, 3, 2, 1, 1]

original = [3, 1, 4, 1, 5]
sorted_copy = sorted(original)   # returns NEW sorted list, original unchanged
print(original)                  # [3, 1, 4, 1, 5] — untouched

# Sort by custom key
words = ["banana", "apple", "kiwi"]
print(sorted(words, key=len))   # sort by string length: ['kiwi', 'apple', 'banana']

# ── OTHER USEFUL OPERATIONS ────────────────────────────────────
nums = [1, 2, 3, 4, 5]
print(len(nums))         # 5 — number of items
print(sum(nums))         # 15 — sum of all items
print(min(nums))         # 1 — smallest
print(max(nums))         # 5 — largest
nums.reverse()           # reverse in place
copy = nums[:]           # shallow copy (slicing trick)
copy2 = nums.copy()     # same as above, more explicit

# ── LIST COMPREHENSIONS — create lists with elegance ───────────
# Format: [expression for item in iterable if condition]

# Old way: loop + append
squares_old = []
for n in range(1, 6):
    squares_old.append(n ** 2)

# New way: list comprehension (concise, fast, Pythonic)
squares = [n ** 2 for n in range(1, 6)]
print(squares)   # [1, 4, 9, 16, 25]

# With a filter condition
evens = [n for n in range(20) if n % 2 == 0]
print(evens)     # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Transforming strings
names = ["alice", "bob", "charlie"]
upper_names = [name.upper() for name in names]
print(upper_names)  # ['ALICE', 'BOB', 'CHARLIE']

# Nested comprehension (flattening a 2D list)
matrix = [[1,2,3],[4,5,6],[7,8,9]]
flat = [num for row in matrix for num in row]
print(flat)      # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Creating tuples — parentheses (optional but conventional)
point = (3, 7)                   # 2D coordinate
rgb = (255, 128, 0)               # color values
person = ("Alice", 25, "NYC")    # grouped data
single = (42,)                    # ← trailing comma REQUIRED for 1-item tuples!
empty = ()                          # empty tuple

# Accessing — same as lists
print(point[0])       # 3
print(rgb[-1])        # 0
print(person[1:3])    # (25, 'NYC')

# Immutability — cannot change after creation
# point[0] = 10  ← TypeError! Tuples don't support item assignment

# ── WHY USE TUPLES OVER LISTS? ────────────────────────────────
# 1. Immutability signals intent: "this data shouldn't change"
# 2. Tuples are slightly faster than lists
# 3. Tuples can be used as DICTIONARY KEYS — lists cannot!
locations = {
    (40.7128, -74.0060): "New York",    # tuple as key ✅
    (34.0522, -118.2437): "Los Angeles",
}

# 4. Tuples are returned by functions returning multiple values
def divmod_custom(a, b):
    return a // b, a % b   # returns a tuple automatically

quotient, remainder = divmod_custom(17, 5)
print(quotient, remainder)  # 3 2

# Tuple unpacking — assign multiple variables at once
name, age, city = person    # unpack all 3 values
print(name, age, city)     # Alice 25 NYC

x, y = 10, 20              # create and unpack in one line
x, y = y, x                # SWAP two variables — Python magic!
print(x, y)                # 20 10

# Extended unpacking with *
first, *middle, last = [1, 2, 3, 4, 5]
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

# Creating dictionaries — curly braces {key: value}
person = {
    "name": "Alice",     # key: value
    "age": 25,
    "city": "NYC",
    "hobbies": ["coding", "hiking"]  # value can be anything!
}

# ── ACCESSING VALUES ───────────────────────────────────────────
print(person["name"])       # "Alice" — direct access
# person["missing"]          ← KeyError if key doesn't exist!

# .get() — safe access with optional default
print(person.get("name"))           # "Alice"
print(person.get("email"))          # None — key doesn't exist, no error
print(person.get("email", "N/A"))  # "N/A" — custom default

# ── MODIFYING DICTIONARIES ─────────────────────────────────────
person["age"] = 26             # update existing key
person["email"] = "[email protected]"  # add new key

person.update({"age": 27, "country": "USA"})  # update multiple at once

del person["city"]            # delete a key-value pair
removed = person.pop("email") # remove and return value

# ── CHECKING EXISTENCE ─────────────────────────────────────────
print("name" in person)       # True — checks KEYS
print("Alice" in person)      # False — doesn't check values
print("Alice" in person.values())  # True — explicitly check values

# ── ITERATING ──────────────────────────────────────────────────
for key in person:                     # iterates over keys
    print(key)

for key in person.keys():             # explicit keys iteration
    print(key)

for value in person.values():         # iterate over values
    print(value)

for key, value in person.items():    # iterate over key-value pairs
    print(f"{key}: {value}")

# ── DICT COMPREHENSION ─────────────────────────────────────────
# {key_expr: val_expr for item in iterable}
squares = {n: n**2 for n in range(1, 6)}
print(squares)   # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Invert a dictionary (swap keys and values)
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted)  # {1: 'a', 2: 'b', 3: 'c'}

# Merge two dicts (Python 3.9+)
defaults = {"theme": "light", "language": "en"}
user_prefs = {"theme": "dark"}
merged = defaults | user_prefs    # user_prefs overrides defaults
print(merged)  # {'theme': 'dark', 'language': 'en'}

# Creating sets — curly braces, but no key:value pairs
colors = {"red", "green", "blue"}
nums = {1, 2, 3, 4}

# Duplicates are automatically removed!
dupes = {1, 2, 2, 3, 3, 3}
print(dupes)    # {1, 2, 3}

# Create a set from a list (deduplicate a list!)
raw = ["apple", "banana", "apple", "cherry", "banana"]
unique = set(raw)         # remove duplicates
print(unique)              # {'apple', 'banana', 'cherry'} (order not guaranteed)
unique_list = list(unique) # convert back to list if needed

# IMPORTANT: empty set — can't use {} (that creates an empty DICT!)
empty_set = set()         # ✅ correct
empty_dict = {}            # this is a dict, not a set!

# Adding and removing
colors.add("yellow")       # add one item
colors.discard("pink")    # remove if exists (no error if missing)
colors.remove("red")      # remove (KeyError if missing)

# ── SET MATHEMATICS — the real power of sets ───────────────────
a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

print(a | b)     # Union: all items from both:     {1,2,3,4,5,6,7,8}
print(a & b)     # Intersection: items in BOTH:    {4, 5}
print(a - b)     # Difference: in a but NOT b:     {1, 2, 3}
print(a ^ b)     # Symmetric diff: in one but not both: {1,2,3,6,7,8}

# Practical: find common users between two lists
list_a = ["Alice", "Bob", "Charlie"]
list_b = ["Bob", "Dave", "Alice"]
common = set(list_a) & set(list_b)
print(common)    # {'Bob', 'Alice'}

# Subset and superset checks
print({1, 2}.issubset({1, 2, 3}))    # True: {1,2} is inside {1,2,3}
print({1, 2, 3}.issuperset({1, 2})) # True: {1,2,3} contains {1,2}

# Decision guide — which structure to choose?

# "I need ordered items I'll loop through" → LIST
todo_list = ["Buy groceries", "Call dentist", "Write report"]

# "I have fixed data that shouldn't change" → TUPLE
SCREEN_SIZE = (1920, 1080)   # won't and shouldn't change
birthday = (1999, 4, 15)

# "I need to look things up by name/key" → DICT
user = {"username": "alice99", "score": 1500, "level": 5}
print(user["score"])    # O(1) instant lookup by key

# "I need unique items / membership testing" → SET
visited_pages = {"/home", "/about", "/contact"}
if "/home" in visited_pages:    # O(1) — sets are FAST for this
    print("Already visited home")

# Performance note: checking 'x in list' is O(n) — slow for large lists
# Checking 'x in set' is O(1) — instant regardless of set size!
big_list = list(range(1_000_000))
big_set  = set(range(1_000_000))
# 999_999 in big_list  → scans up to 1 million items
# 999_999 in big_set   → instant! Always O(1)

from collections import defaultdict, Counter, deque, namedtuple

# ── defaultdict — never get a KeyError again ───────────────────
# PROBLEM: counting word frequency with a plain dict requires a key check
# APPROACH: defaultdict auto-creates missing keys with a default factory

# Plain dict — cumbersome
word_count = {}
for word in ["apple", "banana", "apple", "cherry", "banana", "apple"]:
    if word not in word_count:
        word_count[word] = 0
    word_count[word] += 1

# defaultdict — clean and Pythonic
word_count = defaultdict(int)   # int() returns 0, the default
for word in ["apple", "banana", "apple", "cherry", "banana", "apple"]:
    word_count[word] += 1         # no KeyError — missing keys default to 0

print(dict(word_count))  # {'apple': 3, 'banana': 2, 'cherry': 1}

# defaultdict(list) — group items
by_length = defaultdict(list)
for word in ["cat", "dog", "elephant", "ant", "bear"]:
    by_length[len(word)].append(word)
# {3: ['cat', 'dog', 'ant'], 8: ['elephant'], 4: ['bear']}

# ── Counter — count anything in one line ───────────────────────
from collections import Counter

votes = ["Alice", "Bob", "Alice", "Alice", "Bob", "Charlie"]
tally = Counter(votes)
print(tally)              # Counter({'Alice': 3, 'Bob': 2, 'Charlie': 1})
print(tally.most_common(2)) # [('Alice', 3), ('Bob', 2)] — top 2
print(tally["Alice"])    # 3
print(tally["Zara"])     # 0 — missing keys return 0, not KeyError

# Counter arithmetic
a = Counter("aabbcc")
b = Counter("abcd")
print(a + b)   # Counter({'a': 3, 'b': 3, 'c': 3, 'd': 1})
print(a - b)   # Counter({'a': 1, 'b': 1, 'c': 1})

# ── deque — O(1) append/pop from BOTH ends ─────────────────────
# list.insert(0, x) is O(n) — slow for large lists
# deque.appendleft(x) is O(1) — always fast

queue = deque(["first", "second"])
queue.append("third")          # add to right: ['first', 'second', 'third']
queue.appendleft("zeroth")     # add to left: ['zeroth', 'first', ...]
print(queue.popleft())         # remove from left: 'zeroth'
print(queue.pop())             # remove from right: 'third'

# Fixed-size sliding window (maxlen)
recent = deque(maxlen=3)       # keeps only last 3 items
for n in [1, 2, 3, 4, 5]:
    recent.append(n)
print(recent)                  # deque([3, 4, 5], maxlen=3)

# ── namedtuple — lightweight named records ─────────────────────
# Like a tuple but fields have names — more readable than index access
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 7)
print(p.x, p.y)     # 3, 7 — named access
print(p[0], p[1])  # 3, 7 — still works as a tuple
print(p)            # Point(x=3, y=7) — readable repr
x, y = p            # still unpackable

# Better than: color = (255, 128, 0) and having to remember indices
Color = namedtuple("Color", ["red", "green", "blue"])
orange = Color(255, 128, 0)
print(orange.red)   # 255 — clearer than orange[0]

# open(filename, mode) — open a file and return a file object
# Mode tells Python what you want to DO with the file

# ── FILE MODES ─────────────────────────────────────────────────
# "r"  — Read (default). File must exist. Cannot write.
# "w"  — Write. Creates file if not exists. ERASES existing content!
# "a"  — Append. Creates if not exists. Adds to END of file.
# "x"  — Exclusive create. Fails if file already exists.
# "r+" — Read and write. File must exist.
# "b"  — Binary mode (add to any: "rb", "wb") — for images, PDFs, etc.

# The old way — you MUST close the file manually!
f = open("notes.txt", "r")     # open for reading
content = f.read()              # read entire file into a string
f.close()                       # MUST close — releases the file lock

# Problem: if an error happens between open() and close(),
# close() never gets called and the file stays locked.
# Solution: use 'with' statement (next section)

# The 'with' statement — ALWAYS use this for files
# When the 'with' block ends (normally or via exception),
# Python automatically closes the file for you.

# ── READING ────────────────────────────────────────────────────
with open("notes.txt", "r") as f:    # 'f' is the file object
    content = f.read()               # read entire file as one string
    print(content)
# file is automatically closed here — no f.close() needed!

# Read line by line (memory-efficient for huge files)
with open("notes.txt", "r") as f:
    for line in f:                   # file objects are iterable!
        print(line.strip())          # .strip() removes the \n at end of each line

# Read all lines into a list
with open("notes.txt", "r") as f:
    lines = f.readlines()           # list of strings, each ending with \n
    print(f"{len(lines)} lines")

# ── WRITING ────────────────────────────────────────────────────
with open("output.txt", "w") as f:   # "w" ERASES existing content!
    f.write("Hello, File!\n")          # write a string (\n = new line)
    f.write("Second line.\n")

# Write multiple lines at once
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("output.txt", "w") as f:
    f.writelines(lines)               # write a list of strings

# ── APPENDING ──────────────────────────────────────────────────
with open("log.txt", "a") as f:      # "a" adds to end, doesn't erase
    f.write("New log entry\n")

# ── SPECIFYING ENCODING (always do this!) ──────────────────────
# Different computers/systems use different text encodings
# UTF-8 is the universal standard — always specify it explicitly
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

# Reading/writing non-English text requires this!
with open("greetings.txt", "w", encoding="utf-8") as f:
    f.write("こんにちは\n")   # Japanese — works fine with UTF-8
    f.write("Héllo Wörld\n") # Accented chars — also fine

import csv    # built-in module — no installation needed

# ── READING A CSV ──────────────────────────────────────────────
# Imagine data.csv contains:
# name,age,city
# Alice,25,New York
# Bob,30,Los Angeles

# Read as lists
with open("data.csv", "r", newline="", encoding="utf-8") as f:
    # newline="" is recommended by Python docs to handle line endings correctly
    reader = csv.reader(f)            # creates a CSV reader object
    header = next(reader)             # read (and skip) the first row = header
    print(f"Columns: {header}")        # ['name', 'age', 'city']
    for row in reader:               # each row is a list of strings
        name, age, city = row         # unpack
        print(f"{name} is {age} from {city}")

# Read as dicts (DictReader — cleaner for most use cases)
with open("data.csv", "r", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)       # first row becomes dict keys
    for row in reader:
        print(row)                    # {'name': 'Alice', 'age': '25', 'city': 'New York'}
        print(row["name"])           # access by column name — much cleaner!

# ── WRITING A CSV ──────────────────────────────────────────────
data = [
    ["name", "age", "city"],          # header row
    ["Alice", 25, "New York"],
    ["Bob", 30, "Los Angeles"],
    ["Charlie", 22, "Chicago"],
]

with open("output.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerows(data)           # write all rows at once

# Write dicts with DictWriter
people = [
    {"name": "Alice", "score": 95},
    {"name": "Bob",   "score": 87},
]
fields = ["name", "score"]           # define column order

with open("scores.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fields)
    writer.writeheader()             # writes "name,score" header row
    writer.writerows(people)         # writes all dict rows

import json

# Python ↔ JSON type mapping:
# Python dict    ↔  JSON object  {}
# Python list    ↔  JSON array   []
# Python str     ↔  JSON string  ""
# Python int/float ↔ JSON number
# Python True/False ↔ JSON true/false
# Python None    ↔  JSON null

# ── WRITING JSON (serializing Python → JSON) ───────────────────
user = {
    "name": "Alice",
    "age": 25,
    "active": True,
    "scores": [95, 87, 92],
    "address": {"city": "NYC", "zip": "10001"}
}

# json.dump — write to a file
with open("user.json", "w", encoding="utf-8") as f:
    json.dump(user, f, indent=4)    # indent=4 makes it human-readable
# Creates a nicely formatted file

# json.dumps — convert to string (not file)
json_string = json.dumps(user, indent=2)
print(json_string)

# ── READING JSON (deserializing JSON → Python) ─────────────────
# json.load — read from a file
with open("user.json", "r", encoding="utf-8") as f:
    loaded_user = json.load(f)

print(type(loaded_user))           # <class 'dict'> — it's a Python dict now
print(loaded_user["name"])        # Alice
print(loaded_user["scores"][0])  # 95

# json.loads — parse from a string (common with API responses)
raw_json = '{"status": "ok", "count": 42}'   # a string, not a dict
parsed = json.loads(raw_json)
print(parsed["count"])            # 42 — now a proper Python dict

# Handling JSON that might be malformed
try:
    data = json.loads('{"broken": json')   # invalid JSON
except json.JSONDecodeError as e:
    print(f"JSON error: {e}")

from pathlib import Path

# ── Creating Paths ─────────────────────────────────────────────
p = Path("data/report.csv")      # relative path
p = Path.cwd()                   # current working directory
p = Path.home()                  # user's home directory (~)
p = Path(__file__).parent       # directory of the current script

# ── Path arithmetic with / operator ───────────────────────────
config_dir = Path.home() / ".config" / "myapp"
data_file  = Path("project") / "data" / "sales.csv"

# ── Inspecting paths ──────────────────────────────────────────
p = Path("reports/annual_2024.pdf")
print(p.name)       # "annual_2024.pdf" — filename with extension
print(p.stem)       # "annual_2024" — filename without extension
print(p.suffix)     # ".pdf" — extension including the dot
print(p.parent)     # "reports" — parent directory
print(p.parts)      # ('reports', 'annual_2024.pdf')

# ── Checking existence ────────────────────────────────────────
p = Path("myfile.txt")
print(p.exists())   # True/False
print(p.is_file())  # True if it's a file (not a directory)
print(p.is_dir())   # True if it's a directory

# ── Reading and writing — no open() needed! ───────────────────
path = Path("output.txt")
path.write_text("Hello, pathlib!")          # write string to file
content = path.read_text()                  # read entire file as string
path.write_bytes(b"binary data")           # write bytes
data = path.read_bytes()                    # read as bytes

# ── Creating directories ──────────────────────────────────────
Path("new/nested/dir").mkdir(parents=True, exist_ok=True)
# parents=True: create intermediate dirs; exist_ok=True: don't error if exists

# ── Globbing — find files matching a pattern ──────────────────
src = Path(".")
for py_file in src.glob("*.py"):            # all .py in current dir
    print(py_file.name)

for py_file in src.rglob("*.py"):           # recursive: all .py everywhere
    print(py_file)

# ── Renaming and moving ────────────────────────────────────────
old = Path("draft.txt")
old.rename(Path("final.txt"))              # rename in-place

# ── Changing extensions ────────────────────────────────────────
p = Path("data.csv")
new_p = p.with_suffix(".json")            # Path("data.json")
new_p = p.with_name("output.csv")         # Path("output.csv")

# Common exceptions you'll encounter

# ValueError — right type, wrong value
int("hello")       # ValueError: invalid literal for int()

# TypeError — wrong type entirely
5 + "ten"          # TypeError: unsupported operand type(s)

# KeyError — dictionary key doesn't exist
d = {"a": 1}
d["b"]             # KeyError: 'b'

# IndexError — list index out of range
lst = [1, 2, 3]
lst[10]            # IndexError: list index out of range

# NameError — variable doesn't exist
print(undefined_variable)  # NameError: name 'undefined_variable' is not defined

# FileNotFoundError — file doesn't exist
open("missing.txt")  # FileNotFoundError: No such file or directory

# ZeroDivisionError — dividing by zero
10 / 0              # ZeroDivisionError: division by zero

# AttributeError — object doesn't have that attribute/method
5.upper()           # AttributeError: 'int' object has no attribute 'upper'

# Basic try/except — the minimum you need
try:
    number = int("hello")   # this will fail
except ValueError:           # catch that specific type of error
    print("That's not a valid number!")
# Output: That's not a valid number! (program continues, no crash)

# Catch multiple exception types
def safe_divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Error: cannot divide by zero")
        return None
    except TypeError:
        print("Error: both arguments must be numbers")
        return None
    return result

print(safe_divide(10, 2))   # 5.0
print(safe_divide(10, 0))   # Error: cannot divide by zero → None
print(safe_divide("a", 2))  # Error: both must be numbers → None

# Access the exception object with 'as'
try:
    result = int("abc")
except ValueError as e:      # 'e' is the exception object
    print(f"Error: {e}")       # Error: invalid literal for int() with base 10: 'abc'

# ── FULL STRUCTURE: try/except/else/finally ────────────────────
def read_file_safely(filename):
    try:
        # try: code that MIGHT raise an exception
        f = open(filename, "r")
        content = f.read()

    except FileNotFoundError:
        # except: runs ONLY if the error occurs
        print(f"File '{filename}' not found.")
        content = None

    except PermissionError:
        # multiple except blocks for different errors
        print("Permission denied.")
        content = None

    else:
        # else: runs ONLY if NO exception occurred
        print(f"Successfully read {len(content)} characters.")
        f.close()    # close on success

    finally:
        # finally: ALWAYS runs — error or not
        # Use for cleanup: close connections, release locks, etc.
        print("Finished attempting to read file.")

    return content

# Catch ALL exceptions (use sparingly — hides bugs!)
try:
    risky_operation = 1 / 0
except Exception as e:       # 'Exception' catches almost everything
    print(f"Something went wrong: {type(e).__name__}: {e}")
# ⚠️ Avoid bare 'except:' with no exception type — catches even keyboard interrupts!

# You can raise exceptions yourself to signal invalid conditions

def set_age(age):
    if not isinstance(age, int):
        raise TypeError(f"Age must be an integer, got {type(age).__name__}")
    if age < 0 or age > 150:
        raise ValueError(f"Age must be between 0 and 150, got {age}")
    return age

try:
    set_age("twenty")
except TypeError as e:
    print(f"TypeError: {e}")

try:
    set_age(-5)
except ValueError as e:
    print(f"ValueError: {e}")

# Re-raise an exception (after logging it)
def process(data):
    try:
        result = risky_operation(data)
    except Exception as e:
        print(f"Logging error: {e}")   # log it
        raise                           # re-raise the SAME exception

# Create your own exception classes by inheriting from Exception
# This lets callers catch YOUR specific error type

class ValidationError(Exception):
    """Raised when user-provided data fails validation."""
    pass   # no extra code needed — inheriting from Exception is enough

class InsufficientFundsError(Exception):
    """Raised when a bank account has insufficient funds."""
    def __init__(self, amount, balance):
        self.amount = amount
        self.balance = balance
        # Call parent's __init__ with a descriptive message
        super().__init__(f"Tried to withdraw {amount}, but balance is {balance}")

# Using custom exceptions
def withdraw(balance, amount):
    if amount <= 0:
        raise ValidationError("Withdrawal amount must be positive")
    if amount > balance:
        raise InsufficientFundsError(amount, balance)
    return balance - amount

try:
    new_balance = withdraw(100, 150)
except InsufficientFundsError as e:
    print(f"Can't withdraw: {e}")
    print(f"You need {e.amount - e.balance} more.")  # access custom attributes
except ValidationError as e:
    print(f"Invalid input: {e}")

import logging

# Configure logging (do this once at the start of your program)
logging.basicConfig(
    level=logging.DEBUG,              # minimum level to log
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[
        logging.StreamHandler(),    # print to console
        logging.FileHandler("app.log")  # also write to file
    ]
)

# Five logging levels (least → most severe)
logging.debug("Detailed diagnostic info — only for debugging")
logging.info("Normal operation — server started, user logged in")
logging.warning("Something unexpected but not breaking — disk 80% full")
logging.error("A function failed — couldn't connect to database")
logging.critical("System-level failure — application is crashing")

# Use in error handling
def safe_parse(text):
    try:
        value = int(text)
        logging.info(f"Parsed value: {value}")
        return value
    except ValueError:
        logging.error(f"Could not parse '{text}' as integer", exc_info=True)
        # exc_info=True includes the full traceback in the log
        return None

# ── IMPORTING MODULES ──────────────────────────────────────────

# import the whole module — access things with module.name
import math
print(math.pi)           # 3.141592653589793
print(math.sqrt(16))    # 4.0
print(math.floor(3.7))  # 3
print(math.ceil(3.2))   # 4

# from module import specific_thing — use it directly
from math import sqrt, pi
print(sqrt(25))   # 5.0 — no 'math.' prefix needed
print(pi)         # 3.14...

# import with alias — shorter name
import numpy as np          # convention: everyone uses 'np'
import pandas as pd          # convention: everyone uses 'pd'
from datetime import datetime as dt

# from module import * — import EVERYTHING (avoid this!)
# from math import *  ← pollutes namespace, hard to know where names come from

# ── YOUR OWN MODULES ───────────────────────────────────────────
# Any .py file is a module. Create utils.py:
# ┌─ utils.py ──────────────────────────┐
# │ def add(a, b):                      │
# │     return a + b                    │
# │ PI = 3.14159                        │
# └─────────────────────────────────────┘

# In main.py (same folder):
# import utils
# print(utils.add(3, 4))   # 7
# print(utils.PI)           # 3.14159

# The if __name__ == "__main__" guard
# When Python runs a file directly, __name__ = "__main__"
# When a file is imported as a module, __name__ = the file's name
# This lets code run when executed directly but not when imported

def main():
    print("Running as main program")

if __name__ == "__main__":
    main()   # only runs when you execute this file directly

# ── os — operating system interface ───────────────────────────
import os

print(os.getcwd())                    # current working directory
os.makedirs("new_folder", exist_ok=True)  # create folder (ok if exists)
print(os.listdir("."))              # list files in current directory
print(os.path.exists("data.csv"))   # does this file exist?
print(os.path.join("data", "file.csv")) # cross-platform path join
print(os.path.basename("/home/user/file.txt"))  # "file.txt"

# Better: pathlib (modern, object-oriented paths)
from pathlib import Path
p = Path("data") / "users" / "file.csv"  # / operator joins paths!
print(p.exists())        # True/False
print(p.suffix)         # ".csv"
print(p.stem)           # "file"

# ── sys — system-specific parameters ─────────────────────────
import sys
print(sys.version)      # Python version string
print(sys.argv)         # command-line arguments: ['script.py', 'arg1', ...]
sys.exit(0)             # exit program (0 = success, non-zero = error)

# ── math — mathematical functions ─────────────────────────────
import math
print(math.pi, math.e, math.tau)  # pi, Euler's number, tau (2π)
print(math.sin(math.pi / 2))      # 1.0
print(math.log(100, 10))          # 2.0 (log base 10 of 100)
print(math.factorial(5))           # 120
print(math.gcd(48, 18))            # 6 (greatest common divisor)

# ── random — random number generation ─────────────────────────
import random
print(random.random())             # float between 0.0 and 1.0
print(random.randint(1, 100))     # random integer 1-100 (inclusive)
print(random.choice(["a", "b", "c"]))  # pick random item from list
items = [1, 2, 3, 4, 5]
random.shuffle(items)              # shuffle list in place
print(random.sample(items, 3))    # 3 unique random items (no replacement)
random.seed(42)                    # set seed for reproducible results

# ── datetime — dates and times ────────────────────────────────
from datetime import datetime, date, timedelta

now = datetime.now()              # current date and time
print(now)                         # 2024-01-15 14:30:22.123456
print(now.year, now.month, now.day)  # 2024, 1, 15
print(now.strftime("%Y-%m-%d %H:%M"))  # format: "2024-01-15 14:30"

birthday = date(1990, 6, 15)     # create a specific date
today = date.today()
age = (today - birthday).days // 365  # calculate age in years

# timedelta: time differences
one_week_later = now + timedelta(weeks=1)
yesterday = now - timedelta(days=1)

# ── collections — specialized containers ──────────────────────
from collections import Counter, defaultdict, namedtuple, deque

# Counter: count occurrences of items
words = ["apple", "banana", "apple", "cherry", "apple", "banana"]
counts = Counter(words)
print(counts)                  # Counter({'apple': 3, 'banana': 2, 'cherry': 1})
print(counts.most_common(2))  # [('apple', 3), ('banana', 2)]

# Counter also works on strings!
char_counts = Counter("hello world")
print(char_counts)

# defaultdict: dict that auto-creates missing keys
# Normal dict raises KeyError for missing keys
# defaultdict creates a default value instead
word_groups = defaultdict(list)   # missing key creates empty list
for word in ["apple", "avocado", "banana", "blueberry"]:
    word_groups[word[0]].append(word)  # group by first letter
print(dict(word_groups))
# {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry']}

# namedtuple: tuples with named fields (like a lightweight class)
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 7)
print(p.x, p.y)     # 3, 7  — access by name
print(p[0])         # 3    — still works as a tuple

# deque: double-ended queue, fast at both ends
dq = deque([1, 2, 3])
dq.appendleft(0)     # fast prepend to front
dq.append(4)          # fast append to end
print(dq)              # deque([0, 1, 2, 3, 4])

# Install a package
pip install requests

# Install a specific version
pip install requests==2.31.0

# Install minimum version
pip install requests>=2.28.0

# Install multiple packages
pip install requests pandas numpy matplotlib

# Upgrade an existing package
pip install --upgrade requests

# Uninstall a package
pip uninstall requests

# List all installed packages
pip list

# Show info about a specific package
pip show requests

# Check for outdated packages
pip list --outdated

# Save all installed packages to a file
pip freeze > requirements.txt

# Install from a requirements file
pip install -r requirements.txt

# Create a virtual environment in a folder called 'venv'
python -m venv venv

# Activate it (MUST DO THIS every time you work on the project!)
# On Windows:
venv\Scripts\activate

# On Mac/Linux:
source venv/bin/activate

# Your prompt now shows (venv) to confirm it's active
# (venv) $ pip install requests   ← installs ONLY in this venv

# Deactivate when done
deactivate

# Never commit the venv/ folder to git!
# Add it to .gitignore:
# venv/
# __pycache__/
# *.pyc

# requirements.txt — pin exact versions for reproducibility
requests==2.31.0
pandas==2.0.3
numpy==1.25.2
matplotlib==3.7.2

# Or with flexible versions
requests>=2.28.0,<3.0.0

# Generate requirements.txt from current environment
pip freeze > requirements.txt

# Install everything in requirements.txt (for collaborators / deployment)
pip install -r requirements.txt

from datetime import datetime, date, time, timedelta, timezone

# ── Creating dates and times ───────────────────────────────────
today = date.today()                       # just the date: 2024-03-15
now = datetime.now()                       # local date + time (naive!)
utc_now = datetime.now(timezone.utc)      # ✅ UTC-aware datetime
specific = datetime(2024, 3, 15, 14, 30)  # year, month, day, hour, min

print(today)         # 2024-03-15
print(now)           # 2024-03-15 14:30:00.123456
print(utc_now)       # 2024-03-15 19:30:00.123456+00:00

# ── Formatting: datetime → string (strftime) ───────────────────
# strftime = "string format time"
now = datetime(2024, 3, 15, 14, 30, 45)
print(now.strftime("%Y-%m-%d"))           # "2024-03-15"
print(now.strftime("%B %d, %Y"))          # "March 15, 2024"
print(now.strftime("%I:%M %p"))           # "02:30 PM"
print(now.strftime("%A, %B %d"))          # "Friday, March 15"

# Key format codes:
# %Y=year(4dig) %m=month(01-12) %d=day(01-31)
# %H=hour(24h) %M=minute %S=second
# %I=hour(12h) %p=AM/PM
# %A=weekday(full) %B=month(full)

# ── Parsing: string → datetime (strptime) ─────────────────────
# strptime = "string parse time"
date_str = "2024-03-15"
parsed = datetime.strptime(date_str, "%Y-%m-%d")
print(parsed)        # 2024-03-15 00:00:00

# fromisoformat — parse ISO 8601 strings (simpler than strptime)
dt = datetime.fromisoformat("2024-03-15T14:30:00")

# ── Date arithmetic with timedelta ────────────────────────────
today = date.today()
tomorrow = today + timedelta(days=1)
next_week = today + timedelta(weeks=1)
in_90_days = today + timedelta(days=90)
two_hours_ago = datetime.now() - timedelta(hours=2)

# Difference between two dates
start = date(2024, 1, 1)
end = date(2024, 12, 31)
diff = end - start
print(diff.days)     # 365

# ── Timestamps ────────────────────────────────────────────────
import time as time_module
ts = datetime.now(timezone.utc).timestamp()  # Unix timestamp (float)
back = datetime.fromtimestamp(ts, tz=timezone.utc) # back to datetime

import re

# ── Core functions ─────────────────────────────────────────────
# re.search()  — find FIRST match anywhere in string
# re.match()   — match only at START of string
# re.findall() — return list of ALL matches
# re.sub()     — replace matches with something else
# re.compile() — pre-compile a pattern for repeated use (faster)

text = "Call us at 555-1234 or 555-5678 for info."

# re.search — returns a Match object or None
match = re.search(r"\d{3}-\d{4}", text)
if match:
    print(match.group())    # "555-1234" — the matched text
    print(match.start())   # 11 — start index
    print(match.end())     # 19 — end index

# re.findall — return all matches as a list
phones = re.findall(r"\d{3}-\d{4}", text)
print(phones)              # ['555-1234', '555-5678']

# re.sub — replace all matches
cleaned = re.sub(r"\d{3}-\d{4}", "[REDACTED]", text)
print(cleaned)             # "Call us at [REDACTED] or [REDACTED]..."

# re.compile — reuse a pattern (more efficient for loops)
phone_pattern = re.compile(r"\d{3}-\d{4}")
for line in ["555-1234", "no match", "999-0000"]:
    if phone_pattern.search(line):
        print(f"Found phone in: {line}")

# ── Essential pattern syntax ───────────────────────────────────
# .        any character except newline
# *        0 or more of previous
# +        1 or more of previous
# ?        0 or 1 of previous (optional)
# {n}      exactly n of previous
# {n,m}    between n and m of previous
# ^        start of string
# $        end of string
# [abc]    any of: a, b, or c
# [^abc]   anything EXCEPT a, b, or c
# \d       any digit (0-9)
# \w       any word character (letter, digit, underscore)
# \s       any whitespace (space, tab, newline)
# (abc)    capturing group
# a|b      a or b

# ── Capturing groups ──────────────────────────────────────────
# Parentheses create groups you can extract separately
email = "[email protected]"
match = re.search(r"(\w+)@(\w+)\.(\w+)", email)
if match:
    print(match.group(0))   # "[email protected]" — whole match
    print(match.group(1))   # "alice" — group 1
    print(match.group(2))   # "example" — group 2
    print(match.group(3))   # "com" — group 3

# Named groups — cleaner than numbered
match = re.search(r"(?P<user>\w+)@(?P<domain>\w+)\.(?P<tld>\w+)", email)
if match:
    print(match.group("user"))    # "alice"
    print(match.group("domain"))  # "example"

# ── Raw strings: always use r"..." for patterns ───────────────
# \d without raw string = \\d (double backslash needed)
# r"\d" = \d (backslash preserved) ← always use raw strings!

# ── Flags ─────────────────────────────────────────────────────
text = "Hello\nWorld"
re.search(r"hello", text, re.IGNORECASE)   # case-insensitive
re.search(r"^World", text, re.MULTILINE)    # ^ matches each line start

# CLASS — the blueprint/template
# Classes use PascalCase by convention
class Dog:
    """Represents a dog with a name and breed."""

    # __init__ = "initializer" — called automatically when you create an instance
    # 'self' refers to the specific object being created
    # 'self' MUST be the first parameter of every method — Python passes it automatically
    def __init__(self, name, breed, age):
        # self.attribute = value — these become INSTANCE attributes
        # Each Dog object gets its own copy of these
        self.name = name         # store name on THIS dog object
        self.breed = breed       # store breed on THIS dog object
        self.age = age           # store age on THIS dog object
        self.tricks = []         # each dog starts with an empty tricks list

    # METHOD — a function that belongs to the class
    def bark(self):              # 'self' lets the method access the object's data
        print(f"{self.name} says: Woof!")

    def learn_trick(self, trick):
        self.tricks.append(trick)
        print(f"{self.name} learned {trick}!")

    def describe(self):
        tricks_str = ", ".join(self.tricks) if self.tricks else "none"
        print(f"{self.name} is a {self.age}-year-old {self.breed}. Tricks: {tricks_str}")

# INSTANCE — a specific object created from the class blueprint
dog1 = Dog("Rex", "German Shepherd", 3)   # create dog1
dog2 = Dog("Luna", "Labrador", 5)          # create dog2 — independent object!

# Access attributes
print(dog1.name)    # Rex
print(dog2.breed)   # Labrador

# Call methods
dog1.bark()                     # Rex says: Woof!
dog1.learn_trick("sit")         # Rex learned sit!
dog1.learn_trick("shake hands") # Rex learned shake hands!
dog1.describe()

dog2.bark()          # Luna says: Woof! — same method, different object
dog2.describe()      # tricks: none — dog2 is independent of dog1

class BankAccount:
    # CLASS ATTRIBUTE — shared by ALL instances
    # Defined at class level, not inside __init__
    interest_rate = 0.02       # 2% for all accounts
    account_count = 0          # tracks total number of accounts created

    def __init__(self, owner, balance=0):
        # INSTANCE ATTRIBUTES — unique to each account
        self.owner = owner
        self.balance = balance
        BankAccount.account_count += 1   # update class attribute

    def apply_interest(self):
        # Access class attribute via self or class name
        self.balance *= (1 + BankAccount.interest_rate)

    def deposit(self, amount):
        self.balance += amount

# Class attributes are accessed via the class OR any instance
acc1 = BankAccount("Alice", 1000)
acc2 = BankAccount("Bob", 500)

print(BankAccount.interest_rate)   # 0.02 — class attribute
print(acc1.interest_rate)           # 0.02 — also accessible via instance
print(BankAccount.account_count)   # 2 — two accounts created

# Instance attributes are per-object
print(acc1.owner, acc1.balance)     # Alice 1000
print(acc2.owner, acc2.balance)     # Bob 500

# Changing class attribute affects ALL instances
BankAccount.interest_rate = 0.03   # now 3% for everyone
acc1.apply_interest()
print(acc1.balance)                 # 1030.0

# Parent (base) class
class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
        self.is_alive = True

    def eat(self):
        print(f"{self.name} is eating.")

    def describe(self):
        print(f"{self.name} is a {self.species}")

# Child (derived) class — inherits from Animal
class Dog(Animal):              # (Animal) means "inherit from Animal"
    def __init__(self, name, breed):
        # super() calls the PARENT's __init__ — don't duplicate code!
        super().__init__(name, species="Canis lupus familiaris")
        self.breed = breed       # Dog-specific attribute
        self.tricks = []

    # Override parent method
    def describe(self):          # replaces Animal's describe()
        super().describe()       # call parent's version first
        print(f"  Breed: {self.breed}")  # then add dog-specific info

    # New method only dogs have
    def bark(self):
        print(f"{self.name}: Woof!")

class Cat(Animal):
    def __init__(self, name, indoor=True):
        super().__init__(name, species="Felis catus")
        self.indoor = indoor

    def purr(self):
        print(f"{self.name}: Purrr...")

# Usage
rex = Dog("Rex", "German Shepherd")
whiskers = Cat("Whiskers")

rex.eat()       # inherited from Animal
rex.bark()      # Dog-specific
rex.describe()  # overridden version

whiskers.eat()  # also inherited from Animal
whiskers.purr() # Cat-specific

# isinstance() — check if object is an instance of a class (or its parents)
print(isinstance(rex, Dog))     # True
print(isinstance(rex, Animal))  # True! Dog IS-A Animal
print(isinstance(rex, Cat))     # False

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    # __str__: called by print() and str() — human-readable representation
    def __str__(self):
        return f"'{self.title}' by {self.author}"

    # __repr__: called in REPL and repr() — developer representation
    # Should ideally be enough to recreate the object
    def __repr__(self):
        return f"Book(title={self.title!r}, author={self.author!r}, pages={self.pages})"

    # __len__: called by len()
    def __len__(self):
        return self.pages

    # __eq__: called by ==
    def __eq__(self, other):
        if not isinstance(other, Book):
            return NotImplemented
        return self.title == other.title and self.author == other.author

    # __lt__: called by < — enables sorting!
    def __lt__(self, other):
        return self.pages < other.pages

    # __contains__: called by 'in' operator
    def __contains__(self, word):
        return word.lower() in self.title.lower()

    # __add__: called by +
    def __add__(self, other):
        """Combine two books into an anthology."""
        return Book(
            title=f"{self.title} & {other.title}",
            author=f"{self.author}, {other.author}",
            pages=self.pages + other.pages
        )

# In action
b1 = Book("Python Basics", "Alice", 300)
b2 = Book("Advanced Python", "Bob", 500)
b3 = Book("Python Basics", "Alice", 300)

print(b1)               # 'Python Basics' by Alice  (__str__)
print(repr(b1))         # Book(title='Python Basics', ...)  (__repr__)
print(len(b1))           # 300  (__len__)
print(b1 == b3)          # True  (__eq__)
print(b1 == b2)          # False
print(b1 < b2)           # True (300 < 500)  (__lt__)
print("Python" in b1)   # True  (__contains__)

anthology = b1 + b2       # creates a new Book  (__add__)
print(anthology)
print(sorted([b2, b1]))  # sorts by pages using __lt__

from dataclasses import dataclass, field

# @dataclass decorator auto-generates __init__, __repr__, __eq__
# You just declare the fields — no boilerplate!

@dataclass
class Point:
    x: float       # type hint required!
    y: float
    z: float = 0.0  # default value

p = Point(1.0, 2.0)
print(p)            # Point(x=1.0, y=2.0, z=0.0) — __repr__ auto-generated
print(p.x, p.y)     # 1.0, 2.0 — attributes work normally

p2 = Point(1.0, 2.0)
print(p == p2)      # True — __eq__ auto-generated (compares all fields)

# Frozen dataclass — immutable (like a named tuple with types)
@dataclass(frozen=True)
class Color:
    r: int
    g: int
    b: int

red = Color(255, 0, 0)
# red.r = 100  ← FrozenInstanceError! Can't modify frozen dataclass

# Dataclass with methods
@dataclass
class Student:
    name: str
    grades: list = field(default_factory=list)  # ← correct way to have mutable default

    def average(self) -> float:
        return sum(self.grades) / len(self.grades) if self.grades else 0.0

alice = Student("Alice")
alice.grades.extend([95, 87, 92])
print(f"{alice.name}'s average: {alice.average():.1f}")

# ── LIST COMPREHENSION ─────────────────────────────────────────
# [expression for item in iterable if condition]

# All in one line — more readable once you know the pattern
squares = [x**2 for x in range(10)]
evens   = [x for x in range(20) if x % 2 == 0]

# Conditional expression inside (ternary in comprehension)
labeled = ["even" if x % 2 == 0 else "odd" for x in range(6)]
print(labeled)   # ['even', 'odd', 'even', 'odd', 'even', 'odd']

# Nested comprehension — flatten a 2D list
matrix = [[1,2],[3,4],[5,6]]
flat = [n for row in matrix for n in row]
print(flat)      # [1, 2, 3, 4, 5, 6]

# ── DICT COMPREHENSION ─────────────────────────────────────────
# {key_expr: val_expr for item in iterable if condition}

# Word length mapping
words = ["python", "is", "great"]
lengths = {word: len(word) for word in words}
print(lengths)   # {'python': 6, 'is': 2, 'great': 5}

# Filter while building
scores = {"Alice": 92, "Bob": 68, "Charlie": 85}
passing = {name: score for name, score in scores.items() if score >= 80}
print(passing)   # {'Alice': 92, 'Charlie': 85}

# ── SET COMPREHENSION ──────────────────────────────────────────
# {expression for item in iterable}

# Unique word lengths
sentence = "the quick brown fox jumps over the lazy dog"
unique_lengths = {len(word) for word in sentence.split()}
print(unique_lengths)   # {3, 4, 5} (unordered, unique)

# When NOT to use comprehensions:
# If the logic is complex, use a regular loop — readability wins!
# BAD — too complex to read quickly:
result = [str(x**2) for x in range(100) if x % 3 == 0 if x % 5 == 0 if x < 50]
# Better: write a regular loop with comments

# List comprehension: creates ALL values in memory at once
squares_list = [x**2 for x in range(1_000_000)]  # ~8MB of memory

# Generator expression: produces values ONE AT A TIME (lazy evaluation)
# Same syntax as list comprehension but with () instead of []
squares_gen = (x**2 for x in range(1_000_000))    # ~200 bytes!

# You can iterate over it just like a list
for sq in squares_gen:
    if sq > 100:
        break   # only generated values up to this point

# Generators work great with sum(), max(), any(), all()
total = sum(x**2 for x in range(100))   # no intermediate list created!
has_negative = any(x < 0 for x in [1, -2, 3])   # stops as soon as it finds -2

# ── GENERATOR FUNCTIONS (using yield) ─────────────────────────
# 'yield' is like 'return' but pauses the function instead of ending it
# Each time next() is called, execution resumes from after the yield

def count_up(start, step=1):
    """Generate integers starting from 'start', incrementing by 'step'."""
    current = start
    while True:           # infinite generator — only generates when asked
        yield current      # pause here and send 'current' to the caller
        current += step    # then resume from here on next call

gen = count_up(10, 5)
print(next(gen))   # 10 — get first value
print(next(gen))   # 15
print(next(gen))   # 20
# Generator remembers its state between calls!

# Practical generator: reading a huge file line by line
def read_large_file(filepath):
    """Read file without loading it all into memory."""
    with open(filepath, "r") as f:
        for line in f:
            yield line.strip()   # yield one line at a time

# The file is read one line at a time — works for 100GB files!
for line in read_large_file("huge_data.txt"):
    process(line)   # handle one line, then discard it

import time
from functools import wraps

# ── HOW DECORATORS WORK ────────────────────────────────────────
# A decorator is a function that takes a function and returns a function

def timer(func):                      # 'func' is the function being decorated
    @wraps(func)                       # preserves original function's metadata
    def wrapper(*args, **kwargs):      # wrapper captures all arguments
        start = time.time()           # do something BEFORE
        result = func(*args, **kwargs) # call the original function
        end = time.time()             # do something AFTER
        print(f"{func.__name__} took {end - start:.4f}s")
        return result                  # return the original result
    return wrapper                     # return the wrapper, not the result

# Apply with @ syntax — this is just syntactic sugar for:
# slow_function = timer(slow_function)
@timer
def slow_function(n):
    """Sleep for n seconds."""
    time.sleep(n)
    return f"Done sleeping for {n}s"

result = slow_function(1)   # slow_function took 1.0002s
print(result)                # Done sleeping for 1s

# ── DECORATOR WITH ARGUMENTS ───────────────────────────────────
def retry(max_attempts=3):            # outer function takes decorator args
    def decorator(func):               # middle function takes the function
        @wraps(func)
        def wrapper(*args, **kwargs):  # inner function runs the logic
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"Attempt {attempt+1} failed: {e}")
                    if attempt + 1 == max_attempts:
                        raise
        return wrapper
    return decorator

@retry(max_attempts=3)
def flaky_function():
    import random
    if random.random() < 0.7:  # fails 70% of the time
        raise ConnectionError("Network error")
    return "Success!"

# ── BUILT-IN DECORATORS ────────────────────────────────────────
class Circle:
    def __init__(self, radius):
        self._radius = radius   # _ prefix = "private by convention"

    # @property: access a method like an attribute (no parentheses)
    @property
    def radius(self):
        return self._radius

    # @radius.setter: called when you set circle.radius = value
    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    @property
    def area(self):
        import math
        return math.pi * self._radius ** 2

    # @staticmethod: belongs to class but doesn't need self or cls
    @staticmethod
    def is_valid_radius(r):
        return r > 0

    # @classmethod: alternative constructor, gets class as first arg (cls)
    @classmethod
    def from_diameter(cls, diameter):
        return cls(diameter / 2)

c = Circle(5)
print(c.radius)     # 5 — property accessed like attribute
print(c.area)       # 78.54 — computed on the fly
c.radius = 10       # calls the setter
# c.radius = -1     ← ValueError!

c2 = Circle.from_diameter(20)   # alternative constructor
print(c2.radius)    # 10.0
print(Circle.is_valid_radius(5))  # True — no instance needed

# Class-based context manager
# __enter__: called at the start of the 'with' block
# __exit__: called at the end, even if an error occurs

class Timer:
    """Context manager that measures elapsed time."""

    def __enter__(self):
        self.start = time.time()
        return self          # 'as' clause receives this return value

    def __exit__(self, exc_type, exc_val, exc_tb):
        # exc_type, exc_val, exc_tb = exception info (None if no error)
        self.elapsed = time.time() - self.start
        print(f"Elapsed: {self.elapsed:.4f}s")
        return False        # False = don't suppress exceptions

with Timer() as t:           # t = what __enter__ returned (self)
    time.sleep(0.5)
    print(f"Mid-way, elapsed so far: {time.time() - t.start:.2f}s")
# __exit__ called here: Elapsed: 0.5001s

# ── contextlib: easier context managers ───────────────────────
from contextlib import contextmanager

@contextmanager
def managed_resource(name):
    print(f"Setting up {name}")     # runs BEFORE the with block
    try:
        yield name                   # pause here — this is the 'with' block
    finally:
        print(f"Cleaning up {name}")  # runs AFTER, even on error

with managed_resource("database") as resource:
    print(f"Using {resource}")
# Output:
# Setting up database
# Using database
# Cleaning up database

# Multiple context managers in one with statement (Python 3.10+)
with open("input.txt") as infile, open("output.txt", "w") as outfile:
    outfile.write(infile.read().upper())

import itertools

# ── chain() — flatten multiple iterables into one ──────────────
letters = ["a", "b"]
numbers = [1, 2, 3]
symbols = ("!", "?")

for item in itertools.chain(letters, numbers, symbols):
    print(item, end=" ")      # a b 1 2 3 ! ?

# vs the naive approach: for item in letters + numbers + list(symbols) ...
# chain() doesn't build a new list — saves memory on large collections

# ── product() — Cartesian product (replaces nested for loops) ──
sizes = ["S", "M", "L"]
colors = ["red", "blue"]

# Naive approach with nested loop:
# for size in sizes:
#     for color in colors: print(size, color)

# With product:
for size, color in itertools.product(sizes, colors):
    print(f"{size}-{color}")
# S-red, S-blue, M-red, M-blue, L-red, L-blue

# ── groupby() — group consecutive items by a key ───────────────
# IMPORTANT: data must be sorted by the key first!
data = [
    {"name": "Alice", "dept": "Eng"},
    {"name": "Bob",   "dept": "Eng"},
    {"name": "Carol", "dept": "HR"},
    {"name": "Dave",  "dept": "HR"},
]
data.sort(key=lambda x: x["dept"])  # sort first!
for dept, members in itertools.groupby(data, key=lambda x: x["dept"]):
    names = [m["name"] for m in members]
    print(f"{dept}: {names}")
# Eng: ['Alice', 'Bob']
# HR: ['Carol', 'Dave']

# ── islice() — lazy slicing of any iterable ────────────────────
# Useful when you can't use [start:stop] (e.g., on a generator)
def infinite_counter():
    n = 0
    while True:
        yield n
        n += 1

first_10 = list(itertools.islice(infinite_counter(), 10))
print(first_10)   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# ── combinations() & permutations() ───────────────────────────
items = ["A", "B", "C"]
print(list(itertools.combinations(items, 2)))
# [('A','B'), ('A','C'), ('B','C')] — order doesn't matter

print(list(itertools.permutations(items, 2)))
# [('A','B'), ('A','C'), ('B','A'), ('B','C'), ...] — order matters

from functools import lru_cache, cache, partial, reduce, wraps

# ── @lru_cache — memoization in one decorator ──────────────────
# PROBLEM: recursive fibonacci recomputes the same values millions of times
# APPROACH: cache results — if we've seen inputs before, return cached result

# Without cache — exponential time O(2^n)
def fib_slow(n):
    if n < 2: return n
    return fib_slow(n-1) + fib_slow(n-2)

# With lru_cache — linear time O(n)
@lru_cache(maxsize=None)   # cache unlimited results
def fib_fast(n):
    if n < 2: return n
    return fib_fast(n-1) + fib_fast(n-2)

print(fib_fast(50))   # instant! fib_slow(50) would take minutes
print(fib_fast.cache_info())   # CacheInfo(hits=48, misses=51, ...)

# @cache is a simpler alias for @lru_cache(maxsize=None)
@cache   # Python 3.9+
def expensive_computation(n):
    return n ** 2

# ── partial() — pre-fill function arguments ────────────────────
# Creates a new function with some arguments already filled in
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)   # exponent always 2
cube   = partial(power, exponent=3)   # exponent always 3

print(square(5))   # 25
print(cube(3))     # 27

# Useful with sorted(): pre-fill the key function
data = ["banana", "apple", "Cherry", "date"]
sort_ci = partial(sorted, key=str.lower)  # case-insensitive sort
print(sort_ci(data))   # ['apple', 'banana', 'Cherry', 'date']

# ── @wraps — every decorator MUST use this ─────────────────────
# Without @wraps, decorators destroy the function's metadata
def timer_bad(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper   # wrapper.__name__ = "wrapper" — WRONG!

def timer_good(func):
    @wraps(func)     # copies __name__, __doc__, __annotations__ from func
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper   # wrapper.__name__ = func.__name__ — correct!

@timer_good
def calculate(x):
    """Squares x."""
    return x ** 2

print(calculate.__name__)  # "calculate" — preserved by @wraps
print(calculate.__doc__)   # "Squares x." — preserved by @wraps

# ── reduce() — fold a sequence into a single value ─────────────
from functools import reduce
import operator

numbers = [1, 2, 3, 4, 5]
total = reduce(operator.add, numbers)    # 15 — same as sum(numbers)
product = reduce(operator.mul, numbers)  # 120 — 1*2*3*4*5

# Generally: prefer sum(), max(), min() over reduce() when possible
# Use reduce() for operations that don't have a built-in equivalent

pip install pandas

import pandas as pd  # 'pd' is the universal alias
import numpy as np

# ── SERIES — a labeled 1D array (like a column) ────────────────
temps = pd.Series([72, 75, 68, 80, 79],
                   index=["Mon", "Tue", "Wed", "Thu", "Fri"])
print(temps)
print(temps["Wed"])      # 68 — access by label
print(temps.mean())      # 74.8
print(temps[temps > 74]) # filter: only days above 74

# ── DATAFRAME — a 2D table ─────────────────────────────────────
# Create from a dict of lists (each list = one column)
data = {
    "name":   ["Alice", "Bob", "Charlie", "Diana", "Eve"],
    "dept":   ["Eng", "Mktg", "Eng", "HR", "Eng"],
    "salary": [95000, 72000, 105000, 68000, 98000],
    "years":  [3, 5, 7, 2, 4],
}
df = pd.DataFrame(data)
print(df)
print(df.head(3))        # first 3 rows
print(df.tail(2))        # last 2 rows
print(df.shape)          # (5, 4) — rows, columns
print(df.dtypes)         # data type of each column
print(df.describe())     # statistics: mean, std, min, max...
print(df.info())          # column types, null counts, memory

# ── READING/WRITING CSV ────────────────────────────────────────
df.to_csv("employees.csv", index=False)  # save to CSV
df2 = pd.read_csv("employees.csv")         # read from CSV
df2 = pd.read_csv("employees.csv",
                  dtype={"salary": float},  # specify column types
                  na_values=["N/A", "-"])    # what counts as missing

# Reading Excel
# df_excel = pd.read_excel("data.xlsx", sheet_name="Sheet1")

# ── SELECTING DATA ─────────────────────────────────────────────
# Single column (returns Series)
print(df["name"])

# Multiple columns (returns DataFrame)
print(df[["name", "salary"]])

# By position: iloc[rows, columns]
print(df.iloc[0])           # first row (as Series)
print(df.iloc[1:3])         # rows 1-2
print(df.iloc[0, 2])        # row 0, column 2 → 95000

# By label: loc[rows, columns]
print(df.loc[0, "salary"])  # row with index 0, "salary" column

# ── FILTERING ─────────────────────────────────────────────────
# Boolean mask — condition returns a Series of True/False
engineers = df[df["dept"] == "Eng"]
print(engineers)

# Multiple conditions — must use & (and) | (or), not 'and'/'or'
senior_eng = df[(df["dept"] == "Eng") & (df["years"] >= 4)]
print(senior_eng)

high_salary = df[df["salary"] > 90000]
print(high_salary["name"])  # just the names column

# .isin() — match any value in a list
tech_depts = df[df["dept"].isin(["Eng", "IT"])]

# .str accessor for string operations on columns
df["name_upper"] = df["name"].str.upper()
df["name_length"] = df["name"].str.len()

# ── GROUPBY — split-apply-combine ─────────────────────────────
# GroupBy is one of the most powerful pandas features
# "Group by dept, then calculate the mean salary for each group"

dept_stats = df.groupby("dept")["salary"].agg(["mean", "min", "max", "count"])
print(dept_stats)

# Group by multiple columns
# df.groupby(["dept", "seniority"])["salary"].mean()

# ── MERGE (SQL-style JOIN) ─────────────────────────────────────
projects = pd.DataFrame({
    "name": ["Alice", "Bob", "Alice"],
    "project": ["Alpha", "Beta", "Gamma"]
})
merged = pd.merge(df, projects, on="name", how="left")  # left join
print(merged)

# ── APPLY — custom function on each row/column ────────────────
def grade_salary(salary):
    if salary >= 100000: return "Senior"
    if salary >= 80000:  return "Mid"
    return "Junior"

df["level"] = df["salary"].apply(grade_salary)  # apply to each row in column
print(df[["name", "salary", "level"]])

# ── PIVOT TABLE ────────────────────────────────────────────────
pivot = df.pivot_table(values="salary", index="dept", aggfunc="mean")
print(pivot)

# ── HANDLING MISSING VALUES ────────────────────────────────────
df_with_nulls = pd.DataFrame({"a": [1, None, 3], "b": [4, 5, None]})
print(df_with_nulls.isnull())          # True where value is missing
print(df_with_nulls.isnull().sum())    # count missing per column
df_dropped = df_with_nulls.dropna()    # remove rows with ANY null
df_filled = df_with_nulls.fillna(0)   # replace null with 0
df_filled2 = df_with_nulls.fillna(df_with_nulls.mean())  # fill with column mean

import numpy as np

# ── CREATING ARRAYS ────────────────────────────────────────────
a = np.array([1, 2, 3, 4, 5])       # from a Python list
b = np.array([[1,2,3],[4,5,6]])    # 2D array (matrix)

print(a.shape)    # (5,)    — 1D array with 5 elements
print(b.shape)    # (2, 3)  — 2 rows, 3 columns
print(b.ndim)     # 2       — number of dimensions
print(b.dtype)    # int64   — data type
print(b.size)     # 6       — total number of elements

# Common array creation functions
zeros = np.zeros((3, 4))           # 3x4 array of zeros
ones  = np.ones((2, 3))            # 2x3 array of ones
eye   = np.eye(4)                   # 4x4 identity matrix
rng   = np.arange(0, 10, 2)         # [0, 2, 4, 6, 8] — like range() but returns array
lin   = np.linspace(0, 1, 5)         # 5 evenly spaced from 0 to 1: [0, 0.25, 0.5, 0.75, 1]
rand  = np.random.rand(3, 3)         # 3x3 random floats [0, 1)
randn = np.random.randn(100)         # 100 values from normal distribution

# ── VECTORIZED OPERATIONS — no loops needed! ───────────────────
# Operations apply to ALL elements at once — much faster than Python loops

prices = np.array([10.0, 20.0, 30.0, 40.0])
tax_rate = 0.08

# No loop needed — operates on entire array
prices_with_tax = prices * (1 + tax_rate)
print(prices_with_tax)   # [10.8, 21.6, 32.4, 43.2]

discounted = prices - 5           # subtract 5 from each
doubled = prices * 2              # multiply each by 2
squared = prices ** 2             # square each

# Math functions that work element-wise
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)               # sin of every element
y2 = np.exp(np.array([1, 2, 3]))  # [e^1, e^2, e^3]

# ── BROADCASTING — operations between different-shaped arrays ──
# numpy auto-expands smaller array to match larger
matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])
row = np.array([10, 20, 30])     # shape (3,)

result = matrix + row              # row broadcasts to match matrix
print(result)
# [[11, 22, 33],
#  [14, 25, 36],
#  [17, 28, 39]]

# ── ARRAY MATH AND STATISTICS ──────────────────────────────────
data = np.random.randn(1000)    # 1000 random numbers
print(np.mean(data))             # mean (≈ 0 for standard normal)
print(np.std(data))              # standard deviation (≈ 1)
print(np.min(data), np.max(data))
print(np.percentile(data, [25, 50, 75]))  # quartiles
print(np.sum(data))
print(np.cumsum(np.array([1,2,3,4])))   # [1, 3, 6, 10] cumulative sum

# ── INDEXING AND SLICING ───────────────────────────────────────
arr = np.arange(12).reshape(3, 4)  # reshape 1D to 3x4 matrix
print(arr)
print(arr[1, 2])        # row 1, col 2 → 6
print(arr[0, :])        # entire first row
print(arr[:, 1])        # entire second column
print(arr[1:, 2:])      # bottom-right 2x2 block

# Boolean indexing — filter with a condition
print(arr[arr > 6])     # only values > 6

# ── WHY IS NUMPY FASTER THAN LISTS? ───────────────────────────
# Python lists store objects (with overhead). numpy stores raw numbers.
# Operations use optimized C/Fortran code under the hood.
# For 1 million elements:
# Python loop:      ~100ms
# numpy vectorized: ~1ms  (100x faster!)

import time
n = 1_000_000

# Python list approach
py_list = list(range(n))
start = time.time()
result = [x**2 for x in py_list]
print(f"Python: {time.time() - start:.3f}s")

# numpy approach
np_arr = np.arange(n)
start = time.time()
result = np_arr ** 2
print(f"numpy:  {time.time() - start:.3f}s")  # ~50-100x faster!

import requests

# ── GET REQUEST — fetch data ───────────────────────────────────
response = requests.get("https://api.github.com")

# Response object properties
print(response.status_code)    # 200 = success, 404 = not found, 500 = server error
print(response.ok)             # True if status_code < 400
print(response.headers)       # response headers dict
print(response.text)           # response body as string
data = response.json()         # parse JSON body → Python dict
print(data)

# GET with query parameters (URL: ?page=1&per_page=5)
params = {"page": 1, "per_page": 5}
response = requests.get(
    "https://api.github.com/repos/python/cpython/issues",
    params=params    # requests builds the query string for you
)
issues = response.json()
for issue in issues:
    print(f"#{issue['number']}: {issue['title']}")

# ── POST REQUEST — send data ───────────────────────────────────
# Sending form data
response = requests.post(
    "https://httpbin.org/post",   # test endpoint that echoes back what you send
    data={"username": "alice", "password": "secret"}
)

# Sending JSON
response = requests.post(
    "https://httpbin.org/post",
    json={"user": "alice", "score": 100}  # auto-sets Content-Type: application/json
)
print(response.json())

# ── HEADERS — authentication, content type ────────────────────
headers = {
    "Authorization": "Bearer YOUR_API_TOKEN_HERE",
    "Accept": "application/json",
    "User-Agent": "MyApp/1.0"
}
response = requests.get("https://api.example.com/data", headers=headers)

# ── ERROR HANDLING ─────────────────────────────────────────────
def safe_request(url, **kwargs):
    """Make a GET request with proper error handling."""
    try:
        response = requests.get(url, timeout=10, **kwargs)  # timeout in seconds
        response.raise_for_status()   # raises HTTPError for 4xx/5xx responses
        return response.json()

    except requests.exceptions.Timeout:
        print("Request timed out")
    except requests.exceptions.ConnectionError:
        print("No internet connection")
    except requests.exceptions.HTTPError as e:
        print(f"HTTP Error: {e.response.status_code}")
    except requests.exceptions.JSONDecodeError:
        print("Response was not valid JSON")
    return None

# ── SESSION — reuse connection and headers ─────────────────────
# Sessions are more efficient for multiple requests to the same host
with requests.Session() as session:
    session.headers["Authorization"] = "Bearer TOKEN"  # set once, used for all
    session.headers["Accept"] = "application/json"

    r1 = session.get("https://api.example.com/users")
    r2 = session.get("https://api.example.com/posts")
    # both use the same headers and connection pool

# ── OTHER METHODS ──────────────────────────────────────────────
# requests.put(url, json=data)     — update a resource
# requests.patch(url, json=data)   — partial update
# requests.delete(url)             — delete a resource
# requests.head(url)               — get headers only (no body)

pip install matplotlib seaborn

import matplotlib.pyplot as plt    # 'plt' is the universal alias
import seaborn as sns               # 'sns' is the universal alias
import numpy as np
import pandas as pd

# ── LINE CHART ─────────────────────────────────────────────────
x = np.linspace(0, 2*np.pi, 100)  # 100 points from 0 to 2π

plt.figure(figsize=(10, 4))        # create figure: 10 wide, 4 tall (inches)
plt.plot(x, np.sin(x), label="sin(x)", color="blue", linewidth=2)
plt.plot(x, np.cos(x), label="cos(x)", color="red", linestyle="--")
plt.title("Sine and Cosine", fontsize=14)
plt.xlabel("x")
plt.ylabel("y")
plt.legend()                         # show legend with labels
plt.grid(True, alpha=0.3)           # light grid lines
plt.tight_layout()                    # auto-adjust spacing
plt.savefig("sine_cosine.png", dpi=150)  # save to file
plt.show()                            # display (blocks until window closed)

# ── BAR CHART ──────────────────────────────────────────────────
categories = ["Engineering", "Marketing", "HR", "Finance"]
values = [95000, 72000, 68000, 85000]
colors = ["#1a4a8c", "#2e6dbf", "#a8c4e8", "#0f2d5a"]

plt.figure(figsize=(8, 5))
bars = plt.bar(categories, values, color=colors, edgecolor="white", linewidth=1.5)
plt.title("Average Salary by Department")
plt.ylabel("Salary ($)")
# Add value labels on top of each bar
for bar, val in zip(bars, values):
    plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 500,
             f"${val:,}", ha="center", va="bottom", fontweight="bold")
plt.tight_layout()
plt.show()

# ── SCATTER PLOT ───────────────────────────────────────────────
n = 100
x = np.random.randn(n)
y = 2 * x + np.random.randn(n)    # linear relationship with noise
colors_scatter = np.abs(y)           # color by y value

plt.figure(figsize=(7, 6))
scatter = plt.scatter(x, y, c=colors_scatter, cmap="Blues", alpha=0.7)
plt.colorbar(scatter, label="|y|")  # add color legend
plt.title("Scatter Plot with Color Mapping")
plt.show()

# ── SUBPLOTS — multiple plots in one figure ────────────────────
fig, axes = plt.subplots(2, 2, figsize=(12, 8))  # 2x2 grid of plots
fig.suptitle("Dashboard", fontsize=16)

axes[0,0].plot([1,2,3,4], [1,4,2,3])
axes[0,0].set_title("Line")

axes[0,1].bar(["A","B","C"], [3,7,2], color="#1a4a8c")
axes[0,1].set_title("Bar")

axes[1,0].scatter(np.random.randn(50), np.random.randn(50))
axes[1,0].set_title("Scatter")

axes[1,1].hist(np.random.randn(500), bins=20, color="#2e6dbf")
axes[1,1].set_title("Histogram")

plt.tight_layout()
plt.show()

# ── SEABORN — prettier, higher-level plots ─────────────────────
sns.set_theme(style="whitegrid")    # set a nice default theme

# Sample dataset
df = pd.DataFrame({
    "dept":   ["Eng","Eng","Mktg","Mktg","HR"]*10,
    "salary": np.random.normal([95000,95000,72000,72000,68000]*10, 5000)
})

# Box plot — distribution by category
plt.figure(figsize=(8, 5))
sns.boxplot(data=df, x="dept", y="salary", palette="Blues")
plt.title("Salary Distribution by Department")
plt.show()

# Heatmap — great for correlation matrices
corr_data = pd.DataFrame(np.random.randn(100, 4),
                           columns=["Revenue","Costs","Profit","Growth"])
plt.figure(figsize=(7, 6))
sns.heatmap(corr_data.corr(), annot=True, fmt=".2f",
            cmap="Blues", vmin=-1, vmax=1, center=0)
plt.title("Correlation Matrix")
plt.tight_layout()
plt.show()

# ── Variable annotations ───────────────────────────────────────
name: str = "Alice"
age: int = 25
score: float = 98.6
is_active: bool = True

# You can annotate without assigning (declares intent)
user_id: int   # not yet assigned, but tools know it must be int

# ── Function annotations ──────────────────────────────────────
def greet(name: str, times: int = 1) -> str:
    """Return greeting repeated `times` times."""
    return (name + "!") * times

def log_message(msg: str) -> None:  # -> None = returns nothing
    print(f"[LOG] {msg}")

# ── Collection annotations ─────────────────────────────────────
# Python 3.9+: use built-in types directly
scores: list[int] = [95, 87, 91]
lookup: dict[str, int] = {"alice": 1, "bob": 2}
coords: tuple[float, float] = (51.5, -0.1)
unique: set[str] = {"python", "rust"}

# Python 3.7-3.8: must import from typing
from typing import List, Dict, Tuple, Set
scores_old: List[int] = [95, 87, 91]  # same, older syntax

# Nested collections
matrix: list[list[float]] = [[1.0, 0.0], [0.0, 1.0]]
users: list[dict[str, str]] = [{"name": "Alice"}, {"name": "Bob"}]

# ── Typed class ───────────────────────────────────────────────
class User:
    name: str
    age: int
    email: str

    def __init__(self, name: str, age: int, email: str) -> None:
        self.name = name
        self.age = age
        self.email = email

    def greet(self) -> str:
        return f"Hi, I'm {self.name}"

from typing import Optional, Union, Any, Callable, TypeVar

# ── Optional — value can be the type OR None ───────────────────
# Use when a function might return nothing
def find_user(user_id: int) -> Optional[str]:  # returns str or None
    users = {1: "Alice", 2: "Bob"}
    return users.get(user_id)   # returns None if not found

# Python 3.10+ shorthand: str | None (no import needed!)
def find_user_modern(user_id: int) -> str | None:  # 3.10+ syntax
    users = {1: "Alice"}
    return users.get(user_id)

# ── Union — value can be one of several types ──────────────────
def process(value: Union[int, str]) -> str:
    return str(value)

# Python 3.10+: int | str  (much cleaner!)
def process_modern(value: int | str) -> str:
    return str(value)

# ── Any — escape hatch (use sparingly!) ───────────────────────
from typing import Any
def flexible(data: Any) -> Any:   # turns off type checking for this function
    return data

# ── Callable — annotating functions that take functions ────────
from typing import Callable
def apply_twice(func: Callable[[int], int], x: int) -> int:
    # func: a callable that takes int → returns int
    return func(func(x))

apply_twice(lambda n: n * 2, 3)   # 12 (3 → 6 → 12)

# ── TypedDict — typed structure for dict data ──────────────────
from typing import TypedDict

class MovieRecord(TypedDict):
    title: str
    year: int
    rating: float

# mypy now knows exactly what fields a MovieRecord has
movie: MovieRecord = {"title": "Inception", "year": 2010, "rating": 8.8}

# ── Literal — restrict to specific values ─────────────────────
from typing import Literal
def set_direction(direction: Literal["left", "right", "up", "down"]) -> None:
    print(f"Moving {direction}")
# mypy error if you pass "diagonal" — only the 4 literals allowed

# Install mypy
pip install mypy

# Check a single file
mypy script.py

# Check an entire package
mypy src/

# Strict mode — catches more issues
mypy --strict script.py

# Common useful flags
mypy --ignore-missing-imports script.py  # suppress errors for untyped 3rd-party libs
mypy --show-error-codes script.py        # show error codes (e.g., [arg-type])

# Example mypy errors and what they mean:

# script.py:12: error: Argument 1 to "greet" has incompatible type "int";
#   expected "str"  [arg-type]
# → You passed an int where a str was expected on line 12

# script.py:18: error: Item "None" of "Optional[str]" has no attribute "upper"
#   [union-attr]
# → You called .upper() on something that might be None — add a None check!

# script.py:25: error: Return type declared as "str" but return statement
#   returns "int"  [return-value]
# → Your function signature says -> str but you returned an int

# Suppressing a specific line when you KNOW it's safe:
result = some_api_call()  # type: ignore[return-value]
# Use sparingly — prefer fixing the underlying type issue

# mypy config in pyproject.toml or mypy.ini
# [mypy]
# strict = true
# ignore_missing_imports = true

# ── PYTHONIC PATTERNS ──────────────────────────────────────────

# ❌ C-style loop  ✅ Direct iteration
for i in range(len(items)): print(items[i])   # bad
for item in items: print(item)                   # good

# ❌ Verbose swap  ✅ Tuple swap
temp = a; a = b; b = temp    # bad
a, b = b, a                   # good — Pythonic one-liner

# ❌ Checking empty list  ✅ Truth value
if len(items) > 0: ...       # bad
if items: ...                  # good

# ❌ Dict get with KeyError risk  ✅ .get() with default
val = d[k] if k in d else "default"  # verbose
val = d.get(k, "default")                # clean

# ❌ String concat in loop (O(n²))  ✅ join
result = ""
for w in words: result += w + ", "    # very slow
result = ", ".join(words)               # fast and clean

# ❌ Counting with a loop  ✅ Counter
from collections import Counter
counts = Counter(words)   # instant, no loop needed

# ❌ Building a dict with a loop  ✅ Dict comprehension
lengths = {w: len(w) for w in words}

# ✅ Use enumerate for index + value
for i, item in enumerate(items, 1):
    print(f"{i}. {item}")

# ✅ Unpack meaningfully (don't use index[0], index[1])
first, *rest = items
name, age, city = user_tuple

# ✅ Use walrus := to assign and test in one step
if (n := len(data)) > 10:
    print(f"Large dataset: {n} items")

# ✅ "Ask forgiveness" (EAFP) rather than "look before you leap" (LBYL)
# LBYL style:
if "key" in my_dict:
    val = my_dict["key"]
# EAFP style (more Pythonic):
try:
    val = my_dict["key"]
except KeyError:
    val = None