>>> 1 + 1
2

name = "Python"
print(name)

# This line never runs
x = 10  # End-of-line comments work too

Setup ──► Syntax ──► Data structures ──► Functions ──► OOP ──► Advanced ──► Engineering
Ch 1-3     Ch 4-7        Ch 8-10          Ch 11-13    Ch 16-18   Ch 19-24    Ch 25-28
                             │
                             └──► Exceptions / files (Ch 14-15)

for i in range(1, 6):
    print(i)

python3 --version

brew install python

winget install Python.Python.3.14

sudo apt update && sudo apt install python3 python3-pip python3-venv

# Install uv (macOS/Linux)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install Python with uv
uv python install 3.14

Python 3.14.x (main, ...) [...]
Type "help", "copyright", "credits" or "license" for more information.
>>>

>>> 2 + 3
5
>>> "hello".upper()
'HELLO'

python3 hello.py

$ python3
>>> 2 ** 100
1267650600228229401496703205376
>>> exit()

$ cat first.py
print("Python is installed")
$ python3 first.py
Python is installed

print("Hello, World!")

Hello, World!

print("a", "b", "c")          # a b c   — multiple args joined by spaces
print("a", "b", sep="-")      # a-b     — custom separator
print("no newline", end="")   # suppress the trailing newline
print()                       # print a blank line

name = input("What's your name? ")
print("Hello, " + name)

What's your name? Alice
Hello, Alice

age = input("Age: ")   # user types 18
print(age + 1)         # TypeError: can only concatenate str (not "int") to str

age = int(input("Age: "))
print(age + 1)   # 19

# A single-line comment

x = 1  # An end-of-line comment

# Multi-line comments are just multiple #
# lines, like this

"""
Syntactically these lines are a string.
It isn't assigned to anything, so the effect is a comment.
Placed at the top of a function/class/module it has special meaning (a docstring).
"""

# ❌ Useless — the code already says this
count = count + 1  # add one to count

# ✅ Useful — explains intent you can't read off the code
count += 1  # server counts from 1, client from 0; compensate for the offset

if 5 > 3:
    print("this line is inside the if")
    print("so is this one")
print("this one is outside; it always runs")

# bmi.py — body mass index
# Categories below use the WHO standard for adults:
# underweight <18.5, normal 18.5-24.9, overweight 25.0-29.9, obese >=30
# Note some countries use different cutoffs (e.g. China's WS/T 428:
# overweight >=24, obese >=28)

print("=== BMI Calculator ===")

height = float(input("Height in meters (e.g. 1.75): "))
weight = float(input("Weight in kg: "))

bmi = weight / (height ** 2)

print(f"Your BMI is {bmi:.1f}")

if bmi < 18.5:
    print("Underweight")
elif bmi < 25:
    print("Normal")
elif bmi < 30:
    print("Overweight")
else:
    print("Obese")

=== BMI Calculator ===
Height in meters (e.g. 1.75): 1.75
Weight in kg: 70
Your BMI is 22.9
Normal

print("Enter two numbers")
a = input()
b = input()
print("Sum:", a + b)

name = input("Your name: ")
age = int(input("Your age: "))
print(f"Hi {name}, next year you'll be {age + 1}")

celsius = float(input("Celsius: "))
fahrenheit = celsius * 9 / 5 + 32
print(f"{celsius}°C = {fahrenheit}°F")

print("Enter two numbers")
a = float(input())
b = float(input())
print("Sum:", a + b)

x = 10
message = "hello"
pi = 3.14159

x = 10        # x is an integer
x = "hello"   # x is a string now — perfectly legal

user_name = "Alice"     # ✅ variables/functions: lowercase with underscores (snake_case)
MAX_RETRY = 3           # ✅ constants: ALL_CAPS
class UserProfile:      # ✅ classes: PascalCase
_internal = 1           # ✅ leading underscore: "internal, don't touch"

userName = "Alice"      # ❌ that's Java/JS style, not Python
l = 1                   # ❌ lowercase l is hard to tell from digit 1
list = [1, 2]           # ❌ shadows the built-in list

>>> import keyword
>>> keyword.kwlist          # hard keywords: never usable as names
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break',
 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal',
 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

>>> keyword.softkwlist      # soft keywords: special only in specific syntax
['_', 'case', 'match', 'type']

>>> type(42)
<class 'int'>
>>> type(3.14)
<class 'float'>
>>> type("hi")
<class 'str'>
>>> type(True)
<class 'bool'>

a = 42
b = -17
c = 1_000_000     # underscores as digit separators; purely visual, value is 1000000

# Other bases
binary = 0b1010   # binary  → 10
octal = 0o17      # octal   → 15
hexa = 0xFF       # hex     → 255

>>> 2 ** 1000
10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

x = 3.14
y = -0.001
z = 2.5e3      # scientific notation = 2500.0
w = 1e-4       # = 0.0001

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False

# Option 1: compare with tolerance
import math
math.isclose(0.1 + 0.2, 0.3)   # True

# Option 2: for money and anything needing exactness, use Decimal
from decimal import Decimal
Decimal("0.1") + Decimal("0.2")    # Decimal('0.3')  ✅

# Option 3: for fractions, use Fraction
from fractions import Fraction
Fraction(1, 3) + Fraction(1, 6)    # Fraction(1, 2)

is_ready = True
is_done = False

>>> True + True
2
>>> sum([True, False, True])   # count the Trues
2

False, None, 0, 0.0, 0j, "", [], (), {}, set(), range(0)

if []:
    print("won't run")     # empty list is falsy

if [0]:
    print("will run")      # non-empty list is truthy, even holding a 0

if "False":
    print("will run")      # a non-empty string is always truthy!

result = None

def f():
    print("hi")

x = f()       # prints hi
print(x)      # None — no return statement, so None is returned

if x is None:        # ✅
if x is not None:    # ✅
if x == None:        # ❌ works but isn't idiomatic, and custom classes may override ==

int("42")        # 42       string → int
int(3.99)        # 3        truncates, does NOT round!
int("0b101", 2)  # 5        specify a base
float("3.14")    # 3.14
float(7)         # 7.0
str(42)          # "42"
bool(0)          # False
bool("hi")       # True

round(3.99)        # 4
round(3.14159, 2)  # 3.14

>>> round(0.5)
0
>>> round(1.5)
2
>>> round(2.5)
2

>>> int("abc")
ValueError: invalid literal for int() with base 10: 'abc'

>>> "3" + 5
TypeError: can only concatenate str (not "int") to str

bool("")
bool(" ")
bool([])
bool([[]])
int(-3.7)
round(-3.5)
True + 1
type(1 / 1)

_x    2fast    my-var    myVar    class    Class    données    __init__

bool("")      # False — empty string
bool(" ")     # True  — one space, non-empty
bool([])      # False — empty list
bool([[]])    # True  — one element (which happens to be an empty list, but that's irrelevant)
int(-3.7)     # -3    — truncates toward zero, not floor
round(-3.5)   # -4    — banker's rounding, ties to even
True + 1      # 2     — bool subclasses int
type(1 / 1)   # <class 'float'> — / always returns a float, even when it divides evenly

n = float(input("Enter a number: "))
print(f"Square: {n ** 2}")
print(f"Cube: {n ** 3}")
print(f"Greater than 100: {n > 100}")

import math
math.isclose(0.1 + 0.2, 0.3)   # True

7 + 3     # 10   add
7 - 3     # 4    subtract
7 * 3     # 21   multiply
7 / 3     # 2.3333333333333335   divide (always returns a float)
7 // 3    # 2    floor division
7 % 3     # 1    modulo
7 ** 3    # 343  exponent

>>> -7 // 3
-3          # rounds toward negative infinity, not toward zero
>>> -7 % 3
2           # the sign follows the divisor

n % 2 == 0        # is it even
n % 15 == 0       # divisible by both 3 and 5
seconds % 60      # seconds → minutes and seconds
i % len(items)    # wrapping index, never out of range

a == b     # equal
a != b     # not equal
a > b      # greater
a < b      # less
a >= b
a <= b

>>> x = 5
>>> 1 < x < 10        # same as 1 < x and x < 10
True
>>> 0 <= score <= 100  # range check — very handy

True and False    # False   — both must be true
True or False     # True    — either one
not True          # False   — negation

# Standard idiom: check existence before accessing
if user is not None and user.is_active:
    ...
# If user is None, and short-circuits and user.is_active is never evaluated

>>> "a" and "b"
'b'          # both truthy, returns the last
>>> "" or "default"
'default'    # left is falsy, returns the right
>>> 0 or None
None

name = user_input or "Anonymous"   # falls back when user_input is empty

port = config_port if config_port is not None else 8080
# not config_port or 8080 — because 0 is a meaningful legal value here
# (it means "let the OS pick a port"), and or would silently replace it with 8080

x = 5
x += 3     # x = x + 3 → 8
x -= 2     # 6
x *= 2     # 12
x /= 4     # 3.0  (note it became a float)
x //= 2    # 1.0
x **= 3    # 1.0
x %= 2     # 1.0

a = [1, 2, 3]
b = [1, 2, 3]
c = a

a == b    # True  — same contents
a is b    # False — but two distinct list objects
a is c    # True  — the same object

if x is None:      # ✅
if x is True:      # usually if x: is enough
if name is "abc":  # ❌ never compare strings this way

>>> a = 256; b = 256
>>> a is b
True          # CPython caches integers from -5 to 256
>>> a = 257; b = 257
>>> a is b
False         # outside the cache

"a" in "abc"           # True
3 in [1, 2, 3]         # True
"key" in {"key": 1}    # True  — dicts check keys
5 not in [1, 2, 3]     # True

# One million elements, testing membership
big_list = list(range(1_000_000))
big_set = set(big_list)

999_999 in big_list    # slow
999_999 in big_set     # hundreds of times faster

5 & 3     # 1   AND     0101 & 0011 = 0001
5 | 3     # 7   OR      0101 | 0011 = 0111
5 ^ 3     # 6   XOR     0101 ^ 0011 = 0110
~5        # -6  NOT
5 << 1    # 10  left shift  (× 2)
5 >> 1    # 2   right shift (// 2)

**                          exponent
+x  -x  ~x                  unary sign, bitwise NOT
*  /  //  %                 multiplicative
+  -                        additive
<<  >>                      shifts
&                           bitwise AND
^                           bitwise XOR
|                           bitwise OR
comparisons  ==  !=  <  >  in  is
not                         logical NOT
and                         logical AND
or                          logical OR

2 + 3 * 4        # 14, not 20
(2 + 3) * 4      # 20
2 ** 3 ** 2      # 512 — exponent is right-associative: 2 ** (3 ** 2)
-2 ** 2          # -4 — ** binds tighter than unary minus: -(2 ** 2)

# Traditional
data = input()
while data != "quit":
    print(data)
    data = input()

# Walrus
while (data := input()) != "quit":
    print(data)

# Avoid calling the function twice
if (n := len(items)) > 10:
    print(f"Too many: {n}")

17 // 5
-17 // 5
17 % 5
-17 % 5
2 ** 3 ** 2
not 0 or 1
[] or "x"
1 == 1.0
1 is 1.0

17 // 5      # 3
-17 // 5     # -4   (floor, not -3)
17 % 5       # 2
-17 % 5      # 3    (sign follows the divisor)
2 ** 3 ** 2  # 512  (right-associative)
not 0 or 1   # True (not 0 → True; True or 1 short-circuits to True)
[] or "x"    # 'x'
1 == 1.0     # True (equal values)
1 is 1.0     # False (different types, different objects)

total = int(input("Seconds: "))
hours = total // 3600
minutes = total % 3600 // 60
seconds = total % 60
print(f"{hours} hours {minutes} minutes {seconds} seconds")

minutes, seconds = divmod(total, 60)
hours, minutes = divmod(minutes, 60)

year = int(input("Year: "))
is_leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
print(is_leap)

a, b = b, a

s1 = "double quotes"
s2 = 'single quotes'   # exactly equivalent
s3 = """triple quotes
span lines"""
s4 = '''single triple quotes work too'''

"He said: 'hi'"      # ✅ double outside, single inside
'She said: "hi"'     # ✅ the reverse
"He said: \"hi\""    # works, but less readable

"\n"     # newline
"\t"     # tab
"\\"     # a literal backslash
"\""     # double quote
"\'"     # single quote
"\u00e9" # Unicode code point → é

print("C:\new\table")       # \n and \t get interpreted; output is a mess
print(r"C:\new\table")      # C:\new\table  ✅

name = "Alice"
age = 18

f"I'm {name}, {age} years old"     # I'm Alice, 18 years old
f"Next year: {age + 1}"            # any expression works
f"{name.upper()}"                  # method calls work

pi = 3.14159265

f"{pi:.2f}"        # '3.14'       two decimal places
f"{pi:10.2f}"      # '      3.14' width 10, right-aligned
f"{pi:<10.2f}"     # '3.14      ' left-aligned
f"{pi:^10.2f}"     # '   3.14   ' centered
f"{pi:+.2f}"       # '+3.14'      always show the sign

n = 1234567
f"{n:,}"           # '1,234,567'  thousands separators
f"{n:_}"           # '1_234_567'
f"{n:>12}"         # '     1234567'
f"{n:012}"         # '000001234567' zero-padded

r = 0.8567
f"{r:.1%}"         # '85.7%'      percentage

f"{255:b}"         # '11111111'   binary
f"{255:o}"         # '377'        octal
f"{255:x}"         # 'ff'         hex
f"{255:X}"         # 'FF'
f"{255:08b}"       # '11111111'   zero-padded to 8 digits

x = 42
print(f"{x=}")           # x=42
print(f"{x * 2 = }")     # x * 2 = 84

"I'm {}, {} years old".format(name, age)   # str.format(), Python 3.0+
"I'm %s, %d years old" % (name, age)       # % formatting, oldest, from C

s = "hello"
s[0] = "H"     # TypeError: 'str' object does not support item assignment

s = "hello"
t = s.upper()
print(s)   # hello  — the original is unchanged
print(t)   # HELLO

s = "Python"
#    012345      forward indices
#   -654321      negative indices

s[0]      # 'P'
s[5]      # 'n'
s[-1]     # 'n'   last
s[-2]     # 'o'   second to last
s[10]     # IndexError!

s = "Python"

s[0:3]     # 'Pyt'    indices 0,1,2
s[:3]      # 'Pyt'    omit start = from the beginning
s[3:]      # 'hon'    omit stop = to the end
s[:]       # 'Python' full copy
s[1:5:2]   # 'yh'     step 2
s[::-1]    # 'nohtyP' step -1 = reverse
s[::2]     # 'Pto'    every other character
s[-3:]     # 'hon'    last three
s[:-3]     # 'Pyt'    all but the last three

s[100:200]    # ''  empty string, no error
s[0:100]      # 'Python'

"hello".upper()        # 'HELLO'
"HELLO".lower()        # 'hello'
"hello world".title()  # 'Hello World'
"hello".capitalize()   # 'Hello'
"Hello".swapcase()     # 'hELLO'
"Hello".casefold()     # 'hello'  more aggressive than lower(); use for case-insensitive comparison

"  hi  ".strip()       # 'hi'      both ends
"  hi  ".lstrip()      # 'hi  '    left
"  hi  ".rstrip()      # '  hi'    right
"xxhixx".strip("x")    # 'hi'      strip specific characters
"file.txt".removesuffix(".txt")   # 'file'  Python 3.9+
"pre_name".removeprefix("pre_")   # 'name'

"hello".find("ll")        # 2    returns -1 if not found
"hello".index("ll")       # 2    raises ValueError if not found
"hello".rfind("l")        # 3    search from the right
"hello".count("l")        # 2
"hello".startswith("he")  # True
"hello".endswith((".jpg", ".png"))   # accepts a tuple; any match counts
"ll" in "hello"           # True  ← simplest when you only need existence

"a-b-c".replace("-", "+")       # 'a+b+c'
"a-b-c".replace("-", "+", 1)    # 'a+b-c'  only the first

"a,b,c".split(",")           # ['a', 'b', 'c']
"a b  c".split()             # ['a', 'b', 'c']  no arg = split on any whitespace, collapsing runs
"a,b,c".split(",", 1)        # ['a', 'b,c']     at most one split
"a,b,c".rsplit(",", 1)       # ['a,b', 'c']     split from the right
"line1\nline2".splitlines()  # ['line1', 'line2']
"a=1".partition("=")         # ('a', '=', '1')  three pieces

",".join(["a", "b", "c"])    # 'a,b,c'
"".join(["a", "b"])          # 'ab'
"\n".join(lines)             # join with newlines

# ❌ Slow: every += creates a new string
result = ""
for word in words:
    result += word

# ✅ Fast
result = "".join(words)

"abc".isalpha()      # True   all letters
"123".isdigit()      # True   all digits
"a1".isalnum()       # True   letters or digits
"  ".isspace()       # True   all whitespace
"Hello".istitle()    # True
"ABC".isupper()      # True

"5".zfill(3)         # '005'
"hi".ljust(10, ".")  # 'hi........'
"hi".rjust(10)       # '        hi'
"hi".center(10, "*") # '****hi****'

s = "héllo"
b = s.encode("utf-8")     # str → bytes: b'h\xc3\xa9llo'
s2 = b.decode("utf-8")    # bytes → str: 'héllo'

len(s)    # 5  five characters
len(b)    # 6  six bytes (é takes 2 bytes in UTF-8)

len("中文")                    # 2 characters
len("中文".encode("utf-8"))    # 6 bytes

open("file.txt", encoding="utf-8")

"apple" < "banana"     # True   compares Unicode code points, character by character
"Apple" < "apple"      # True   uppercase code points are lower than lowercase
"10" < "9"             # True   ⚠️ string comparison is not numeric comparison!

a.casefold() == b.casefold()

s = "Hello, World!"
s[::-1]           # '!dlroW ,olleH'
s.upper()         # 'HELLO, WORLD!'
s[7:12]           # 'World'
s[:5]             # 'Hello'
s.count("l")      # 3

raw = " Alice, Bob ,Carol "
names = [name.strip() for name in raw.split(",")]
print(names)   # ['Alice', 'Bob', 'Carol']

text = input("Enter a phrase: ")
cleaned = text.lower().replace(" ", "")
if cleaned == cleaned[::-1]:
    print("Palindrome")
else:
    print("Not a palindrome")

path = "/home/user/documents/report.pdf"
filename = path.split("/")[-1]        # 'report.pdf'
ext = filename.split(".")[-1]         # 'pdf'

from pathlib import Path
p = Path(path)
p.name      # 'report.pdf'
p.suffix    # '.pdf'
p.stem      # 'report'

f"{1234567.891:,.2f}"    # '1,234,567.89'

age = 18

if age >= 18:
    print("Adult")
elif age >= 13:
    print("Teenager")
else:
    print("Child")

if is_logged_in:
    if is_admin:
        print("Admin panel")
    else:
        print("User panel")
else:
    print("Please log in")

# ❌ Three levels deep
def process(user):
    if user is not None:
        if user.is_active:
            if user.has_permission:
                do_work()

# ✅ Return early, stay flat
def process(user):
    if user is None:
        return
    if not user.is_active:
        return
    if not user.has_permission:
        return
    do_work()

status = "adult" if age >= 18 else "minor"

for item in [1, 2, 3]:
    print(item)

for char in "abc":
    print(char)

for key in {"a": 1, "b": 2}:
    print(key)      # iterating a dict gives you keys

range(5)         # 0, 1, 2, 3, 4        (stop is exclusive)
range(2, 5)      # 2, 3, 4
range(0, 10, 2)  # 0, 2, 4, 6, 8
range(5, 0, -1)  # 5, 4, 3, 2, 1

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

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

# ❌ C-style
for i in range(len(fruits)):
    print(i, fruits[i])

# ✅ Pythonic
for i, fruit in enumerate(fruits):
    print(i, fruit)

# Number from 1
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

names = ["Alice", "Bob"]
ages = [25, 30]

for name, age in zip(names, ages):
    print(f"{name}: {age}")

for x in reversed([1, 2, 3]):     # 3 2 1
    ...
for x in sorted([3, 1, 2]):       # 1 2 3
    ...

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

# Keep asking until the input is valid
while True:
    answer = input("y/n? ").lower()
    if answer in ("y", "n"):
        break
    print("Please enter y or n")

count = 0
while count < 5:
    print(count)     # forgot count += 1 → prints 0 forever

for i in range(10):
    if i == 3:
        continue      # skip the rest of this iteration
    if i == 6:
        break         # exit the loop entirely
    print(i)
# Output: 0 1 2 4 5

for item in items:
    if item.is_target:
        print("Found it")
        break
else:
    print("Went through everything and found nothing")

def find_pair(matrix, target):
    for row in matrix:
        for x in row:
            if x == target:
                return True     # exits every level at once
    return False

def handle(command):
    match command.split():
        case ["quit"]:
            return "Quitting"
        case ["go", direction]:
            return f"Heading {direction}"
        case ["drop", *items]:
            return f"Dropping {len(items)} items"
        case _:
            return "Didn't understand that"

match response:
    case {"status": 200, "data": data}:
        print(f"Success: {data}")
    case {"status": 404}:
        print("Not found")
    case {"status": code} if code >= 500:
        print(f"Server error {code}")
    case _:
        print("Unknown response")

STATUS_OK = 200
match code:
    case STATUS_OK:      # ❌ this assigns code to STATUS_OK and always matches!
        ...
    case Status.OK:      # ✅ only dotted names compare by value
        ...

handlers = {"start": do_start, "stop": do_stop}
handlers.get(command, do_unknown)()

def todo():
    pass          # syntax needs a statement; haven't decided what yet

class Empty:
    ...           # Ellipsis; same effect, common in type-stub contexts

import random

secret = random.randint(1, 100)
attempts = 0
MAX_ATTEMPTS = 7

print(f"I'm thinking of a number from 1 to 100. You get {MAX_ATTEMPTS} guesses.")

while attempts < MAX_ATTEMPTS:
    raw = input(f"Guess #{attempts + 1}: ")

    if not raw.isdigit():
        print("Please enter a number")
        continue          # invalid input doesn't cost a guess

    guess = int(raw)
    attempts += 1

    if guess == secret:
        print(f"Got it in {attempts} guesses!")
        break
    elif guess < secret:
        print("Too low")
    else:
        print("Too high")
else:
    print(f"Out of guesses. It was {secret}")

*
**
***
****
*****

for n in range(1, 101):
    if n % 3 == 0 and n % 5 != 0:
        print(n)

for n in range(1, 31):
    if n % 15 == 0:
        print("FizzBuzz")
    elif n % 3 == 0:
        print("Fizz")
    elif n % 5 == 0:
        print("Buzz")
    else:
        print(n)

for i in range(1, 6):
    print("*" * i)

n = int(input("Enter a number: "))

if n < 2:
    print("Not prime")
else:
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            print(f"Not prime, divisible by {i}")
            break
    else:
        print("Prime")

numbers = []
while True:
    raw = input("Enter a number (blank to finish): ")
    if raw == "":
        break
    numbers.append(float(raw))

if numbers:
    print(f"Sum: {sum(numbers)}")
    print(f"Average: {sum(numbers) / len(numbers)}")
else:
    print("No numbers entered")

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}x{i}={i*j}", end="\t")
    print()

fruits = ["apple", "banana", "orange"]
numbers = [1, 2, 3]
mixed = [1, "a", 3.14, True, None, [1, 2]]    # any mix of types
empty = []

fruits[0]      # 'apple'
fruits[-1]     # 'orange'
fruits[1:]     # ['banana', 'orange']
fruits[::-1]   # ['orange', 'banana', 'apple']

fruits[0] = "pear"
fruits[1:3] = ["grape"]      # slice assignment: replace two elements with one

lst = [1, 2, 3]

# Add
lst.append(4)             # [1, 2, 3, 4]        one item at the end
lst.extend([5, 6])        # [1, 2, 3, 4, 5, 6]  several items at the end
lst.insert(0, 0)          # [0, 1, 2, ...]      insert at a position
lst += [7]                # same as extend

# Remove
lst.remove(3)             # remove the first 3; ValueError if absent
x = lst.pop()             # remove and return the last item
x = lst.pop(0)            # remove and return index 0
del lst[0]                # delete by index
del lst[1:3]              # delete by slice
lst.clear()               # empty it

# Search
lst.index(2)              # index of the first 2; ValueError if absent
lst.count(2)              # how many 2s
2 in lst                  # True

# Reorder
lst.sort()                # sorts in place, returns None
lst.sort(reverse=True)    # descending
lst.reverse()             # reverses in place

a = [1, 2]
a.append([3, 4])    # [1, 2, [3, 4]]    ← the whole list becomes one element
b = [1, 2]
b.extend([3, 4])    # [1, 2, 3, 4]      ← elements added individually

lst = [3, 1, 2]
result = lst.sort()      # result is None!
print(result)            # None

new = sorted(lst)         # ✅ returns a new list; the original is untouched
new = list(reversed(lst)) # ✅

lst = [1, 2, 3, 4]
for x in lst:
    if x % 2 == 0:
        lst.remove(x)     # ❌ result is [1, 3, 4] — indices shift and 3 gets skipped

lst = [x for x in lst if x % 2 != 0]     # ✅

for i in range(len(lst) - 1, -1, -1):
    if lst[i] % 2 == 0:
        del lst[i]

words = ["banana", "Apple", "cherry"]

sorted(words)                          # ['Apple', 'banana', 'cherry']  uppercase first
sorted(words, key=str.lower)           # ['Apple', 'banana', 'cherry']  case-insensitive
sorted(words, key=len)                 # by length
sorted(words, reverse=True)            # descending

people = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Carol", "age": 30},
]

# By age
sorted(people, key=lambda p: p["age"])

# Multi-level: age first, then name
sorted(people, key=lambda p: (p["age"], p["name"]))

# Age descending, name ascending (trick: negate the number)
sorted(people, key=lambda p: (-p["age"], p["name"]))

from operator import itemgetter
sorted(people, key=itemgetter("age", "name"))

point = (3, 4)
single = (42,)        # ⚠️ a one-element tuple needs the comma! (42) is just a parenthesized int
empty = ()
no_paren = 3, 4       # parens are optional; the comma is what matters

point[0] = 5     # TypeError

locations = {(0, 0): "origin", (1, 1): "diagonal"}   # ✅ tuple key
locations = {[0, 0]: "origin"}                       # ❌ TypeError: unhashable type

def divmod_(a, b):
    return a // b, a % b     # returns a tuple

q, r = divmod_(17, 5)        # 3, 2

a, b = 1, 2               # a=1, b=2
a, b = b, a               # swap, no temp needed

x, y, z = [1, 2, 3]       # lists unpack too
name, age = ("Alice", 25)

# Star collects the rest
first, *rest = [1, 2, 3, 4]      # first=1, rest=[2, 3, 4]
*init, last = [1, 2, 3, 4]       # init=[1, 2, 3], last=4
a, *mid, z = [1, 2, 3, 4, 5]     # a=1, mid=[2,3,4], z=5

# Underscore by convention for values you don't need
_, important, _ = (1, 2, 3)

# Nested unpacking
(a, b), c = (1, 2), 3

pairs = [(1, "a"), (2, "b")]
for num, letter in pairs:
    print(num, letter)

a, b = [1, 2, 3]     # ValueError: too many values to unpack

a = [1, 2, 3]
b = a            # b and a point at the same list
b.append(4)
print(a)         # [1, 2, 3, 4]  ← a changed too!

b = a.copy()        # recommended
b = a[:]            # slice copy
b = list(a)         # construct a new list

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)      # [[1, 2, 99], [3, 4]]  ← the inner lists are still shared!

import copy
b = copy.deepcopy(a)     # recursively copies every level

grid = [[0] * 3] * 3        # ❌ all three rows are the same list
grid[0][0] = 1
print(grid)                  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

grid = [[0] * 3 for _ in range(3)]   # ✅ each row is a fresh list

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

len(nums)         # 8
sum(nums)         # 31
max(nums)         # 9
min(nums)         # 1
sorted(nums)      # [1, 1, 2, 3, 4, 5, 6, 9]
any([0, 1, 0])    # True   at least one truthy
all([1, 1, 0])    # False  all must be truthy
list(reversed(nums))

# max/min also take key
max(words, key=len)                 # longest word
max(people, key=lambda p: p["age"]) # oldest person

# sum takes a start value
sum([[1], [2]], [])                 # [1, 2]  (concatenates lists, but inefficiently)

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

matrix[1][2]        # 6   row 2, column 3

# Iterating
for row in matrix:
    for value in row:
        print(value, end=" ")
    print()

# Transpose
transposed = list(zip(*matrix))    # [(1,4,7), (2,5,8), (3,6,9)]

a = [1, 2, 3]
b = a
c = a[:]
a.append(4)
print(b, c)

nums = [3, 7, 1, 9, 4, 1, 7]

max(nums)                      # 9
min(nums)                      # 1
sum(nums) / len(nums)          # 4.571428571428571

sorted(set(nums))              # [1, 3, 4, 7, 9]

[n for n in nums if n > 3]     # [7, 9, 4, 7]

nums[::-1]                     # slice, returns a new list
list(reversed(nums))           # same
nums.reverse()                 # in place, returns None

nested = [[1, 2], [3, 4], [5, 6]]

# Way 1: comprehension (most common)
flat = [x for row in nested for x in row]

# Way 2: itertools
from itertools import chain
flat = list(chain.from_iterable(nested))

# Way 3: loop
flat = []
for row in nested:
    flat.extend(row)

scores = [("Alice", 85), ("Bob", 92), ("Carol", 78)]
ranked = sorted(scores, key=lambda s: s[1], reverse=True)

for rank, (name, score) in enumerate(ranked, start=1):
    print(f"#{rank}: {name}, {score} points")

def dedup(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

def dedup(items):
    return list(dict.fromkeys(items))

grid = [[0] * 3 for _ in range(3)]   # ✅

person = {
    "name": "Alice",
    "age": 25,
    "city": "Berlin",
}

empty = {}
from_pairs = dict([("a", 1), ("b", 2)])
from_kwargs = dict(name="Alice", age=25)

person["name"]              # 'Alice'
person["email"]             # ❌ KeyError!

person.get("email")         # None, no error
person.get("email", "n/a")  # 'n/a', custom default

person["age"] = 26              # update
person["email"] = "[email protected]"     # add if missing

person.update({"age": 27, "phone": "555-0100"})   # bulk update
person |= {"age": 28}                             # merge syntax, Python 3.9+

del person["email"]
age = person.pop("age")             # remove and return the value
age = person.pop("age", None)       # default if missing, no error
key, val = person.popitem()         # remove and return the last inserted pair
person.clear()

for key in person:                  # keys by default
    print(key)

for key in person.keys():           # explicit, equivalent
    ...
for value in person.values():
    ...
for key, value in person.items():   # most common
    print(f"{key}: {value}")

"name" in person          # True   — checks keys
"Alice" in person.values() # True  — checking values requires being explicit

d = {[1, 2]: "x"}     # TypeError: unhashable type: 'list'
d = {(1, 2): "x"}     # ✅

text = "hello world"
counts = {}
for char in text:
    counts[char] = counts.get(char, 0) + 1

from collections import Counter
counts = Counter(text)
counts.most_common(3)       # the three most frequent: [('l', 3), ('o', 2), ...]

from collections import defaultdict

words = ["apple", "avocado", "banana", "blueberry"]
groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)
# {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry']}

groups = {}
for word in words:
    groups.setdefault(word[0], []).append(word)

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}

merged = {**a, **b}       # {'x': 1, 'y': 20, 'z': 3}  later wins
merged = a | b            # Python 3.9+, same thing, clearer

inverted = {v: k for k, v in d.items()}

squares = {n: n**2 for n in range(5)}        # {0:0, 1:1, 2:4, 3:9, 4:16}
filtered = {k: v for k, v in d.items() if v is not None}

config = {
    "database": {"host": "localhost", "port": 5432},
    "cache": {"ttl": 300},
}

config["database"]["host"]                      # 'localhost'
config.get("cache", {}).get("size", 100)        # safely reach deep values

s = {1, 2, 3}
s = set([1, 2, 2, 3])       # {1, 2, 3}  duplicates dropped
empty = set()               # ⚠️ not {} — that's an empty dict

s.add(4)
s.remove(4)          # KeyError if absent
s.discard(4)         # no error if absent
s.pop()              # removes an arbitrary element (which one is unspecified — and don't
                     # count on it being random)
s.clear()
len(s)
3 in s               # O(1), very fast

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

a | b        # {1, 2, 3, 4}   union            a.union(b)
a & b        # {2, 3}         intersection     a.intersection(b)
a - b        # {1}            difference       a.difference(b)
a ^ b        # {1, 4}         symmetric diff   a.symmetric_difference(b)

a <= b       # subset?         a.issubset(b)
a >= b       # superset?
a.isdisjoint(b)   # no elements in common?

unique = list(set(items))           # but loses order
unique = list(dict.fromkeys(items)) # preserves order

# ❌ list lookup is O(n)
banned = ["a", "b", "c", ...]      # 10,000 entries
if word in banned:  ...             # slow

# ✅ set lookup is O(1)
banned = {"a", "b", "c", ...}
if word in banned:  ...             # fast

fs = frozenset([1, 2, 3])
d = {fs: "value"}     # ✅

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

# Counter — counting
c = Counter("mississippi")
c.most_common(2)          # [('i', 4), ('s', 4)]
c["i"]                    # 4
c["z"]                    # 0 (no error)

# defaultdict — dict with automatic defaults
d = defaultdict(int)      # defaults to 0
d["x"] += 1               # no initialization needed
d = defaultdict(list)     # defaults to []

# deque — double-ended queue, O(1) at both ends
q = deque([1, 2, 3])
q.appendleft(0)           # list.insert(0, x) is O(n); deque is O(1)
q.popleft()
q = deque(maxlen=5)       # fixed size, drops the oldest when full

# namedtuple — a tuple with field names (dataclass is usually better; see Ch 18)
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
p.x                       # 3

d = {}
d[[1, 2]] = "value"

from collections import Counter

text = "the quick brown fox jumps over the lazy dog the end"
words = text.lower().split()
counts = Counter(words)

for word, count in counts.most_common(5):
    print(f"{word}: {count}")

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

a & b       # {4, 5}
a - b       # {1, 2, 3}
a | b       # {1, 2, 3, 4, 5, 6, 7}

from collections import defaultdict

students = [
    {"name": "Alice", "class": "A"},
    {"name": "Bob", "class": "B"},
    {"name": "Carol", "class": "A"},
]

groups = defaultdict(list)
for s in students:
    groups[s["class"]].append(s["name"])

print(dict(groups))   # {'A': ['Alice', 'Carol'], 'B': ['Bob']}

def is_anagram(a, b):
    return sorted(a.lower()) == sorted(b.lower())

# Or with Counter, which reads more clearly
from collections import Counter
def is_anagram(a, b):
    return Counter(a.lower()) == Counter(b.lower())

d[(1, 2)] = "value"

def get_nested(data, path, default=None):
    current = data
    for key in path.split("."):
        if not isinstance(current, dict) or key not in current:
            return default
        current = current[key]
    return current

config = {"database": {"host": "localhost", "port": 5432}}
get_nested(config, "database.host")      # 'localhost'
get_nested(config, "database.user")      # None
get_nested(config, "cache.ttl", 300)     # 300

[expression for variable in iterable]

# Traditional
squares = []
for n in range(5):
    squares.append(n ** 2)

# Comprehension
squares = [n ** 2 for n in range(5)]      # [0, 1, 4, 9, 16]

[expression for variable in iterable if condition]

evens = [n for n in range(20) if n % 2 == 0]
long_words = [w for w in words if len(w) > 5]
valid = [int(x) for x in inputs if x.isdigit()]

# if at the end = filtering (decide whether to include the element)
[n for n in nums if n > 0]

# if...else at the front = transformation (include everything, just different values)
[n if n > 0 else 0 for n in nums]

# Flatten a nested list
flat = [x for row in matrix for x in row]

# Equivalent to
flat = []
for row in matrix:
    for x in row:
        flat.append(x)

pairs = [(a, b) for a in "AB" for b in [1, 2]]
# [('A', 1), ('A', 2), ('B', 1), ('B', 2)]

# Dict comprehension
{k: v for ...}
squares = {n: n**2 for n in range(5)}
inverted = {v: k for k, v in d.items()}
upper_keys = {k.upper(): v for k, v in d.items()}
filtered = {k: v for k, v in d.items() if v is not None}

# Set comprehension
{expression for ...}
unique_lengths = {len(w) for w in words}

squares_list = [n**2 for n in range(1000000)]    # builds a million elements now, tens of MB
squares_gen = (n**2 for n in range(1000000))     # almost no memory; computes one at a time

sum(n**2 for n in range(100))          # no need for sum((n**2 for ...))
any(x > 100 for x in nums)
max(len(w) for w in words)
"\n".join(str(x) for x in nums)

result = [transform(x) if cond1(x) else other(x)
          for sublist in data if check(sublist)
          for x in sublist if x is not None and validate(x)]

[print(x) for x in items]     # ❌ builds a list of Nones nobody wants
for x in items: print(x)      # ✅

# Convert types
[int(x) for x in strings]

# Filter out None
[x for x in items if x is not None]

# Extract a field
[p["name"] for p in people]

# Clean lines of text
[line.strip() for line in lines if line.strip()]

# Index plus value
[f"{i}: {v}" for i, v in enumerate(items)]

# Conditional transformation
[x if x > 0 else 0 for x in nums]

# Pair two lists
[(a, b) for a, b in zip(list1, list2)]

# Flatten
[x for sub in nested for x in sub]

# Build a lookup dict
{item["id"]: item for item in items}

# Invert a dict
{v: k for k, v in d.items()}

# Deduplicate (unordered)
{x for x in items}

[x for x in range(10) if x % 2 == 0]
[x if x % 2 == 0 else None for x in range(10)]

# 1
[n**2 for n in range(1, 21) if n % 2 == 0]

# 2
sentence = "the quick brown fox jumps"
[w.upper() for w in sentence.split() if len(w) > 3]

# 3
items = ["1", "a", "2", "b", "3"]
[int(x) for x in items if x.isdigit()]

# 4
[[i * j for j in range(1, 4)] for i in range(1, 4)]
# [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

data = {"a": 1, "b": None, "c": 3, "d": None}
cleaned = {k: v for k, v in data.items() if v is not None}
# {'a': 1, 'c': 3}

sum(n for n in range(1, 101) if n % 7 == 0)    # 735

matrix = [[1, 2, 3], [4, 5, 6]]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
# [[1, 4], [2, 5], [3, 6]]

def greet(name):
    """Say hello."""            # docstring
    return f"Hello, {name}"

message = greet("Alice")
print(message)                  # Hello, Alice

def check(n):
    if n < 0:
        return "negative"
    return "non-negative"
    print("never runs")     # dead code

def power(base, exponent):
    return base ** exponent

power(2, 3)      # 8   matched by position

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}"

greet("Alice")                   # Hello, Alice
greet("Alice", "Good morning")   # Good morning, Alice

def f(a=1, b): ...       # ❌ SyntaxError

def add_item(item, items=[]):    # ❌ dangerous!
    items.append(item)
    return items

add_item("a")     # ['a']
add_item("b")     # ['a', 'b']   ← it remembered the previous call!

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

power(exponent=3, base=2)    # 8

save(data, True, False)                    # ❌ what are True and False?
save(data, overwrite=True, backup=False)   # ✅

def total(*numbers):           # collects any number of positional args into a tuple
    return sum(numbers)

total(1, 2, 3)                 # 6
total(1, 2, 3, 4, 5)           # 15


def config(**options):         # collects any number of keyword args into a dict
    for key, value in options.items():
        print(f"{key} = {value}")

config(debug=True, port=8080)


def flexible(a, b=2, *args, **kwargs):
    print(a, b, args, kwargs)

flexible(1, 2, 3, 4, x=5)      # 1 2 (3, 4) {'x': 5}

nums = [1, 2, 3]
total(*nums)                   # same as total(1, 2, 3)

opts = {"debug": True, "port": 8080}
config(**opts)                 # same as config(debug=True, port=8080)

def f(a, b, /, c, d, *, e, f):
    ...
#      ↑ everything before / must be positional
#              ↑ everything after * must be keyword

def create_user(name, *, admin=False, active=True):
    ...

create_user("Alice", admin=True)      # ✅
create_user("Alice", True)            # ❌ TypeError

def min_max(numbers):
    return min(numbers), max(numbers)     # actually returns a tuple

lo, hi = min_max([3, 1, 4])               # unpacked
result = min_max([3, 1, 4])               # (1, 4)

def calculate_bmi(weight, height):
    """Compute body mass index.

    Args:
        weight: mass in kilograms
        height: height in meters

    Returns:
        The BMI as a float

    Raises:
        ValueError: if height is zero or negative
    """
    if height <= 0:
        raise ValueError("Height must be positive")
    return weight / height ** 2

help(calculate_bmi)
calculate_bmi.__doc__

square = lambda x: x ** 2      # same as def square(x): return x ** 2

sorted(people, key=lambda p: p["age"])
list(filter(lambda x: x > 0, nums))
list(map(lambda x: x * 2, nums))

square = lambda x: x ** 2      # ❌ PEP 8 explicitly discourages this
def square(x): return x ** 2   # ✅

map(lambda x: x * 2, nums)         →  [x * 2 for x in nums]
filter(lambda x: x > 0, nums)      →  [x for x in nums if x > 0]
sorted(d, key=lambda x: x[1])      →  sorted(d, key=itemgetter(1))

def double(x):
    return x * 2

f = double              # assign to a variable (note: no parentheses)
f(5)                    # 10

funcs = [double, abs, len]        # put them in a list
for fn in funcs:
    print(fn.__name__)

def apply(fn, value):             # take one as a parameter
    return fn(value)
apply(double, 5)                  # 10

def make_multiplier(n):           # return one
    def multiplier(x):
        return x * n
    return multiplier

triple = make_multiplier(3)
triple(5)                         # 15

def factorial(n):
    if n <= 1:          # base case — mandatory!
        return 1
    return n * factorial(n - 1)

factorial(5)            # 120

def total_size(item):
    """Recursively sum all numbers in a nested list."""
    if isinstance(item, list):
        return sum(total_size(x) for x in item)
    return item

total_size([1, [2, [3, 4]], 5])    # 15

from functools import cache

@cache
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

fib(100)     # instant

# ❌ Reads a file, computes, and prints
def process():
    data = open("f.txt").read()
    result = complicated_math(data)
    print(result)

# ✅ Split up — each is testable and reusable
def load_data(path): ...
def compute(data): ...
def report(result): ...

get_user()  calculate_tax()  is_valid()  has_permission()  send_email()

# ❌ The name says "calculate" but it mutates the input
def calculate_total(items):
    items.sort()          # unexpectedly modifies the caller's list!
    return sum(items)

# ✅ Leave the input alone
def calculate_total(items):
    return sum(sorted(items))

def append_log(msg, logs=[]):
    logs.append(msg)
    return logs

def is_prime(n):
    if n < 2:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n ** 0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

def average(*numbers):
    if not numbers:
        return 0
    return sum(numbers) / len(numbers)

average(1, 2, 3)     # 2.0
average()            # 0

def append_log(msg, logs=None):
    if logs is None:
        logs = []
    logs.append(msg)
    return logs

import re
from collections import Counter

def word_count(text):
    words = re.findall(r"\w+", text.lower())
    return dict(Counter(words))

word_count("The cat. The DOG! the cat?")
# {'the': 3, 'cat': 2, 'dog': 1}

def retry(func, times=3):
    last_error = None
    for attempt in range(times):
        try:
            return func()
        except Exception as e:
            last_error = e
            print(f"Attempt {attempt + 1} failed: {e}")
    raise last_error

def max_depth(d):
    if not isinstance(d, dict) or not d:
        return 0
    return 1 + max(max_depth(v) for v in d.values())

max_depth({"a": {"b": {"c": 1}}})    # 3

L (Local)      — inside the current function
E (Enclosing)  — an outer function (only with nested functions)
G (Global)     — module top level
B (Built-in)   — Python's built-ins (print, len, etc.)

x = "global"                  # G

def outer():
    x = "enclosing"           # E
    def inner():
        x = "local"           # L
        print(x)              # local
    inner()
    print(x)                  # enclosing

outer()
print(x)                      # global

counter = 0

def show():
    print(counter)    # ✅ readable

counter = 0

def increment():
    counter = counter + 1     # ❌ UnboundLocalError

counter = 0

def increment():
    global counter            # declare: I mean the module-level one
    counter += 1

def outer():
    count = 0
    def inner():
        nonlocal count        # modifies outer's count, not a global
        count += 1
    inner()
    inner()
    return count              # 2

# ❌
total = 0
def add(x):
    global total
    total += x

# ✅
def add(total, x):
    return total + x

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

c1 = make_counter()
c1()    # 1
c1()    # 2
c1()    # 3

c2 = make_counter()
c2()    # 1  — an independent counter with its own count

def make_validator(min_len):
    def validate(text):
        return len(text) >= min_len
    return validate

check_password = make_validator(8)
check_username = make_validator(3)

check_password("abc")      # False
check_username("abc")      # True

funcs = []
for i in range(3):
    funcs.append(lambda: i)

[f() for f in funcs]     # [2, 2, 2]  ← all 2!

for i in range(3):
    funcs.append(lambda i=i: i)

[f() for f in funcs]     # [0, 1, 2]  ✅

def make_f(i):
    return lambda: i
funcs = [make_f(i) for i in range(3)]

x = 10
def f():
    x = 20
    def g():
        nonlocal x
        x = 30
    g()
    print(x)
f()
print(x)

total = 0
def add(n):
    total += n
    return total

fs = [lambda: i for i in range(3)]
print([f() for f in fs])

# Option 1: global (not recommended)
total = 0
def add(n):
    global total
    total += n
    return total

# Option 2: make it pure (recommended)
def add(total, n):
    return total + n

# Option 3: encapsulate the state in a closure
def make_adder():
    total = 0
    def add(n):
        nonlocal total
        total += n
        return total
    return add

def make_accumulator():
    total = 0
    def accumulate(n):
        nonlocal total
        total += n
        return total
    return accumulate

acc = make_accumulator()
acc(10)    # 10
acc(5)     # 15
acc(3)     # 18

# Fix 1: capture via default argument
fs = [lambda i=i: i for i in range(3)]

# Fix 2: factory function
def make(i):
    return lambda: i
fs = [make(i) for i in range(3)]

PI = 3.14159

def circle_area(r):
    return PI * r ** 2

def circle_circumference(r):
    return 2 * PI * r

import mathtools

mathtools.circle_area(2)     # 12.56636
mathtools.PI                 # 3.14159

import math                       # import the whole module
math.sqrt(16)

import math as m                  # with an alias
m.sqrt(16)

from math import sqrt             # import a single name
sqrt(16)

from math import sqrt, pi, floor  # several
from math import sqrt as square_root

from math import *                # ❌ import everything — don't

myproject/
├── main.py
└── utils/
    ├── __init__.py
    ├── text.py
    └── files.py

# main.py
from utils.text import clean
from utils import files

import utils.text as text

# utils/__init__.py
from .text import clean
from .files import read_json

from .text import clean       # sibling module
from ..config import SETTINGS # one level up

# tools.py

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

if __name__ == "__main__":
    main()

import sys
print(sys.path)         # the search path actually in effect — this is authoritative

# Your directory contains random.py
import random           # imports YOUR file, not the standard library!
random.randint(1, 10)   # AttributeError

import os, sys, math, random, json, re, time, datetime
import pathlib, collections, itertools, functools
import csv, sqlite3, urllib, http, socket
import unittest, logging, argparse, subprocess
import typing, dataclasses, enum, abc
import asyncio, threading, multiprocessing

myproject/
├── pyproject.toml          # project config and dependency declarations
├── README.md
├── .gitignore
├── src/
│   └── myproject/
│       ├── __init__.py
│       ├── main.py         # entry point
│       ├── config.py       # configuration
│       ├── models.py       # data structures
│       ├── services/       # business logic
│       │   ├── __init__.py
│       │   └── user.py
│       └── utils/          # shared helpers
│           ├── __init__.py
│           └── text.py
└── tests/
    ├── test_models.py
    └── test_services.py

import datetime
from datetime import datetime
from datetime import *

# calculator.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

if __name__ == "__main__":
    print("Self-test:")
    print(add(2, 3))        # 5
    print(divide(10, 2))    # 5.0

# main.py
from calculator import add, divide

print(add(1, 2))
print(divide(10, 4))

>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Traceback (most recent call last):
  File "main.py", line 10, in <module>
    result = process(data)
  File "main.py", line 5, in process
    return int(data["value"])
KeyError: 'value'

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Can't divide by zero")

try:
    value = int(input("Number: "))
    result = 100 / value
except ValueError:
    print("Please enter a number")
except ZeroDivisionError:
    print("Can't be zero")
except (TypeError, KeyError):        # several at once
    print("Type or key error")

try:
    int("abc")
except ValueError as e:
    print(f"Failed: {e}")            # invalid literal for int()...
    print(type(e).__name__)          # ValueError

try:
    f = open("data.txt")
except FileNotFoundError:
    print("File doesn't exist")
else:
    print("Runs only if try succeeded")
    data = f.read()
finally:
    print("Runs no matter what")     # cleanup goes here

BaseException
 ├── SystemExit
 ├── KeyboardInterrupt
 └── Exception          ← your own exceptions should subclass this
      ├── ValueError
      ├── TypeError
      ├── LookupError
      │    ├── KeyError
      │    └── IndexError
      ├── OSError
      │    ├── FileNotFoundError
      │    └── PermissionError
      └── ArithmeticError
           └── ZeroDivisionError

except LookupError:      # catches both KeyError and IndexError
except OSError:          # catches all file/system errors

# ❌ The worst possible form
try:
    do_something()
except:
    pass

# ✅ Best: catch a specific exception
except ValueError:
    ...

# ✅ Acceptable: catch Exception and log it
except Exception as e:
    logger.exception("Processing failed")
    raise                  # log, then re-raise

# ⚠️ Only at the outermost layer (to prevent a crash)
except Exception:
    logger.exception("Unexpected error")

def set_age(age):
    if not isinstance(age, int):
        raise TypeError(f"Age must be an integer, got {type(age).__name__}")
    if age < 0:
        raise ValueError(f"Age can't be negative: {age}")
    ...

try:
    risky()
except ValueError:
    logger.error("Noting this")
    raise                       # bare raise preserves the original traceback

try:
    data = json.loads(text)
except json.JSONDecodeError as e:
    raise ConfigError("Config file is malformed") from e
    # The traceback will show "The above exception was the direct cause of..."

class AppError(Exception):
    """Base class for all exceptions in this application."""

class ConfigError(AppError):
    """Configuration problem."""

class ValidationError(AppError):
    """Data validation failed."""
    def __init__(self, field, message):
        self.field = field
        super().__init__(f"{field}: {message}")


try:
    ...
except AppError as e:           # catch everything from this application at once
    ...

# ❌ Forgot to close, or an exception skipped the close
f = open("data.txt")
data = f.read()
f.close()

# ✅ with guarantees closing on exit, even if an exception occurs
with open("data.txt", encoding="utf-8") as f:
    data = f.read()

with open("a.txt") as fa, open("b.txt", "w") as fb:    # manage several at once
    fb.write(fa.read())

from contextlib import contextmanager
import time

@contextmanager
def timer(name):
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"{name} took {elapsed:.3f}s")


with timer("Data processing"):
    do_heavy_work()
# Data processing took 1.234s

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        print(f"Took {time.perf_counter() - self.start:.3f}s")
        return False        # returning True swallows the exception; normally return False

# LBYL — the common style in other languages
if os.path.exists(path):
    with open(path) as f:       # ⚠️ the file can be deleted between the check and the open
        ...

# EAFP — the Python style
try:
    with open(path) as f:
        ...
except FileNotFoundError:
    ...

# LBYL
if "key" in d:
    value = d["key"]
else:
    value = default

# EAFP
try:
    value = d["key"]
except KeyError:
    value = default

# Best: use what's already there
value = d.get("key", default)

def divide(a, b):
    assert b != 0, "Divisor can't be zero"
    return a / b

assert user.is_admin        # ❌ may be stripped in production = security hole
if not user.is_admin:       # ✅
    raise PermissionError()

f = open("data.txt")
data = f.read()
f.close()

try:
    result = compute()
except:
    pass

def safe_int(s, default=0):
    try:
        return int(s)
    except (ValueError, TypeError):
        return default

safe_int("42")     # 42
safe_int("abc")    # 0
safe_int(None)     # 0
safe_int("x", -1)  # -1

with open("data.txt", encoding="utf-8") as f:
    data = f.read()

import json
from pathlib import Path

class ConfigError(Exception):
    pass

def load_config(path, required_keys=("host", "port")):
    p = Path(path)
    try:
        text = p.read_text(encoding="utf-8")
    except FileNotFoundError:
        raise ConfigError(f"Config file not found: {p.absolute()}") from None

    try:
        config = json.loads(text)
    except json.JSONDecodeError as e:
        raise ConfigError(f"Config isn't valid JSON (line {e.lineno}): {e.msg}") from e

    missing = [k for k in required_keys if k not in config]
    if missing:
        raise ConfigError(f"Config is missing required keys: {', '.join(missing)}")

    return config

from contextlib import contextmanager

@contextmanager
def suppress_errors():
    try:
        yield
    except Exception as e:
        print(f"⚠️ Ignored error: {type(e).__name__}: {e}")

with suppress_errors():
    1 / 0
print("Still running")

class ShopError(Exception):
    """Base class for shop-related exceptions."""

class OutOfStockError(ShopError):
    def __init__(self, product):
        self.product = product
        super().__init__(f"Out of stock: {product}")

class PaymentError(ShopError):
    def __init__(self, amount, reason="unknown reason"):
        self.amount = amount
        super().__init__(f"Payment of {amount} failed: {reason}")

from pathlib import Path

p = Path("data/report.txt")

# Join paths with the / operator
base = Path("/home/user")
full = base / "documents" / "file.txt"      # /home/user/documents/file.txt

# Common attributes
p.name        # 'report.txt'   filename
p.stem        # 'report'       without the extension
p.suffix      # '.txt'         the extension
p.parent      # Path('data')   parent directory
p.parts       # ('data', 'report.txt')
p.absolute()  # absolute path

# Tests
p.exists()      # does it exist
p.is_file()     # is it a file
p.is_dir()      # is it a directory

# Special locations
Path.cwd()      # current working directory
Path.home()     # user's home directory
Path(__file__).parent    # the directory of the current script (extremely useful)

d = Path("output")
d.mkdir()                                # create; errors if it exists
d.mkdir(parents=True, exist_ok=True)     # create recursively, no error if present ← common

# Traversal
for f in d.iterdir():              # immediate children
    print(f)

for f in d.glob("*.txt"):          # match at this level
    print(f)

for f in d.rglob("*.py"):          # match recursively
    print(f)

# Files only
files = [f for f in d.rglob("*") if f.is_file()]

p.rename("newname.txt")
p.unlink()                    # delete a file
p.unlink(missing_ok=True)     # no error if absent
d.rmdir()                     # delete an empty directory

import shutil
shutil.copy("a.txt", "b.txt")       # copy a file
shutil.copytree("src", "dst")       # copy a directory tree
shutil.rmtree("dir")                # delete a directory and its contents ⚠️ irreversible
shutil.move("a", "b")               # move

text = Path("a.txt").read_text(encoding="utf-8")
Path("b.txt").write_text("content", encoding="utf-8")

data = Path("img.png").read_bytes()
Path("copy.png").write_bytes(data)

with open("file.txt", mode="r", encoding="utf-8") as f:
    ...

with open("data.txt", encoding="utf-8") as f:
    content = f.read()          # everything at once, as one string

with open("data.txt", encoding="utf-8") as f:
    lines = f.readlines()       # a list, one element per line (newlines retained)

with open("data.txt", encoding="utf-8") as f:
    for line in f:              # ✅ line by line, memory-friendly, required for big files
        print(line.rstrip())    # rstrip removes the trailing newline

with open("out.txt", "w", encoding="utf-8") as f:
    f.write("first line\n")           # write does NOT add a newline
    f.write("second line\n")
    f.writelines(["a\n", "b\n"])      # nor does this

# print is more convenient (adds newlines automatically)
with open("out.txt", "w", encoding="utf-8") as f:
    print("first line", file=f)
    print("second line", file=f)

import json

# Writing
data = {"name": "Alice", "tags": ["a", "b"], "age": 25}
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
    # ensure_ascii=False → non-ASCII text stays readable instead of \uXXXX
    # indent=2 → pretty-printed

# Reading
with open("data.json", encoding="utf-8") as f:
    data = json.load(f)

# String versions
s = json.dumps(data, ensure_ascii=False)
data = json.loads(s)

json.dumps(obj, default=str)             # blunt: stringify anything unrecognized
json.dumps({"d": date.today().isoformat()})   # convert explicitly

import csv

# Writing
rows = [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 30}]
with open("out.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "age"])
    writer.writeheader()
    writer.writerows(rows)

# Reading
with open("out.csv", newline="", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        print(row["name"], row["age"])    # row is a dict

# Binary serialization of Python objects (only in trusted contexts! pickle can execute code)
import pickle
pickle.dump(obj, open("f.pkl", "wb"))

# TOML (reading; built in since Python 3.11)
import tomllib
with open("pyproject.toml", "rb") as f:      # note "rb"
    config = tomllib.load(f)

# YAML needs a third-party library
# pip install pyyaml
import yaml
config = yaml.safe_load(open("config.yaml", encoding="utf-8"))

from pathlib import Path

for i, f in enumerate(sorted(Path("photos").glob("*.jpg")), start=1):
    f.rename(f.parent / f"photo_{i:03d}.jpg")

total = sum(f.stat().st_size for f in Path(".").rglob("*") if f.is_file())
print(f"{total / 1024 / 1024:.2f} MB")

for py in Path("src").rglob("*.py"):
    text = py.read_text(encoding="utf-8")
    if "TODO" in text:
        print(f"{py}: has todos")

from pathlib import Path

target = Path("important.json")
tmp = target.with_suffix(".json.tmp")
tmp.write_text(json.dumps(data), encoding="utf-8")
tmp.replace(target)      # atomic

with open("data.txt") as f:
    print(f.read())

from pathlib import Path

text = Path("data.txt").read_text(encoding="utf-8")
lines = text.splitlines()

print(f"Lines: {len(lines)}")
print(f"Words: {len(text.split())}")
print(f"Characters: {len(text)}")

from pathlib import Path

lines = Path("in.txt").read_text(encoding="utf-8").splitlines()
Path("out.txt").write_text("\n".join(reversed(lines)), encoding="utf-8")

from pathlib import Path

MB = 1024 * 1024
big = [f for f in Path(".").rglob("*") if f.is_file() and f.stat().st_size > MB]

for f in sorted(big, key=lambda p: p.stat().st_size, reverse=True):
    print(f"{f.stat().st_size / MB:8.2f} MB  {f}")

import csv, json
from pathlib import Path

contacts = json.loads(Path("contacts.json").read_text(encoding="utf-8"))

with open("contacts.csv", "w", newline="", encoding="utf-8-sig") as f:
    writer = csv.DictWriter(f, fieldnames=contacts[0].keys())
    writer.writeheader()
    writer.writerows(contacts)

with open("data.txt", encoding="utf-8") as f:
    print(f.read())

import json
from pathlib import Path

def load_json(path, default=None):
    if default is None:
        default = {}
    try:
        return json.loads(Path(path).read_text(encoding="utf-8"))
    except (FileNotFoundError, json.JSONDecodeError, UnicodeDecodeError) as e:
        print(f"⚠️ Couldn't read {path} ({type(e).__name__}); using the default")
        return default

student = {"name": "Alice", "scores": [85, 92, 78]}

def average(s):
    return sum(s["scores"]) / len(s["scores"])

class Student:
    def __init__(self, name):
        self.name = name
        self.scores = []

    def add_score(self, score):
        self.scores.append(score)

    def average(self):
        if not self.scores:
            return 0
        return sum(self.scores) / len(self.scores)


s = Student("Alice")
s.add_score(85)
s.add_score(92)
print(s.average())      # 88.5

class Dog:
    species = "Canis familiaris"     # class attribute: shared by all instances

    def __init__(self, name, age):   # constructor
        self.name = name             # instance attributes: unique per instance
        self.age = age

    def bark(self):                  # instance method
        return f"{self.name} says woof"

    def birthday(self):
        self.age += 1
        return self.age


d = Dog("Rex", 3)       # creating an instance calls __init__ automatically
d.name                  # 'Rex'
d.bark()                # 'Rex says woof'
d.species               # 'Canis familiaris'
Dog.species             # accessible through the class too

d.bark()          # what Python actually runs is Dog.bark(d)

class Dog:
    def bark():                 # ❌ TypeError: bark() takes 0 positional arguments but 1 was given
        return "woof"

class Counter:
    total = 0                  # class attribute, shared

    def __init__(self):
        Counter.total += 1
        self.id = Counter.total   # instance attribute, independent

a = Counter()
b = Counter()
print(Counter.total)     # 2
print(a.id, b.id)        # 1 2

class Basket:
    items = []              # ❌ every instance shares one list!

    def add(self, x):
        self.items.append(x)

a, b = Basket(), Basket()
a.add("apple")
print(b.items)           # ['apple']  ← b changed too

class Basket:
    def __init__(self):
        self.items = []      # ✅ a fresh list per instance

class Circle:
    PI = 3.14159

    def __init__(self, radius):
        self.radius = radius

    def area(self):                       # instance method: operates on an instance
        return self.PI * self.radius ** 2

    @classmethod
    def from_diameter(cls, d):            # class method: first arg is the class
        return cls(d / 2)                 # typically an alternative constructor

    @staticmethod
    def is_valid_radius(r):               # static method: unrelated to class or instance
        return r > 0                      # just logically grouped here


c1 = Circle(5)
c2 = Circle.from_diameter(10)             # same as Circle(5)
Circle.is_valid_radius(-1)                # False

class Account:
    def __init__(self, balance):
        self.owner = "Alice"         # public: use freely
        self._balance = balance      # single underscore: internal, please don't touch
        self.__pin = "1234"          # double underscore: name mangling, a stronger "keep out"

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self._balance += amount

a = Account(100)
a._balance           # accessible, but you shouldn't
a.__pin              # AttributeError
a._Account__pin      # '1234' — still reachable, so it isn't "secure"

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero")
        self._celsius = value

    @property
    def fahrenheit(self):            # read-only computed property
        return self._celsius * 9 / 5 + 32


t = Temperature(25)
t.celsius          # 25      accessed like an attribute, actually a method call
t.celsius = 30     # invokes the setter, which validates
t.fahrenheit       # 86.0    computed
t.fahrenheit = 100 # AttributeError: no setter
t.celsius = -300   # ValueError

# ❌ Java style, unnecessary in Python
class Person:
    def get_name(self): return self._name
    def set_name(self, v): self._name = v

# ✅ Python style: just use a plain attribute
class Person:
    def __init__(self, name):
        self.name = name

class Student:
    grades = []
    def add_grade(self, g):
        self.grades.append(g)

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

    @property
    def is_square(self):
        return self.width == self.height

class Student:
    def __init__(self):
        self.grades = []
    def add_grade(self, g):
        self.grades.append(g)

class InsufficientFunds(Exception):
    pass

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance
        self._history = []

    @property
    def balance(self):
        return self._balance

    @property
    def history(self):
        return tuple(self._history)      # immutable copy, so callers can't tamper

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError(f"Deposit must be positive, got {amount}")
        self._balance += amount
        self._history.append(("deposit", amount))

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError(f"Withdrawal must be positive, got {amount}")
        if amount > self._balance:
            raise InsufficientFunds(f"Balance {self._balance} can't cover {amount}")
        self._balance -= amount
        self._history.append(("withdraw", amount))

    @classmethod
    def from_dict(cls, data):
        return cls(data["owner"], data.get("balance", 0))

class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        if self.is_empty():
            raise IndexError("pop from an empty stack")
        return self._items.pop()

    def peek(self):
        if self.is_empty():
            raise IndexError("peek at an empty stack")
        return self._items[-1]

    def is_empty(self):
        return len(self._items) == 0

    def size(self):
        return len(self._items)

    def __len__(self):              # so len(stack) works too
        return len(self._items)

    def __repr__(self):
        return f"Stack({self._items})"

class Circle:
    def __init__(self, radius):
        self.radius = radius        # this already triggers the setter's validation

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError(f"Radius must be positive, got {value}")
        self._radius = value

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "..."

    def describe(self):
        return f"{self.name} says: {self.speak()}"


class Dog(Animal):              # Dog inherits from Animal
    def speak(self):            # override the parent's method
        return "Woof"


class Cat(Animal):
    def speak(self):
        return "Meow"


Dog("Rex").describe()       # 'Rex says: Woof'
Cat("Whiskers").describe()  # 'Whiskers says: Meow'

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)     # let the parent initialize first
        self.breed = breed              # then add your own

class LoggedList(list):
    def append(self, item):
        print(f"Adding: {item}")
        super().append(item)            # call list's original append

animals = [Dog("Rex"), Cat("Whiskers"), Animal("Generic")]

for a in animals:
    print(a.speak())        # each object responds according to its own type

class Duck:
    def speak(self): return "Quack"

class Robot:                       # completely unrelated to Animal
    def speak(self): return "Beep"

for x in [Dog("Rex"), Robot()]:
    print(x.speak())               # both work

isinstance(d, Dog)          # True
isinstance(d, Animal)       # True   — a subclass instance is also a parent instance
isinstance(d, (Dog, Cat))   # True   — a tuple works

issubclass(Dog, Animal)     # True
type(d) is Dog              # True   — exact type, ignores inheritance

# ❌ Every new animal means editing this function
def make_sound(animal):
    if isinstance(animal, Dog):
        return "Woof"
    elif isinstance(animal, Cat):
        return "Meow"

# ✅ Polymorphism: new animals need no change here
def make_sound(animal):
    return animal.speak()

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        ...

    @abstractmethod
    def perimeter(self):
        ...

    def describe(self):                  # concrete methods are allowed
        return f"Area {self.area()}, perimeter {self.perimeter()}"


class Rectangle(Shape):
    def __init__(self, w, h):
        self.w, self.h = w, h
    def area(self):
        return self.w * self.h
    def perimeter(self):
        return 2 * (self.w + self.h)


Shape()          # TypeError: Can't instantiate abstract class Shape
Rectangle(3, 4).describe()   # 'Area 12, perimeter 14'

class Serializable:
    def to_json(self):
        import json
        return json.dumps(self.__dict__)

class Comparable:
    def __lt__(self, other):
        return self.value < other.value

class Item(Serializable, Comparable):
    def __init__(self, value):
        self.value = value

Item.__mro__
# (Item, Serializable, Comparable, object)

# ❌ Inheritance: is a Car an Engine? No.
class Car(Engine): ...

# ✅ Composition: a Car has an Engine
class Car:
    def __init__(self):
        self.engine = Engine()

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self, breed):
        self.breed = breed

dog = Dog("Shiba")
print(dog.name)

class Employee:
    def __init__(self, name, base_salary):
        self.name = name
        self.base_salary = base_salary

    def calculate_pay(self):
        return self.base_salary

    def __repr__(self):
        return f"{type(self).__name__}({self.name}, {self.calculate_pay():.0f})"


class Manager(Employee):
    def __init__(self, name, base_salary, bonus=0):
        super().__init__(name, base_salary)
        self.bonus = bonus

    def calculate_pay(self):
        return self.base_salary * 1.5 + self.bonus


class Intern(Employee):
    def calculate_pay(self):
        return self.base_salary * 0.6


staff = [Manager("Alice", 20000, 5000), Intern("Bob", 10000), Employee("Carol", 15000)]
for e in staff:
    print(e)

import json
from abc import ABC, abstractmethod
from pathlib import Path

class Storage(ABC):
    @abstractmethod
    def save(self, key, value): ...

    @abstractmethod
    def load(self, key): ...


class MemoryStorage(Storage):
    def __init__(self):
        self._data = {}
    def save(self, key, value):
        self._data[key] = value
    def load(self, key):
        return self._data.get(key)


class FileStorage(Storage):
    def __init__(self, path):
        self.path = Path(path)
        if not self.path.exists():
            self.path.write_text("{}", encoding="utf-8")

    def _read(self):
        return json.loads(self.path.read_text(encoding="utf-8"))

    def save(self, key, value):
        data = self._read()
        data[key] = value
        self.path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")

    def load(self, key):
        return self._read().get(key)

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

class Service:
    def __init__(self, logger):
        self.logger = logger        # composition — inject any logger you like

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):                      # the developer-facing representation
        return f"Vector({self.x}, {self.y})"

    def __str__(self):                       # the user-facing representation
        return f"({self.x}, {self.y})"

    def __eq__(self, other):                 # ==
        if not isinstance(other, Vector):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):                      # define __hash__ whenever you define __eq__
        return hash((self.x, self.y))

    def __add__(self, other):                # +
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, scalar):               # *
        return Vector(self.x * scalar, self.y * scalar)

    def __abs__(self):                       # abs()
        return (self.x ** 2 + self.y ** 2) ** 0.5

    def __len__(self):                       # len()
        return 2

    def __getitem__(self, i):                # v[0]
        return (self.x, self.y)[i]

    def __bool__(self):                      # if v:
        return bool(self.x or self.y)


v1 = Vector(1, 2)
v2 = Vector(3, 4)

v1 + v2          # Vector(4, 6)
v1 * 3           # Vector(3, 6)
abs(v2)          # 5.0
v1 == Vector(1, 2)   # True
len(v1)          # 2
v1[0]            # 1
print(v1)        # (1, 2)       — uses __str__
v1               # Vector(1, 2) — the REPL uses __repr__

__repr__(self)      # repr(x) — for debugging; ideally reconstructs the object
__str__(self)       # str(x), print(x) — for humans
__format__(self, spec)   # f"{x:spec}"

__eq__  __ne__  __lt__  __le__  __gt__  __ge__

__add__  __sub__  __mul__  __truediv__  __floordiv__  __mod__  __pow__
__radd__ ...     # reflected operations (3 * vector calls vector.__rmul__)
__iadd__ ...     # in-place operations (+=)
__neg__  __abs__

__len__(self)               # len(x)
__getitem__(self, key)      # x[key]
__setitem__(self, key, v)   # x[key] = v
__delitem__(self, key)      # del x[key]
__contains__(self, item)    # item in x
__iter__(self)              # for i in x
__next__(self)              # the iterator protocol

__call__(self, ...)         # make instances callable like functions: x()
__enter__ / __exit__        # the with statement
__hash__(self)              # usable as a dict key / set member
__bool__(self)              # if x:
__getattr__(self, name)     # fallback for missing attributes
__slots__ = ("x", "y")      # restrict attributes, save memory

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p = Point(1, 2)
p                    # Point(x=1, y=2)      __repr__ generated
p == Point(1, 2)     # True                 __eq__ generated

from dataclasses import dataclass, field

@dataclass(frozen=True)      # immutable, and __hash__ is generated
class Config:
    host: str = "localhost"          # with defaults
    port: int = 8080
    tags: list[str] = field(default_factory=list)   # ⚠️ mutable defaults need field
    _secret: str = field(default="", repr=False)     # excluded from repr


@dataclass(order=True)       # generates < > <= >=, comparing fields in order
class Version:
    major: int
    minor: int

@dataclass
class Rectangle:
    width: float
    height: float
    area: float = field(init=False)      # not a constructor parameter

    def __post_init__(self):
        self.area = self.width * self.height

from dataclasses import asdict, astuple, replace

asdict(p)                  # {'x': 1, 'y': 2}
astuple(p)                 # (1, 2)
replace(p, x=10)           # Point(x=10, y=2)  returns a new instance

# typing.NamedTuple — an annotated immutable record
from typing import NamedTuple
class Point(NamedTuple):
    x: float
    y: float

# pydantic (third party: pip install pydantic) — actually validates and coerces
from pydantic import BaseModel
class User(BaseModel):
    name: str
    age: int
User(name="Alice", age="25")     # age is coerced to int 25
User(name="Alice", age="abc")    # ValidationError

from enum import Enum, auto

class Status(Enum):
    PENDING = "pending"
    ACTIVE = "active"
    CLOSED = "closed"

Status.ACTIVE            # <Status.ACTIVE: 'active'>
Status.ACTIVE.value      # 'active'
Status.ACTIVE.name       # 'ACTIVE'
Status("active")         # <Status.ACTIVE: 'active'>  lookup by value

for s in Status:         # iterable
    print(s)

class Color(Enum):
    RED = auto()         # auto-assigns 1, 2, 3
    GREEN = auto()
    BLUE = auto()

from enum import StrEnum       # Python 3.11+, members usable directly as strings
class Env(StrEnum):
    DEV = "dev"
    PROD = "prod"

Env.DEV == "dev"         # True

# ❌ Magic string
if order.status == "actve":     # typo, silently never matches

# ✅ Enum
if order.status is Status.ACTIVE:   # a typo raises AttributeError

def get_discount(user_type):
    if user_type == "vip":
        return 0.8
    elif user_type == "svip":
        return 0.6
    return 1.0

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, k):
        return Vector(self.x * k, self.y * k)

    __rmul__ = __mul__          # scalar multiplication commutes, so reuse it

from dataclasses import dataclass, field

@dataclass
class Book:
    title: str
    author: str
    year: int
    tags: list[str] = field(default_factory=list)
    isbn: str = field(default="", repr=False)

from dataclasses import dataclass
from decimal import Decimal

@dataclass(frozen=True, order=True)
class Money:
    amount: Decimal
    currency: str = "USD"

    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError(f"Currency mismatch: {self.currency} vs {other.currency}")
        return Money(self.amount + other.amount, self.currency)

    def __str__(self):
        return f"{self.amount:.2f} {self.currency}"


a = Money(Decimal("10.50"))
b = Money(Decimal("5.25"))
print(a + b)      # 15.75 USD

class Playlist:
    def __init__(self, songs=None):
        self._songs = list(songs or [])

    def add(self, song):
        self._songs.append(song)

    def __len__(self):
        return len(self._songs)

    def __getitem__(self, i):
        return self._songs[i]

    def __iter__(self):
        return iter(self._songs)

    def __contains__(self, song):
        return song in self._songs

    def __repr__(self):
        return f"Playlist({len(self)} songs)"

from enum import Enum

class UserType(Enum):
    NORMAL = "normal"
    VIP = "vip"
    SVIP = "svip"

DISCOUNTS = {
    UserType.NORMAL: 1.0,
    UserType.VIP: 0.8,
    UserType.SVIP: 0.6,
}

def get_discount(user_type: UserType) -> float:
    return DISCOUNTS[user_type]

lst = [1, 2, 3]
it = iter(lst)         # get an iterator from an iterable

next(it)               # 1
next(it)               # 2
next(it)               # 3
next(it)               # raises StopIteration

# for x in lst: print(x)
# is equivalent to:
it = iter(lst)
while True:
    try:
        x = next(it)
    except StopIteration:
        break
    print(x)

it = iter([1, 2, 3])
list(it)     # [1, 2, 3]
list(it)     # []  ← already exhausted

z = zip([1,2], "ab")
list(z)      # [(1, 'a'), (2, 'b')]
list(z)      # []  ← zip returns an iterator!

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        return CountdownIterator(self.start)


class CountdownIterator:
    def __init__(self, current):
        self.current = current

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1


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

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for x in countdown(3):
    print(x)      # 3 2 1

def demo():
    print("start")
    yield 1
    print("middle")
    yield 2
    print("end")

g = demo()          # prints nothing
next(g)             # prints "start", returns 1
next(g)             # prints "middle", returns 2
next(g)             # prints "end", raises StopIteration

# ❌ Builds ten million numbers at once, hundreds of MB
def squares_list(n):
    return [i ** 2 for i in range(n)]

# ✅ One at a time, constant memory
def squares_gen(n):
    for i in range(n):
        yield i ** 2

sum(squares_gen(10_000_000))    # essentially zero memory

def naturals():
    n = 0
    while True:
        yield n
        n += 1

from itertools import islice
list(islice(naturals(), 5))     # [0, 1, 2, 3, 4]

def read_large_file(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.rstrip()

def filter_errors(lines):
    for line in lines:
        if "ERROR" in line:
            yield line

def parse(lines):
    for line in lines:
        yield line.split("|")

# A pipeline that never holds more than one line in memory
for parts in parse(filter_errors(read_large_file("huge.log"))):
    print(parts)

def chain(*iterables):
    for it in iterables:
        yield from it              # same as: for x in it: yield x

list(chain([1, 2], "ab"))          # [1, 2, 'a', 'b']

def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

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

from itertools import (count, cycle, repeat, chain, islice,
                       groupby, product, permutations, combinations,
                       accumulate, takewhile, dropwhile, tee, zip_longest)

# Infinite iterators
count(10, 2)                 # 10, 12, 14, ...
cycle("ABC")                 # A B C A B C ...
repeat("x", 3)               # x x x

# Combining
chain([1,2], [3,4])          # 1 2 3 4
islice(range(100), 5, 10)    # 5 6 7 8 9   (slicing for arbitrary iterators)
zip_longest([1,2], "abc", fillvalue=None)   # (1,'a') (2,'b') (None,'c')

# Combinatorics
list(product("AB", repeat=2))       # AA AB BA BB
list(permutations("ABC", 2))        # AB AC BA BC CA CB
list(combinations("ABC", 2))        # AB AC BC

# Accumulation
list(accumulate([1, 2, 3, 4]))            # [1, 3, 6, 10]  running sum
list(accumulate([1, 2, 3], func=max))     # running maximum

# Conditional slicing
list(takewhile(lambda x: x < 3, [1,2,3,1]))   # [1, 2]  stops at the first false
list(dropwhile(lambda x: x < 3, [1,2,3,1]))   # [3, 1]  skips the leading run

# Grouping (⚠️ you must sort by the same key first!)
data = sorted(people, key=lambda p: p["city"])
for city, group in groupby(data, key=lambda p: p["city"]):
    print(city, list(group))

def accumulator():
    total = 0
    while True:
        value = yield total
        if value is None:
            break
        total += value

acc = accumulator()
next(acc)          # prime it, returns 0
acc.send(10)       # 10
acc.send(5)        # 15

data = zip([1,2,3], "abc")
print(list(data))
print(list(data))

sum([x**2 for x in range(10**7)])
sum(x**2 for x in range(10**7))

from itertools import islice

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

list(islice(fibonacci(), 10))    # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

from itertools import islice

def chunks(iterable, size):
    it = iter(iterable)
    while chunk := list(islice(it, size)):
        yield chunk

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

from itertools import batched
list(batched([1,2,3,4,5], 2))    # [(1, 2), (3, 4), (5,)]

data = list(zip([1,2,3], "abc"))

from itertools import islice

def error_lines(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            if "ERROR" in line:
                yield line.rstrip()

for line in islice(error_lines("app.log"), 100):
    print(line)

def my_decorator(func):
    def wrapper():
        print("before")
        func()
        print("after")
    return wrapper


@my_decorator
def say_hello():
    print("Hello")

say_hello()
# before
# Hello
# after

say_hello = my_decorator(say_hello)

import functools

def my_decorator(func):
    @functools.wraps(func)                    # preserve the original's metadata
    def wrapper(*args, **kwargs):             # accept anything
        print(f"calling {func.__name__}")
        result = func(*args, **kwargs)        # forward it all
        print(f"returned {result}")
        return result                         # don't forget this!
    return wrapper


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

add(1, 2)

add.__name__     # with wraps → 'add'; without → 'wrapper'

import time, functools

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        try:
            return func(*args, **kwargs)
        finally:
            print(f"{func.__name__} took {time.perf_counter() - start:.4f}s")
    return wrapper

def retry(times=3, delay=1, exceptions=(Exception,)):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last = None
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    last = e
                    print(f"Attempt {attempt}/{times} failed: {e}")
                    if attempt < times:
                        time.sleep(delay)
            raise last
        return wrapper
    return decorator


@retry(times=3, delay=2, exceptions=(ConnectionError,))
def fetch(url):
    ...

import logging

def logged(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        logging.info("calling %s(%r, %r)", func.__name__, args, kwargs)
        try:
            result = func(*args, **kwargs)
            logging.info("%s returned %r", func.__name__, result)
            return result
        except Exception:
            logging.exception("%s raised", func.__name__)
            raise
    return wrapper

from functools import cache, lru_cache

@cache                        # Python 3.9+, unbounded cache
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

fib(100)          # instant; without caching it would run forever

@lru_cache(maxsize=128)       # bounded; evicts the least recently used
def expensive_query(user_id):
    ...

expensive_query.cache_info()      # hit rate
expensive_query.cache_clear()     # reset

from functools import cached_property

class Dataset:
    @cached_property
    def stats(self):
        print("computing...")        # prints only once
        return heavy_computation(self.data)

d = Dataset()
d.stats     # computing... then returns
d.stats     # returns the cache

from functools import singledispatch

@singledispatch
def describe(obj):
    return f"Unknown type: {obj}"

@describe.register
def _(obj: int):
    return f"Integer {obj}"

@describe.register
def _(obj: list):
    return f"List with {len(obj)} items"

describe(42)        # 'Integer 42'
describe([1,2])     # 'List with 2 items'

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)


@CountCalls
def hello():
    print("hi")

hello(); hello()
hello.count        # 2

def add_repr(cls):
    def __repr__(self):
        attrs = ", ".join(f"{k}={v!r}" for k, v in vars(self).items())
        return f"{cls.__name__}({attrs})"
    cls.__repr__ = __repr__
    return cls


@add_repr
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

Point(1, 2)        # Point(x=1, y=2)

@a
@b
@c
def f(): ...

# equivalent to f = a(b(c(f)))

@app.route("/users")       # routing must be outermost
@login_required            # check auth first
@timer                     # then time it
def get_users(): ...

def logger(func):
    def wrapper(*args):
        print(f"calling {func.__name__}")
        func(*args)
    return wrapper

def count_paths(m, n):
    if m == 1 or n == 1:
        return 1
    return count_paths(m-1, n) + count_paths(m, n-1)

import functools

def debug(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        sig = ", ".join([*map(repr, args), *(f"{k}={v!r}" for k, v in kwargs.items())])
        print(f"→ {func.__name__}({sig})")
        result = func(*args, **kwargs)
        print(f"← {func.__name__} returned {result!r}")
        return result
    return wrapper

def validate_positive(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        for i, a in enumerate(args):
            if isinstance(a, (int, float)) and a <= 0:
                raise ValueError(f"{func.__name__} argument {i+1} must be positive, got {a}")
        return func(*args, **kwargs)
    return wrapper

def logger(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

import time, functools

def rate_limit(calls_per_second=2):
    min_interval = 1.0 / calls_per_second
    def decorator(func):
        last_called = 0.0
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            nonlocal last_called
            elapsed = time.perf_counter() - last_called
            if elapsed < min_interval:
                time.sleep(min_interval - elapsed)
            last_called = time.perf_counter()
            return func(*args, **kwargs)
        return wrapper
    return decorator

from functools import cache

@cache
def count_paths(m, n):
    if m == 1 or n == 1:
        return 1
    return count_paths(m-1, n) + count_paths(m, n-1)

count_paths(18, 18)    # instant

name: str = "Alice"
age: int = 25
scores: list[int] = [90, 85]

def greet(name: str, times: int = 1) -> str:
    return f"Hello, {name}! " * times

def add(a: int, b: int) -> int:
    return a + b

add("x", "y")     # 'xy' — runs fine; Python doesn't care

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

# Basic types are written directly
x: int
y: float
s: str
b: bool

# Containers (Python 3.9+ uses the built-in types; no more from typing import List)
nums: list[int]
pairs: dict[str, int]
point: tuple[float, float]           # fixed length, different types per position
row: tuple[int, ...]                 # arbitrary length, uniform type
tags: set[str]

# Possibly None
name: str | None = None              # Python 3.10+, preferred
name: Optional[str] = None           # older form, equivalent

# One of several types
value: int | str
value: Union[int, str]               # older form

# Function types
handler: Callable[[int, str], bool]  # takes int and str, returns bool
callback: Callable[..., None]        # any arguments, returns None

# Anything (effectively turns checking off — use sparingly)
data: Any

from typing import TypeVar

T = TypeVar("T")

def first(items: list[T]) -> T | None:
    return items[0] if items else None

first([1, 2, 3])       # the checker knows this returns int | None
first(["a", "b"])      # and this returns str | None

def first[T](items: list[T]) -> T | None:
    return items[0] if items else None

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int
    email: str | None = None

    def is_adult(self) -> bool:
        return self.age >= 18

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> None: ...

def render(item: Drawable) -> None:      # any object with a draw method qualifies
    item.draw()

type UserId = int                        # Python 3.12+
type JsonValue = dict[str, "JsonValue"] | list["JsonValue"] | str | int | float | bool | None

UserId = int                             # older form

from typing import NoReturn

def fail(msg: str) -> NoReturn:          # never returns normally
    raise RuntimeError(msg)

def gen() -> Iterator[int]:              # a generator
    yield 1

def process(user):          # the IDE has no idea what user has
    user.          # ← no suggestions

def process(user: User):    # now it knows
    user.          # ← name, age, is_adult...

# Can you tell what this does without reading the body?
def calc(a, b, c): ...

# Obvious
def calculate_discount(price: Decimal, rate: float, is_vip: bool) -> Decimal: ...

pip install mypy
mypy your_file.py

[tool.mypy]
python_version = "3.12"
strict = true                    # recommended for new projects
warn_return_any = true
warn_unused_ignores = true

[[tool.mypy.overrides]]
module = "some_untyped_lib.*"
ignore_missing_imports = true

result = weird_call()  # type: ignore[attr-defined]

from pydantic import BaseModel, Field, field_validator

class User(BaseModel):
    name: str = Field(min_length=1, max_length=50)
    age: int = Field(ge=0, le=150)
    email: str

    @field_validator("email")
    @classmethod
    def check_email(cls, v: str) -> str:
        if "@" not in v:
            raise ValueError("Invalid email format")
        return v


User(name="Alice", age=25, email="[email protected]")     # ✅
User(name="", age=200, email="bad")             # ValidationError listing every problem

def find_users(names, min_age=0, active_only=True):
    return [u for u in database if u.name in names]

def get_config() -> dict:
    return {"host": "localhost", "port": 8080}

from collections.abc import Sequence

def find_users(
    names: Sequence[str],
    min_age: int = 0,
    active_only: bool = True,
) -> list[User]:
    return [u for u in database if u.name in names]

d: dict[str, list[int]]
s: str | None
f: Callable[[str], bool]
records: list[tuple[str, int, bool]]

def get_config() -> dict[str, str | int]: ...

# Better: make the structure explicit with TypedDict or a dataclass
from typing import TypedDict

class Config(TypedDict):
    host: str
    port: int

def get_config() -> Config: ...

from typing import Protocol, Any

class Serializable(Protocol):
    def to_dict(self) -> dict[str, Any]: ...


def save_all(items: list[Serializable]) -> None:
    for item in items:
        write(item.to_dict())

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

now = datetime.now()                    # local time
utc = datetime.now(timezone.utc)        # UTC (use this for storage)
today = date.today()

# Constructing
d = date(2026, 7, 26)
dt = datetime(2026, 7, 26, 14, 30, 0)

# Formatting
now.strftime("%Y-%m-%d %H:%M:%S")       # '2026-07-26 14:30:00'
now.isoformat()                         # '2026-07-26T14:30:00.123456'

# Parsing
datetime.strptime("2026-07-26", "%Y-%m-%d")
datetime.fromisoformat("2026-07-26T14:30:00")

# Arithmetic
tomorrow = today + timedelta(days=1)
delta = date(2026, 12, 31) - today
delta.days                              # days remaining

# Timestamps
now.timestamp()                         # 1785…
datetime.fromtimestamp(1785000000)

from zoneinfo import ZoneInfo

berlin = datetime.now(ZoneInfo("Europe/Berlin"))
utc_time = berlin.astimezone(timezone.utc)

import time

time.time()               # Unix timestamp (affected by clock adjustments)
time.perf_counter()       # high-resolution; use this to measure durations
time.monotonic()          # monotonic clock, never goes backwards
time.sleep(1.5)           # pause

# Timing a block
start = time.perf_counter()
do_work()
print(f"{time.perf_counter() - start:.4f}s")

import timeit
timeit.timeit("'-'.join(str(n) for n in range(100))", number=10000)

import random

random.random()                     # a float in [0.0, 1.0)
random.randint(1, 6)                # an int from 1 to 6 (both inclusive)
random.randrange(0, 10, 2)          # one of 0,2,4,6,8
random.uniform(1.5, 3.5)            # a float in a range
random.choice(["a", "b", "c"])      # pick one
random.choices(items, k=3)          # pick 3 with replacement
random.choices(items, weights=[1,5,2], k=3)   # weighted
random.sample(items, 3)             # pick 3 without replacement
random.shuffle(lst)                 # shuffle in place

random.seed(42)                     # fixed seed for reproducibility (handy in tests)

import secrets

secrets.token_hex(16)               # '3d8f2a...'  random hex string
secrets.token_urlsafe(32)           # URL-safe random string
secrets.choice(alphabet)            # secure random choice
secrets.compare_digest(a, b)        # constant-time comparison, resists timing attacks

import math

math.pi, math.e, math.inf, math.nan
math.sqrt(16)          # 4.0
math.floor(3.7)        # 3    round down
math.ceil(3.2)         # 4    round up
math.trunc(-3.7)       # -3   truncate toward zero
math.factorial(5)      # 120
math.gcd(12, 18)       # 6    greatest common divisor
math.lcm(4, 6)         # 12   least common multiple (3.9+)
math.log(100, 10)      # 2.0
math.hypot(3, 4)       # 5.0  Euclidean distance
math.isclose(a, b)     # approximate float comparison
math.isnan(x), math.isinf(x)
math.comb(5, 2)        # 10   combinations
math.dist((0,0), (3,4))  # 5.0

import statistics as st

st.mean([1,2,3,4])       # 2.5
st.median([1,2,3,4])     # 2.5
st.mode([1,1,2])         # 1
st.stdev([1,2,3,4])      # sample standard deviation
st.pstdev([1,2,3,4])     # population standard deviation
st.quantiles(data, n=4)  # quartiles

import os, sys, platform

os.environ.get("HOME")           # read an environment variable
os.environ["MY_VAR"] = "x"       # set one (affects this process only)
os.cpu_count()                   # number of CPUs
os.getpid()                      # process ID

sys.argv                         # command-line arguments; argv[0] is the script name
sys.exit(1)                      # exit; non-zero signals failure
sys.platform                     # 'darwin' / 'win32' / 'linux'
sys.version_info                 # (3, 14, 6, 'final', 0)
sys.stdout, sys.stderr, sys.stdin

platform.system()                # 'Darwin' / 'Windows' / 'Linux'

import subprocess

# Recommended: pass a list (escaping handled), check the exit code, capture output
result = subprocess.run(
    ["git", "status", "--short"],
    capture_output=True,
    text=True,                  # treat output as str rather than bytes
    check=True,                 # raise if the exit code is non-zero
)
print(result.stdout)

subprocess.run(f"rm {filename}", shell=True)     # ❌ filename="; rm -rf /" ends your day
subprocess.run(["rm", filename])                 # ✅

import argparse

parser = argparse.ArgumentParser(description="Batch-process files")
parser.add_argument("input", help="input file path")
parser.add_argument("-o", "--output", default="out.txt", help="output path")
parser.add_argument("-v", "--verbose", action="store_true", help="verbose output")
parser.add_argument("-n", "--count", type=int, default=10)
parser.add_argument("--mode", choices=["fast", "safe"], default="safe")

args = parser.parse_args()
print(args.input, args.output, args.verbose)

import textwrap, string, difflib, unicodedata

textwrap.fill(long_text, width=70)       # wrap to a width
textwrap.dedent(indented_text)           # strip common indentation (great for multiline strings)
textwrap.shorten(text, width=50)         # truncate with an ellipsis

string.ascii_lowercase                   # 'abcdefghijklmnopqrstuvwxyz'
string.digits, string.punctuation

difflib.get_close_matches("aple", ["apple", "banana"])   # ['apple'] fuzzy matching
difflib.unified_diff(lines1, lines2)                     # generate a diff

import json, csv, sqlite3, pickle, base64, hashlib, uuid

# Hashing
hashlib.sha256(b"hello").hexdigest()
hashlib.md5(data).hexdigest()            # ⚠️ md5 is broken; never use it for passwords

# Password storage requires a purpose-built algorithm (third-party)
# pip install argon2-cffi  or  bcrypt

# UUIDs
uuid.uuid4()                             # random unique ID
str(uuid.uuid4())                        # 'f47ac10b-58cc-...'

# Base64
base64.b64encode(b"data").decode()
base64.b64decode("ZGF0YQ==")

# SQLite (a zero-config local database, included in the stdlib)
conn = sqlite3.connect("app.db")
conn.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
conn.execute("INSERT INTO users (name) VALUES (?)", ("Alice",))   # ⚠️ always parameterize
conn.commit()
for row in conn.execute("SELECT * FROM users"):
    print(row)
conn.close()

import urllib.request, urllib.parse

# The stdlib works, but it's verbose
with urllib.request.urlopen("https://api.example.com/data") as r:
    data = json.loads(r.read())

urllib.parse.urlencode({"q": "python", "page": 1})    # 'q=python&page=1'
urllib.parse.quote("some text")                       # URL encoding

# pip install httpx
import httpx

r = httpx.get("https://api.example.com/data", params={"q": "python"}, timeout=10)
r.raise_for_status()
data = r.json()

# POST JSON
r = httpx.post(url, json={"name": "Alice"}, headers={"Authorization": "Bearer ..."})

import functools, operator

functools.reduce(operator.add, [1,2,3,4])     # 10  (just use sum here)
functools.partial(int, base=2)("1010")        # 10  freeze some arguments

operator.itemgetter(1)                        # get index 1, for key=
operator.attrgetter("name")                   # get an attribute
operator.methodcaller("upper")                # call a method

from functools import partial

# Create a pre-configured function
save_json = partial(json.dump, ensure_ascii=False, indent=2)
save_json(data, f)      # no need to repeat those two arguments every time

import copy            # deepcopy
import glob            # file globbing (pathlib.glob is nicer)
import tempfile        # temp files and directories
import zipfile, tarfile, gzip     # compression
import shutil          # high-level file operations
import warnings        # emit warnings
import inspect         # runtime object introspection (for writing frameworks)
import weakref         # weak references
import decimal, fractions         # exact numerics
import heapq           # heaps / priority queues
import bisect          # binary search on sorted lists
import array           # compact numeric arrays
import struct          # binary packing
import html, xml       # markup languages
import email, smtplib  # email
import calendar        # calendars
import pprint          # pretty-print nested structures

import heapq
heapq.nlargest(3, data, key=lambda x: x["score"])
heapq.nsmallest(3, data)

import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
    path = Path(tmpdir) / "work.txt"
    ...    # the whole directory is deleted when the with block exits

import subprocess
filename = input("Filename: ")
subprocess.run(f"cat {filename}", shell=True)

from datetime import date

today = date.today()
year_end = date(today.year, 12, 31)
print(f"{(year_end - today).days} days left in {today.year}")

import secrets, string

alphabet = string.ascii_letters + string.digits
password = "".join(secrets.choice(alphabet) for _ in range(12))
print(password)

import argparse
from pathlib import Path

parser = argparse.ArgumentParser(description="Count files")
parser.add_argument("directory", type=Path)
parser.add_argument("--ext", default="py", help="extension without the dot")
args = parser.parse_args()

files = list(args.directory.rglob(f"*.{args.ext}"))
print(f"{args.directory} contains {len(files)} .{args.ext} files")

import sqlite3
from contextlib import closing

def init(conn):
    conn.execute("""
        CREATE TABLE IF NOT EXISTS todos (
            id INTEGER PRIMARY KEY,
            title TEXT NOT NULL,
            done INTEGER DEFAULT 0
        )
    """)
    conn.commit()

def add(conn, title):
    conn.execute("INSERT INTO todos (title) VALUES (?)", (title,))
    conn.commit()

def list_all(conn):
    for row in conn.execute("SELECT id, title, done FROM todos ORDER BY id"):
        mark = "✓" if row[2] else " "
        print(f"[{mark}] {row[0]}. {row[1]}")

def complete(conn, todo_id):
    conn.execute("UPDATE todos SET done = 1 WHERE id = ?", (todo_id,))
    conn.commit()

with closing(sqlite3.connect("todo.db")) as conn:
    init(conn)
    add(conn, "Learn Python")
    add(conn, "Do the exercises")
    complete(conn, 1)
    list_all(conn)

import subprocess
filename = input("Filename: ")
subprocess.run(["cat", filename], check=True)     # ✅ no shell involved

from pathlib import Path
print(Path(filename).read_text(encoding="utf-8"))

import re

text = "My number is 555-1234-5678, backup 555-8765-4321"

re.search(r"\d{3}-\d{4}-\d{4}", text)      # first match; returns a Match or None
re.findall(r"\d{3}-\d{4}-\d{4}", text)     # all matches, as a list
re.finditer(r"\d+", text)                  # all matches, as an iterator (with positions)
re.sub(r"\d", "*", text)                   # substitute
re.split(r"[,;]", text)                    # split on a pattern
re.fullmatch(r"\d+", "123")                # the whole string must match
re.match(r"My", text)                      # match only at the start

m = re.search(r"(\d{3})-(\d{4})", text)
if m:
    m.group()      # '555-1234'   the whole match
    m.group(1)     # '555'        the first capture group
    m.group(2)     # '1234'
    m.groups()     # ('555', '1234')
    m.start()      # start position
    m.span()       # (13, 21)

.        any character (except newline)
\d       digit          \D  non-digit
\w       word char      \W  non-word
\s       whitespace     \S  non-whitespace
[abc]    a, b, or c
[^abc]   anything but a, b, c
[a-z]    a through z
[0-9a-fA-F]  hex characters

*        zero or more
+        one or more
?        zero or one
{3}      exactly 3
{2,5}    2 to 5
{2,}     at least 2
*?  +?  ??  {n,m}?    non-greedy versions (match as few as possible)

^        start of string (start of line in multiline mode)
$        end of string
\b       word boundary
\B       non-boundary

(...)         capture group
(?:...)       non-capturing group (groups without capturing; more efficient)
(?P<name>...) named group
(?=...)       positive lookahead (must be followed by)
(?!...)       negative lookahead (must not be followed by)
(?<=...)      positive lookbehind (must be preceded by)
(?<!...)      negative lookbehind
|             alternation

text = "<b>bold</b><i>italic</i>"

re.findall(r"<.*>", text)      # ['<b>bold</b><i>italic</i>']  greedy: runs to the end
re.findall(r"<.*?>", text)     # ['<b>', '</b>', '<i>', '</i>']  non-greedy ✅

# Email (simplified; a fully correct email regex is famously monstrous — validate with a library)
r"[\w.+-]+@[\w-]+\.[\w.]+"

# US phone number
r"\d{3}-\d{3}-\d{4}"

# URL
r"https?://[^\s]+"

# IPv4
r"\b(?:\d{1,3}\.){3}\d{1,3}\b"

# Date YYYY-MM-DD
r"\d{4}-\d{2}-\d{2}"

# CJK characters
r"[一-鿿]+"

# HTML tags (simple cases only; use Beautiful Soup to parse HTML)
r"<[^>]+>"

# Quoted content
r'"([^"]*)"'

# Named groups make this far more readable
pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
m = re.search(pattern, "Date: 2026-07-26")
m.group("year")      # '2026'
m.groupdict()        # {'year': '2026', 'month': '07', 'day': '26'}

# Referencing groups in a replacement
re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3/\2/\1", "2026-07-26")   # '26/07/2026'
re.sub(pattern, r"\g<day>/\g<month>/\g<year>", text)            # by name

# Replacing with a function (for complex logic)
def upper_match(m):
    return m.group().upper()

re.sub(r"\b\w{5,}\b", upper_match, "hello world hi")   # 'HELLO WORLD hi'

re.IGNORECASE  / re.I    # case-insensitive
re.MULTILINE   / re.M    # ^ and $ match at each line
re.DOTALL      / re.S    # . also matches newlines
re.VERBOSE     / re.X    # allow whitespace and comments

re.search(r"hello", text, re.IGNORECASE)

pattern = re.compile(r"""
    (\d{3})     # area code
    [-\s]?      # optional separator
    (\d{3})     # exchange
    [-\s]?
    (\d{4})     # line number
""", re.VERBOSE)

pattern = re.compile(r"\d+")

pattern.search(text)
pattern.findall(text)
pattern.sub("X", text)

# ❌ Regex on HTML/XML/JSON — these are nested structures regex can't express
re.findall(r"<div>(.*?)</div>", html)

# ✅ Use a real parser
from bs4 import BeautifulSoup      # HTML
import json                         # JSON
import csv                          # CSV

re.search(r"^abc", s)          → s.startswith("abc")
re.search(r"abc", s)           → "abc" in s
re.sub(r"abc", "x", s)         → s.replace("abc", "x")
re.split(r",", s)              → s.split(",")

r"(a+)+b"     # hangs on "aaaaaaaaaaaaaaaaaaaaac"

re.findall(r"<b>(.*)</b>", "<b>a</b> and <b>b</b>")

import re
emails = re.findall(r"[\w.+-]+@[\w-]+\.[\w.-]+", text)

re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\1/\2/\3", text)

import re

def is_strong(password: str) -> bool:
    if len(password) < 8:
        return False
    checks = [r"[a-z]", r"[A-Z]", r"\d"]
    return all(re.search(c, password) for c in checks)

r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$"

re.findall(r"<b>(.*?)</b>", text)     # ['a', 'b']  ✅ non-greedy

import re

log = '192.168.1.1 - [2026-07-26 14:30:00] "GET /api"\n10.0.0.5 - [2026-07-26 14:31:02] "POST /login"'

pattern = re.compile(
    r"(?P<ip>\d{1,3}(?:\.\d{1,3}){3}).*?"
    r"\[(?P<timestamp>[\d-]+ [\d:]+)\]"
)

records = [m.groupdict() for m in pattern.finditer(log)]
# [{'ip': '192.168.1.1', 'timestamp': '2026-07-26 14:30:00'}, ...]

from concurrent.futures import ThreadPoolExecutor
import httpx

urls = ["https://example.com/1", "https://example.com/2", ...]

def fetch(url):
    return httpx.get(url, timeout=10).text

# Use the high-level API rather than raw Thread objects
with ThreadPoolExecutor(max_workers=10) as pool:
    results = list(pool.map(fetch, urls))

from concurrent.futures import ThreadPoolExecutor, as_completed

with ThreadPoolExecutor(max_workers=10) as pool:
    futures = {pool.submit(fetch, url): url for url in urls}
    for future in as_completed(futures):        # handle each as it finishes
        url = futures[future]
        try:
            print(url, len(future.result()))
        except Exception as e:
            print(f"{url} failed: {e}")

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:              # only one thread at a time in here
            counter += 1

from concurrent.futures import ProcessPoolExecutor

def heavy_compute(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":              # ⚠️ required on Windows/macOS
    with ProcessPoolExecutor() as pool:
        results = list(pool.map(heavy_compute, [10**7] * 4))

import asyncio
import httpx

async def fetch(client, url):            # async def defines a coroutine
    r = await client.get(url)            # await yields control here
    return r.text

async def main():
    async with httpx.AsyncClient() as client:
        tasks = [fetch(client, url) for url in urls]
        results = await asyncio.gather(*tasks)      # run them all concurrently
    return results

asyncio.run(main())                      # start the event loop

await asyncio.sleep(1)                      # async sleep (doesn't block other tasks)
await asyncio.gather(*coros)                # run concurrently, return a list of results
await asyncio.wait_for(coro, timeout=5)     # timeout control
task = asyncio.create_task(coro)            # schedule a background task
await task

# Task groups (Python 3.11+) — safer, better error handling
async with asyncio.TaskGroup() as tg:
    tg.create_task(work1())
    tg.create_task(work2())
# Waits for all tasks on exit; if one fails, the rest are cancelled

async def a(): ...
async def b():
    await a()          # await only works inside an async function
def c():
    await a()          # ❌ SyntaxError

async def bad():
    time.sleep(1)                    # ❌ blocks the whole event loop; every task stalls
    requests.get(url)                # ❌ same

async def good():
    await asyncio.sleep(1)           # ✅
    await client.get(url)            # ✅ use an async HTTP client

    # When you must call something blocking, push it to a thread
    result = await asyncio.to_thread(blocking_function, arg)

Is the work CPU-bound?
├─ Yes → ProcessPoolExecutor (or use numpy / a Rust extension)
└─ No (I/O-bound)
    ├─ Concurrency in the dozens → ThreadPoolExecutor (simple, no style change)
    └─ Concurrency in the hundreds or thousands → asyncio (far better memory profile)

import asyncio
import httpx
from pathlib import Path

async def download(client: httpx.AsyncClient, url: str, dest: Path,
                   sem: asyncio.Semaphore) -> str:
    async with sem:                       # cap concurrency; don't flatten the server
        try:
            r = await client.get(url, timeout=30, follow_redirects=True)
            r.raise_for_status()
            dest.write_bytes(r.content)
            return f"✅ {url} → {dest.name}"
        except httpx.HTTPError as e:
            return f"❌ {url}: {e}"


async def main(urls: list[str], outdir: Path) -> None:
    outdir.mkdir(parents=True, exist_ok=True)
    sem = asyncio.Semaphore(5)            # at most 5 at a time

    async with httpx.AsyncClient() as client:
        tasks = [
            download(client, url, outdir / f"{i:03d}.dat", sem)
            for i, url in enumerate(urls)
        ]
        for coro in asyncio.as_completed(tasks):
            print(await coro)


if __name__ == "__main__":
    asyncio.run(main(["https://example.com"] * 10, Path("downloads")))

def compute():
    return sum(i*i for i in range(10**7))

import time
def task(n):
    time.sleep(1)
    return n * 2

results = [task(i) for i in range(5)]   # takes 5 seconds

async def fetch_all(urls):
    results = []
    for url in urls:
        results.append(await fetch(url))
    return results

from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

paths = list(Path("data").glob("*.txt"))

def read(p):
    return p.name, p.read_text(encoding="utf-8")

with ThreadPoolExecutor(max_workers=10) as pool:
    for name, content in pool.map(read, paths):
        print(name, len(content))

import asyncio

async def task(n):
    await asyncio.sleep(1)
    return n * 2

async def main():
    return await asyncio.gather(*(task(i) for i in range(5)))

results = asyncio.run(main())    # takes about 1 second

async def fetch_all(urls):
    return await asyncio.gather(*(fetch(url) for url in urls))

# Create (generates a .venv directory)
python3 -m venv .venv

# Activate
source .venv/bin/activate          # macOS / Linux
.venv\Scripts\activate             # Windows

# Once active the prompt shows (.venv)
# Now python and pip point at the environment's copies

pip install requests
pip list

deactivate                         # exit

pip install requests                 # install
pip install "django>=4.0,<5.0"       # version range
pip install -r requirements.txt      # install from a file
pip install -e .                     # install this project in editable mode
pip install --upgrade requests
pip uninstall requests
pip list                             # what's installed
pip list --outdated                  # what can be upgraded
pip show requests                    # details and dependencies
pip freeze > requirements.txt        # export exact versions of everything

[project]
name = "myproject"
version = "0.1.0"
description = "One line about it"
requires-python = ">=3.12"
dependencies = [
    "httpx>=0.27",
    "pydantic>=2.0",
]

[project.optional-dependencies]
dev = [
    "pytest>=8.0",
    "ruff>=0.6",
    "mypy>=1.11",
]

[project.scripts]
mycli = "myproject.cli:main"        # after install, `mycli` runs it

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[tool.ruff]
line-length = 100

[tool.pytest.ini_options]
testpaths = ["tests"]

pip install -e ".[dev]"      # the project itself plus dev dependencies

# Start a project (creates pyproject.toml)
uv init myproject
cd myproject

# Add dependencies (creates the venv, updates pyproject.toml and uv.lock)
uv add httpx pydantic
uv add --dev pytest ruff mypy

# Run (ensures the environment is current first)
uv run python main.py
uv run pytest

# Sync the environment to the lockfile
uv sync

# Manage Python versions
uv python install 3.14
uv python pin 3.14

# Run a tool without installing it
uv tool run ruff check .
uvx ruff check .              # shorthand

"httpx"              # ❌ too loose; a future major version can break you outright
"httpx==0.27.0"      # ❌ too tight; you miss security fixes
"httpx>=0.27,<1.0"   # ✅ allows minor updates, blocks breaking changes

pip list --outdated
pip-audit                    # check for known vulnerabilities

dependencies = ["django", "requests==2.25.0", "numpy>=1.0"]

mkdir demo && cd demo
python3 -m venv .venv
source .venv/bin/activate
pip install httpx

cat > main.py << 'EOF'
import httpx

r = httpx.get("https://api.github.com/repos/python/cpython", timeout=10)
r.raise_for_status()
data = r.json()
print(f"{data['full_name']}: {data['stargazers_count']} stars")
EOF

python main.py
pip freeze > requirements.txt

dependencies = [
    "django>=5.0,<6.0",
    "requests>=2.31,<3.0",
    "numpy>=1.26,<3.0",
]

pip install pytest

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

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

import pytest
from calculator import add, divide

def test_add():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, -1) == -2

def test_divide():
    assert divide(10, 2) == 5

def test_divide_by_zero():
    with pytest.raises(ValueError, match="Cannot divide by zero"):
        divide(10, 0)

pytest                    # everything
pytest -v                 # show each test name
pytest test_calc.py       # one file
pytest -k "divide"        # only tests whose names contain divide
pytest -x                 # stop at the first failure
pytest --lf               # rerun only last session's failures
pytest -q                 # quiet output

@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (0.1, 0.2, pytest.approx(0.3)),      # use approx for floats
])
def test_add(a, b, expected):
    assert add(a, b) == expected

import pytest

@pytest.fixture
def sample_users():
    return [
        {"name": "Alice", "age": 25},
        {"name": "Bob", "age": 17},
    ]

def test_adults(sample_users):            # parameter name matches the fixture; injected automatically
    adults = [u for u in sample_users if u["age"] >= 18]
    assert len(adults) == 1

@pytest.fixture
def temp_db(tmp_path):                    # tmp_path is a built-in fixture
    db_path = tmp_path / "test.db"
    conn = sqlite3.connect(db_path)
    conn.execute("CREATE TABLE users (id INTEGER, name TEXT)")
    yield conn                            # the test runs here
    conn.close()                          # cleanup afterwards

@pytest.fixture(scope="function")   # default: fresh for every test function
@pytest.fixture(scope="module")     # once per file
@pytest.fixture(scope="session")    # once for the whole run (e.g. starting a database)

def test_file(tmp_path):              # a temp directory (a Path object)
    (tmp_path / "a.txt").write_text("hi")

def test_output(capsys):              # capture printed output
    print("hello")
    assert capsys.readouterr().out == "hello\n"

def test_env(monkeypatch):            # temporarily patch env vars / attributes
    monkeypatch.setenv("API_KEY", "test")
    monkeypatch.setattr("mymodule.CONFIG", {"debug": True})

def test_withdraw():
    account = BankAccount("Alice", 100)    # Arrange
    account.withdraw(30)                   # Act
    assert account.balance == 70           # Assert

# ❌ When it fails you don't know which step broke
def test_account():
    a = BankAccount("Alice", 100)
    a.deposit(50)
    assert a.balance == 150
    a.withdraw(30)
    assert a.balance == 120
    with pytest.raises(...): a.withdraw(1000)

# ✅ Three separate tests
def test_deposit_increases_balance(): ...
def test_withdraw_decreases_balance(): ...
def test_withdraw_too_much_raises(): ...

def test_1():                                       # ❌
def test_withdraw_more_than_balance_raises():       # ✅

# Empty input, single element, maximum value, None, negatives, very long strings
def test_empty_list(): ...
def test_single_element(): ...
def test_none_input_raises(): ...

from unittest.mock import patch, Mock

def get_user_name(user_id):
    r = httpx.get(f"https://api.example.com/users/{user_id}")
    return r.json()["name"]


def test_get_user_name():
    fake = Mock()
    fake.json.return_value = {"name": "Alice"}

    with patch("mymodule.httpx.get", return_value=fake):
        assert get_user_name(1) == "Alice"

# ❌ Hardcoded dependency, only testable via mocks
def get_user_name(user_id):
    r = httpx.get(...)

# ✅ Dependency passed in; tests supply a fake
def get_user_name(user_id, client=httpx):
    r = client.get(...)

pip install pytest-cov
pytest --cov=myproject --cov-report=term-missing

Name                 Stmts   Miss  Cover   Missing
--------------------------------------------------
myproject/core.py       45      3    93%   67-69

def add(a, b):
    """Return the sum of two numbers.

    >>> add(2, 3)
    5
    >>> add(-1, 1)
    0
    """
    return a + b

pytest --doctest-modules

from hypothesis import given, strategies as st

@given(st.lists(st.integers()))
def test_sort_is_idempotent(lst):
    assert sorted(sorted(lst)) == sorted(lst)

def parse_age(text):
    age = int(text)
    if not 0 <= age <= 150:
        raise ValueError(f"Age out of range: {age}")
    return age

def test_everything():
    assert add(1, 2) == 3
    assert divide(10, 2) == 5
    assert multiply(3, 4) == 12

import pytest
from mymodule import parse_age

@pytest.mark.parametrize("text, expected", [
    ("0", 0),
    ("25", 25),
    ("150", 150),
    (" 42 ", 42),          # int() ignores surrounding whitespace
])
def test_parse_age_valid(text, expected):
    assert parse_age(text) == expected


@pytest.mark.parametrize("text", ["-1", "151", "1000"])
def test_parse_age_out_of_range(text):
    with pytest.raises(ValueError, match="out of range"):
        parse_age(text)


@pytest.mark.parametrize("text", ["abc", "", "3.14", None])
def test_parse_age_invalid_input(text):
    with pytest.raises((ValueError, TypeError)):
        parse_age(text)

@pytest.mark.parametrize("n, expected", [
    (1, "1"),
    (3, "Fizz"),
    (5, "Buzz"),
    (15, "FizzBuzz"),
    (30, "FizzBuzz"),
    (7, "7"),
])
def test_fizzbuzz(n, expected):
    assert fizzbuzz(n) == expected

@pytest.fixture
def sample_dir(tmp_path):
    (tmp_path / "a.txt").write_text("content A", encoding="utf-8")
    (tmp_path / "b.txt").write_text("content B", encoding="utf-8")
    (tmp_path / "c.log").write_text("log", encoding="utf-8")
    return tmp_path

def test_count_txt(sample_dir):
    assert len(list(sample_dir.glob("*.txt"))) == 2

print(f"{user=}")                  # user=User(name='Alice')  — the f-string = syntax
print(f"{len(items)=}, {items[:3]=}")

def process(data):
    result = transform(data)
    breakpoint()                   # Python 3.7+; execution stops here
    return result

n (next)      execute the next line
s (step)      step into a function
c (continue)  run to the next breakpoint
l (list)      show surrounding code
p name        print a variable
pp name       pretty-print
w (where)     show the call stack
u / d         move up and down the stack
q (quit)      exit

python -m pdb -c continue script.py     # stop where it crashed
pytest --pdb                            # enter pdb on test failure

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    datefmt="%H:%M:%S",
)

logger = logging.getLogger(__name__)

logger.debug("Detailed diagnostic information")
logger.info("Normal operational information")
logger.warning("Something's off but we can continue")
logger.error("Something failed")
logger.critical("Fatal problem")

try:
    risky()
except Exception:
    logger.exception("Processing failed")      # includes the full traceback automatically

logger.info("User %s logged in from %s", username, ip)     # ✅ formats only if emitted
logger.info(f"User {username} logged in")                  # ⚠️ always formats, even when DEBUG is off

from logging.handlers import RotatingFileHandler

handler = RotatingFileHandler(
    "app.log", maxBytes=10_000_000, backupCount=5, encoding="utf-8"
)
handler.setFormatter(logging.Formatter(
    "%(asctime)s [%(levelname)s] %(name)s:%(lineno)d - %(message)s"
))
logging.getLogger().addHandler(handler)

# main.py
import logging

def setup_logging(verbose: bool = False):
    logging.basicConfig(
        level=logging.DEBUG if verbose else logging.INFO,
        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    )
    logging.getLogger("httpx").setLevel(logging.WARNING)   # quiet a noisy library

if __name__ == "__main__":
    setup_logging()
    main()

File "main.py", line 5
    print(items[i][j])
          ^^^^^^^^^^^
IndexError: list index out of range

print(f"{type(data)=}, {len(data)=}, {data[:2]=}")

logger.debug(f"Processing data: {expensive_serialize(data)}")

def average(nums):
    total = 0
    for n in nums:
        total += n
    return total / len(nums) - 1

import logging

def setup_logging(log_file="app.log"):
    root = logging.getLogger()
    root.setLevel(logging.DEBUG)

    fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s")

    console = logging.StreamHandler()
    console.setLevel(logging.INFO)
    console.setFormatter(fmt)

    file = logging.FileHandler(log_file, encoding="utf-8")
    file.setLevel(logging.DEBUG)
    file.setFormatter(fmt)

    root.addHandler(console)
    root.addHandler(file)

logger.debug("Processing data: %s", data)      # formats only if actually emitted
# or
if logger.isEnabledFor(logging.DEBUG):
    logger.debug("Processing data: %s", expensive_serialize(data))

def average(nums):
    if not nums:
        return 0
    return sum(nums) / len(nums)

# Indentation: 4 spaces
# Line length: 79 (PEP 8) or 88-100 (modern practice; ruff defaults to 88)

# Naming
variable_name = 1          # variables, functions: snake_case
CONSTANT_VALUE = 1         # constants: UPPER_CASE
class ClassName: ...       # classes: PascalCase
def function_name(): ...
_internal = 1              # internal use: leading underscore

# Blank lines
class A:              # two blank lines between classes and top-level functions

    def method(self): # one blank line between methods
        pass

# Spacing
x = 1                 # ✅ spaces around operators
x=1                   # ❌
f(a, b)               # ✅ space after commas
f(a,b)                # ❌
f(x=1)                # ✅ no spaces around = for keyword arguments
d["key"]              # ✅ no spaces just inside brackets
d[ "key" ]            # ❌

# Import order: standard library → third party → local, blank line between groups
import os
import sys

import httpx
import pydantic

from myproject.utils import helper

if x is None:              # ✅ compare to None with is
if not items:              # ✅ testing for an empty sequence
if len(items) == 0:        # ❌ verbose

if isinstance(x, int):     # ✅
if type(x) == int:         # ❌

try:                       # ✅ catch specific exceptions
    ...
except ValueError:
    ...
except:                    # ❌ bare except
    ...

pip install ruff

ruff check .                # find problems
ruff check --fix .          # auto-fix what it can
ruff format .               # format the code

[tool.ruff]
line-length = 100
target-version = "py312"

[tool.ruff.lint]
select = [
    "E", "W",    # pycodestyle
    "F",         # pyflakes (unused variables, imports, etc.)
    "I",         # isort (import ordering)
    "N",         # pep8-naming
    "UP",        # pyupgrade (modernize syntax automatically)
    "B",         # bugbear (common bug patterns)
    "SIM",       # simplify
    "RUF",       # ruff's own rules
]
ignore = ["E501"]        # let the formatter handle line length

pip install pre-commit

repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.9              # ← example version; use the command below to get the latest
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format

  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0              # ← same
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-added-large-files

pre-commit autoupdate    # bump every rev to each repo's latest tag
pre-commit install       # install the git hook

d = get()                        # ❌ says nothing
active_users = fetch_users()     # ✅

from mymodule import *          # ❌
from mymodule import parse      # ✅

def f(*args, **kwargs): ...     # ❌ unless you genuinely need it
def f(name, age): ...           # ✅

# ❌ Silent failure; the problem resurfaces far away in a strange form
def get_config(key):
    return config.get(key)

# ✅ Missing config errors right here
def get_config(key):
    if key not in config:
        raise KeyError(f"Missing config key: {key}")
    return config[key]

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

def calc( x,y ):
  Result=x*2+y
  if Result>10 :
    return  True
  else :
    return False

def p(d):
    r = []
    for i in d:
        if i['s'] == 1:
            if i['a'] > 18:
                if i['n'] != '':
                    r.append(i['n'].upper())
    return r

def calc(x, y):
    return x * 2 + y > 10

def get_active_adult_names(users: list[dict]) -> list[str]:
    """Return uppercased names of all active adult users."""
    return [
        user["name"].upper()
        for user in users
        if user["status"] == ACTIVE and user["age"] > 18 and user["name"]
    ]

@dataclass
class User:
    name: str
    age: int
    status: Status

def get_active_adult_names(users: list[User]) -> list[str]:
    return [u.name.upper() for u in users
            if u.status is Status.ACTIVE and u.age > 18 and u.name]

uv add --dev ruff pre-commit

[tool.ruff]
line-length = 100
target-version = "py312"

[tool.ruff.lint]
select = ["E", "W", "F", "I", "N", "UP", "B", "SIM"]

repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.9
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format

pre-commit autoupdate
pre-commit install

# Types and conversion
type(x)  isinstance(x, T)  issubclass(A, B)
int()  float()  str()  bool()  bytes()  complex()
list()  tuple()  dict()  set()  frozenset()

# Math
abs()  round()  pow(a, b, mod)  divmod(a, b)
min()  max()  sum()
bin()  oct()  hex()      # to base-prefixed strings
ord("A")  chr(65)         # character ↔ code point

# Sequences
len()  sorted()  reversed()  enumerate()  zip()
range()  slice()
all()  any()
filter(f, it)  map(f, it)
iter()  next()

# Objects
dir(x)              # list all attributes
vars(x)             # return __dict__
getattr(x, "name", default)
setattr(x, "name", value)
hasattr(x, "name")
delattr(x, "name")
id(x)  hash(x)
callable(x)
repr(x)  format(x, spec)

# I/O
print()  input()  open()

# Execution
eval("1+1")         # ⚠️ dangerous; never use on untrusted input
exec(code)          # ⚠️ same
compile()

# Misc
help(x)
globals()  locals()
super()
property()  staticmethod()  classmethod()
breakpoint()

# ============ Variables and types ============
x = 10                      # int
y = 3.14                    # float
s = "text"                  # str
b = True                    # bool
n = None                    # NoneType

# ============ Containers ============
lst = [1, 2, 3]             # list   ordered, mutable
tup = (1, 2, 3)             # tuple  ordered, immutable
dct = {"k": "v"}            # dict   key-value mapping
st  = {1, 2, 3}             # set    unordered, unique

# ============ Strings ============
f"{name} is {age} years old"
f"{pi:.2f}"  f"{n:,}"  f"{r:.1%}"  f"{x=}"
s.strip().lower().split(",")
",".join(items)
s.replace(old, new)
s.startswith(p)  s.endswith(p)
s[::-1]                     # reverse
r"raw\string"

# ============ Slicing ============
s[start:stop:step]          # stop is exclusive
s[:3]  s[3:]  s[::-1]  s[-3:]

# ============ Control flow ============
if cond:
    ...
elif other:
    ...
else:
    ...

x = a if cond else b        # conditional expression

for item in iterable:
    if skip: continue
    if stop: break
else:                       # runs only if no break
    ...

while cond:
    ...

match value:
    case pattern: ...
    case _: ...

# ============ Loop helpers ============
range(start, stop, step)
enumerate(items, start=1)
zip(a, b, strict=True)
reversed(items)  sorted(items, key=f, reverse=True)

# ============ Comprehensions ============
[f(x) for x in it if cond]          # list
{k: v for k, v in it}               # dict
{f(x) for x in it}                  # set
(f(x) for x in it)                  # generator

# ============ Functions ============
def f(a, b=1, *args, key=None, **kwargs) -> int:
    """Docstring."""
    return a + b

lambda x: x * 2

f(*list_args, **dict_kwargs)        # unpacking at the call site

# ============ Classes ============
class Child(Parent):
    class_attr = 0

    def __init__(self, x):
        super().__init__()
        self.x = x

    def method(self): ...

    @property
    def value(self): return self._v

    @classmethod
    def create(cls): return cls()

    @staticmethod
    def helper(): ...

@dataclass
class Point:
    x: float
    y: float = 0.0

# ============ Exceptions ============
try:
    ...
except (ValueError, TypeError) as e:
    ...
except Exception:
    raise
else:
    ...
finally:
    ...

raise ValueError(f"Specific detail: {value}")
raise NewError("...") from original

with open(path, encoding="utf-8") as f:
    ...

# ============ Generators ============
def gen():
    yield 1
    yield from other_iterable

# ============ Decorators ============
import functools

def deco(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@deco
def f(): ...

# ============ Type hints ============
def f(a: int, b: str = "") -> list[int]: ...
x: str | None = None
d: dict[str, list[int]] = {}

# ============ Files ============
from pathlib import Path

p = Path("dir") / "file.txt"
p.read_text(encoding="utf-8")
p.write_text(text, encoding="utf-8")
p.exists()  p.is_file()  p.name  p.stem  p.suffix  p.parent
list(p.parent.glob("*.txt"))
list(Path(".").rglob("*.py"))

# ============ Frequent imports ============
import json, re, os, sys, math, random, time
from pathlib import Path
from datetime import datetime, date, timedelta
from collections import Counter, defaultdict, deque
from dataclasses import dataclass, field
from functools import cache, wraps, partial
from itertools import chain, islice, groupby, product
from enum import Enum, auto
from typing import Any, Protocol, TypeVar

# ============ Script entry point ============
def main() -> None:
    ...

if __name__ == "__main__":
    main()