Python, explained plainly.

Python is a programming language designed to be easy to read. You write short, English-like instructions and the computer follows them. It has built-in tools for lists, text, dates and files, so you rarely start from nothing.

People call Python “interpreted”, but it does a quick translation step first. Python (the standard version is called CPython) turns your .py file into bytecode, a compact list of simple instructions. A small engine, the Python Virtual Machine, then reads those instructions one by one and carries them out.

import dis

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

dis.dis(add)   # shows the bytecode steps Python will run
# LOAD_FAST a / LOAD_FAST b / BINARY_OP + / RETURN_VALUE (names vary by version)

Because the virtual machine does the work, the same .py file runs on Windows, macOS and Linux without changes.

You start Python from a terminal. Typing python3 on its own opens a chat-like prompt. Giving it a file name runs that file. Small flags change the behaviour.

To leave the interactive prompt, press Ctrl+D (macOS and Linux) or Ctrl+Z then Enter (Windows), or type exit().

Words you type after the script name are handed to your program as a list called sys.argv. Item 0 is the script name, item 1 is the first word you typed, and so on.

# greet.py
import sys

name = sys.argv[1] if len(sys.argv) > 1 else "friend"
print(f"Hello, {name}!")

$ python3 greet.py Asha
Hello, Asha!
$ python3 greet.py
Hello, friend!

import argparse

parser = argparse.ArgumentParser(description="Greet someone")
parser.add_argument("name", nargs="?", default="friend")
parser.add_argument("--shout", action="store_true", help="use capital letters")
args = parser.parse_args()

msg = f"Hello, {args.name}!"
print(msg.upper() if args.shout else msg)

REPL stands for Read, Evaluate, Print, Loop. You type one line, Python answers at once, and it waits for the next. It is the fastest way to test an idea before putting it in a file.

>>> 7 * 6
42
>>> _ + 8          # underscore holds the last result
50
>>> "hello".title()
'Hello'
>>> help(str.split)  # built-in documentation
>>> dir("hello")     # list everything a string can do

Two helpers worth memorising: help(thing) shows its manual and dir(thing) lists its attributes. Since Python 3.13 the prompt also supports colour and multi-line editing, and 3.14 adds syntax highlighting as you type.

Python reads your file as UTF-8 text by default, so names, comments and strings can use any language: नमस्ते, café, 日本語. You only need a special first-line comment if your file is saved in a different encoding.

# -*- coding: cp1252 -*-
# Only needed for a file saved as Windows-1252, a legacy encoding.
print("price: 5 €")

Related tip: on macOS and Linux, a first line such as #!/usr/bin/env python3 (the “shebang”) lets you run a script as ./tool.py after chmod +x tool.py.

A variable is a name you attach to a value with =. You never declare a type: the value knows its own type and the name can be moved to a different value later. Anything after # on a line is a comment that Python ignores.

price = 250          # int
price = 249.99       # now a float; same label, new value
shop_name = "Corner Cafe"
is_open = True

print(type(price))   # <class 'float'>
width = height = 0   # chain assignment: both names point to 0

• Use snake_case for variables and functions, CapWords for classes, UPPER_CASE for constants.
• Names are case-sensitive: Total and total are different.
• Using a name that was never assigned raises NameError.

Python does arithmetic the way you would on paper. Whole numbers are int (they can be as large as memory allows), numbers with a decimal point are float. Division with / always gives a float.

print(17 / 3)      # 5.666666666666667   true division
print(17 // 3)     # 5                   floor division (drops the fraction)
print(17 % 3)      # 2                   remainder
print(2 ** 10)     # 1024                power
print(round(3.14159, 2))   # 3.14
print(1_000_000)   # underscores make big numbers readable
print(3 + 4j)      # complex numbers exist too: (3+4j)

Text goes inside single or double quotes; they mean the same. Use a backslash to include special characters, or a raw string (r"...") when backslashes should stay as they are, such as in Windows paths and regular expressions. Triple quotes let text span several lines.

print("It's fine")            # a double-quoted string can hold '
print('She said "hi"')       # and the reverse
print("Line1\nLine2")         # \n starts a new line
print("C:\new")               # surprise: \n is a newline here
print(r"C:\new")              # raw string keeps it: C:\new

poem = """Roses are red,
Violets are blue."""          # triple quotes: multi-line text

print("ha" * 3 + "!")        # hahaha!   repeat and join
print("Py" "thon")            # side-by-side literals join: Python
print(len("Python"))          # 6

Indexing and slicing

Each character has a position number starting at 0. Negative numbers count from the end. A slice word[a:b] takes characters from position a up to, but not including, b. It helps to picture the numbers as pointing at the gaps between letters.

word = "Python"
print(word[0], word[-1])   # P n
print(word[:2])            # Py        (from the start)
print(word[4:])            # on        (to the end)
print(word[::-1])          # nohtyP    (step -1 reverses)
print(word[::2])           # Pto       (every 2nd letter)

A list holds many items in order, written in square brackets. Unlike strings, lists can be changed: you can add, remove or replace items. Items can be of mixed types, even other lists.

cart = ["rice", "milk", "eggs"]
cart.append("tea")            # add at the end
cart[1] = "oat milk"          # replace an item
print(cart[-1])               # tea
print(cart[:2])               # ['rice', 'oat milk']
cart[1:3] = []                # delete a slice
print(cart, len(cart))        # ['rice', 'tea'] 2

grid = [[1, 2], [3, 4]]       # a list of lists
print(grid[1][0])             # 3

A while loop repeats its block as long as a condition is true. Python marks a block by indentation (4 spaces is the convention), not by curly braces. Everything pushed to the right under the colon belongs to the block.

a, b = 0, 1                 # two assignments at once
while a < 100:
    print(a, end=" ")       # end=" " keeps output on one line
    a, b = b, a + b         # right side is computed first, then assigned
# 0 1 1 2 3 5 8 13 21 34 55 89

An if statement runs a block only when its condition is true. Add elif (“else if”) for more choices and else as the catch-all. Python checks from the top and runs only the first branch that matches.

temp = 22
if temp > 30:
    print("Iced drink")
elif temp > 15:
    print("Light tea")        # this one runs
else:
    print("Hot coffee")

# one-line version (conditional expression)
label = "adult" if age >= 18 else "minor"

Combine tests with and, or, not. Python also allows chained comparisons such as 0 < x <= 100.

A for loop walks through anything you can go through one item at a time (a list, string, dictionary, file) and runs its block once per item. You never manage a counter yourself.

words = ["cat", "window", "defenestrate"]
for w in words:
    print(w, len(w))
# cat 3
# window 6
# defenestrate 12

users = {"amy": "active", "raj": "inactive", "li": "active"}

# safe way 1: make a new dict
active = {u: s for u, s in users.items() if s == "active"}

# safe way 2: loop over a copy of the keys, then change the original
for name in list(users):
    if users[name] == "inactive":
        del users[name]

range(start, stop, step) produces numbers from start up to but not including stop. It does not build the whole list; it hands out one number at a time, so range(10**9) costs almost no memory.

print(list(range(5)))            # [0, 1, 2, 3, 4]
print(list(range(5, 10)))        # [5, 6, 7, 8, 9]
print(list(range(0, 10, 3)))     # [0, 3, 6, 9]
print(list(range(-10, -100, -30)))   # [-10, -40, -70]
print(sum(range(4)))             # 6

colors = ["red", "green", "blue"]
for i, color in enumerate(colors, start=1):   # nicer than range(len(...))
    print(i, color)

break leaves the loop immediately. continue skips the rest of this round and starts the next one. The unusual part is else on a loop: it runs only if the loop finished without hitting break. Read it as “no break happened”.

seats = ["taken", "taken", "free", "taken"]
for number, state in enumerate(seats, start=1):
    if state == "free":
        print("Sit at seat", number)    # Sit at seat 3
        break
else:
    print("Sorry, the bus is full")     # only if no break happened

for n in range(1, 8):
    if n % 2 == 0:
        continue          # skip even numbers
    print(n, end=" ")     # 1 3 5 7

Python does not allow an empty block, so pass means “do nothing here, on purpose”. It is how you sketch the shape of a program before filling it in.

class PaymentGateway:
    pass                  # to be written

def send_invoice(order):
    ...                   # "..." (Ellipsis) is another common placeholder

for _ in range(3):
    pass                  # do nothing, three times

match looks like a switch statement from other languages, but it is smarter. Instead of comparing to fixed values only, it checks the shape of your data (a list of two items, a dictionary with a certain key, an object of a certain class) and pulls out the parts you want in the same step.

def handle(command):
    match command.split():
        case ["go", direction]:
            return f"Walking {direction}"
        case ["pick", "up", *items]:
            return f"Taking {', '.join(items)}"
        case ["quit" | "exit"]:
            return "Bye"
        case []:
            return "Say something"
        case _:                       # wildcard: matches anything
            return "I don't understand"

print(handle("go north"))             # Walking north
print(handle("pick up sword lamp"))   # Taking sword, lamp

Classes, dictionaries and guards

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

def where(p):
    match p:
        case Point(x=0, y=0):
            return "origin"
        case Point(x=0, y=y):
            return f"on the y-axis at {y}"
        case Point(x, y) if x == y:    # 'if' adds an extra condition (guard)
            return "on the diagonal"
        case _:
            return "somewhere else"

def read(response):                    # works on dictionaries too
    match response:
        case {"status": 200, "data": data}:
            return data
        case {"status": 404}:
            return "not found"

A function is a named recipe. You write the steps once with def, then call it by name whenever you need it. Values you give it are parameters; the value it hands back is set with return. A function with no return gives back None.

def total_with_tax(price, rate=0.18):
    """Return the price including tax."""
    return round(price * (1 + rate), 2)

print(total_with_tax(100))          # 118.0
print(total_with_tax(100, 0.05))    # 105.0

def say_hi():
    print("hi")                     # no return statement

result = say_hi()
print(result)                       # None

• Variables created inside a function are local; they vanish when it ends.
• Functions are ordinary values: you can store one in a list or pass it to another function.
• Return several things at once by returning a tuple: return low, high.

Give a parameter a value with = and callers may leave it out. Defaults are great for options that are usually the same.

def ask(prompt, retries=3, reminder="Please try again!"):
    ...

ask("Save file?")            # uses both defaults
ask("Save file?", 5)         # changes retries only

def add_item(item, basket=[]):       # BAD: one shared list
    basket.append(item)
    return basket

print(add_item("a"))   # ['a']
print(add_item("b"))   # ['a', 'b']   surprise!

def add_item(item, basket=None):     # GOOD: make a fresh list per call
    if basket is None:
        basket = []
    basket.append(item)
    return basket

When you call a function you can name the arguments, name=value. Names make calls self-explanatory and let you skip options and change the order. Positional arguments must come first.

def book_table(name, guests=2, outdoor=False):
    place = "outside" if outdoor else "inside"
    return f"{name}: {guests} people, {place}"

print(book_table("Asha", outdoor=True))     # Asha: 2 people, outside
print(book_table(guests=4, name="Ravi"))    # Ravi: 4 people, inside
# book_table(name="Li", "x")  -> SyntaxError: positional after keyword

Two markers in a function’s parameter list control how each parameter may be given. A / says “everything before me must be passed by position”. A * says “everything after me must be passed by name”. Parameters between them can be used either way.

def f(a, b, /, c, *, d, e):
    return a + b + c + d + e

f(1, 2, 3, d=4, e=5)         # OK
f(1, 2, c=3, d=4, e=5)       # OK: c can be named
# f(a=1, b=2, c=3, d=4, e=5)   TypeError: a, b are positional-only
# f(1, 2, 3, 4, 5)             TypeError: d, e must be named

Why use them? Positional-only lets you rename a parameter later without breaking callers (library authors love this; built-ins such as len(obj, /) use it). Keyword-only forces readable calls like connect(host, port, timeout=5) and prevents mixing up two similar flags.

*args collects extra positional arguments into a tuple. **kwargs collects extra named arguments into a dictionary. The names args and kwargs are only a convention; the stars do the work.

def log(level, *messages, **context):
    print(level, *messages, context)

log("INFO", "user", "logged in", user_id=7, ip="10.0.0.1")
# INFO user logged in {'user_id': 7, 'ip': '10.0.0.1'}

def wrapper(*args, **kwargs):          # forward everything unchanged
    return real_function(*args, **kwargs)

This “catch everything and pass it along” pattern is the backbone of decorators (see the advanced chapter).

The stars work in reverse at a call site: * spreads a list or tuple into positional arguments, ** spreads a dictionary into named arguments.

bounds = [3, 6]
print(list(range(*bounds)))        # [3, 4, 5]   same as range(3, 6)

def connect(host, port, secure=False):
    return f"{'https' if secure else 'http'}://{host}:{port}"

settings = {"host": "example.com", "port": 8443, "secure": True}
print(connect(**settings))         # https://example.com:8443

print(*["a", "b", "c"], sep=" | ") # a | b | c

A lambda is a tiny nameless function written in one line. It can only hold a single expression, and that expression’s value is returned. Use it where you need a throwaway function, most often as a key= for sorting.

people = [{"name": "Asha", "age": 31}, {"name": "Li", "age": 24}, {"name": "Raj", "age": 28}]
youngest_first = sorted(people, key=lambda p: p["age"])
print([p["name"] for p in youngest_first])    # ['Li', 'Raj', 'Asha']

def make_adder(n):
    return lambda x: x + n          # remembers n (a closure)

add5 = make_adder(5)
print(add5(10))                     # 15

A string placed as the very first statement of a function, class or module is its docstring. Tools and help() show it to people who use your code.

def area(width, height):
    """Return the area of a rectangle.

    width and height must be in the same unit.
    """
    return width * height

print(area.__doc__.splitlines()[0])   # Return the area of a rectangle.
help(area)                            # prints the full manual

Habit to build: one summary line, a blank line, then details. Say what the function does, not how it does it.

Annotations are optional notes about the types a function expects and returns. Python itself does not enforce them; editors and checkers such as mypy or pyright use them to catch mistakes before you run the program and to power auto-complete.

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

def first_word(text: str) -> str | None:      # a str, or None
    parts = text.split()
    return parts[0] if parts else None

prices: dict[str, float] = {"tea": 12.5}      # variable annotation
print(greet.__annotations__)

Most Python code follows a shared style guide called PEP 8. Following it means anyone can read your code without getting used to your habits.

• Indent with 4 spaces. Never mix tabs and spaces.
• Keep lines to about 79 characters (many teams allow 88 or 100).
• Two blank lines around top-level functions and classes, one between methods.
• snake_case for functions and variables, CapWords for classes, UPPER_CASE for constants.
• Spaces around operators and after commas: x = f(a, b), not x=f(a,b).

You do not have to do this by hand: formatters like black or ruff format tidy files for you, and linters like ruff or flake8 point out problems.

Lists come with a toolbox of methods. Most of them change the list in place and return None, so write items.sort(), not items = items.sort() (that would set items to None).

fruits = ["orange", "apple", "pear", "banana", "kiwi", "apple"]
print(fruits.count("apple"))     # 2
print(fruits.index("banana"))    # 3
fruits.reverse()
fruits.append("grape")
fruits.sort(key=len)             # sort by word length
print(fruits.pop())              # removes and returns the last item

ranked = sorted(fruits)          # sorted() returns a NEW list, original untouched

A stack is last in, first out: the newest item leaves first. A list does this perfectly with append() and pop(). A queue is first in, first out: the oldest item leaves first. For queues use collections.deque, because removing from the front of a list is slow (every other item must shift over).

stack = [3, 4, 5]
stack.append(6)
print(stack.pop())        # 6   (last in, first out)

from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")
print(queue.popleft())    # Eric   (first in, first out)

A comprehension builds a new list in one readable line: “give me this, for each of those, but only if…”. It replaces the common loop-and-append pattern.

squares = [x**2 for x in range(10)]
print(squares)                   # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

prices = [120, 80, 450, 30]
cheap_with_tax = [round(p * 1.18, 2) for p in prices if p < 200]
print(cheap_with_tax)            # [141.6, 94.4, 35.4]

pairs = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
print(pairs)                     # [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

matrix = [[1, 2, 3], [4, 5, 6]]
flat = [n for row in matrix for n in row]          # outer loop first
print(flat)                      # [1, 2, 3, 4, 5, 6]
print(list(zip(*matrix)))        # [(1, 4), (2, 5), (3, 6)]   transpose

The same idea works for other containers: {x % 3 for x in nums} builds a set and {name: len(name) for name in names} builds a dictionary.

del removes something by position or key rather than by value: a list item, a slice, a dictionary entry, or a whole variable name.

a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]            # remove the first item
del a[2:4]          # remove a slice
print(a)            # [1, 66.25, 1234.5]
del a[:]            # empty the list but keep the name

prices = {"tea": 12, "coffee": 30}
del prices["tea"]
del a               # now the name 'a' no longer exists

A tuple is like a list that cannot be changed after it is made. Use it for a small group of values that belong together and should stay together, such as coordinates or a record.

point = (3, 4)
x, y = point                   # unpacking: x=3, y=4
a, b = 1, 2
a, b = b, a                    # swap without a temp variable
first, *middle, last = [10, 20, 30, 40, 50]
print(middle)                  # [20, 30, 40]

single = (42,)                 # the comma makes it a tuple, not the brackets
empty = ()

from collections import namedtuple
Order = namedtuple("Order", "id item qty")
o = Order(7, "tea", 2)
print(o.item, o[2])            # tea 2

Because tuples cannot change, they can be dictionary keys and set members (as long as everything inside is also unchangeable). Lists cannot.

A set is an unordered collection with no duplicates. Checking “is this in the set?” is very fast, even with millions of items. Sets also do the maths you learned at school: union, overlap and difference.

monday = {"asha", "li", "raj"}
tuesday = {"li", "sam"}

print(monday | tuesday)     # everyone (union)
print(monday & tuesday)     # {'li'}  came both days (intersection)
print(monday - tuesday)     # {'asha', 'raj'}  Monday only (difference)
print(monday ^ tuesday)     # came on exactly one day (symmetric difference)

emails = ["a@x.com", "b@x.com", "a@x.com"]
print(len(set(emails)))     # 2   removes duplicates fast
empty = set()               # {} would make an empty dictionary instead

A dictionary stores key → value pairs. Instead of asking “what is item number 3?”, you ask “what is the value for "email"?”. Keys must be unchangeable (strings, numbers, tuples). Dictionaries remember the order in which keys were added.

stock = {"apple": 5, "pear": 0}
stock["mango"] = 12                 # add or update
print(stock.get("kiwi", "none"))    # none   (no error if missing)
del stock["pear"]
print("apple" in stock)             # True
print(list(stock))                  # ['apple', 'mango']

# count words
counts = {}
for word in "to be or not to be".split():
    counts[word] = counts.get(word, 0) + 1
print(counts)                       # {'to': 2, 'be': 2, 'or': 1, 'not': 1}

squares = {n: n * n for n in range(4)}     # dict comprehension
merged = stock | {"apple": 9}              # merge; right side wins

Handy helpers from the standard library

from collections import Counter, defaultdict

print(Counter("banana").most_common(2))   # [('a', 3), ('n', 2)]

groups = defaultdict(list)                # missing keys start as []
for name, team in [("Asha", "red"), ("Li", "blue"), ("Raj", "red")]:
    groups[team].append(name)
print(dict(groups))                       # {'red': ['Asha', 'Raj'], 'blue': ['Li']}

Python has ready-made helpers so you rarely need index counters.

knights = {"gallahad": "the pure", "robin": "the brave"}
for name, quality in knights.items():          # key and value together
    print(name, quality)

for i, v in enumerate(["tic", "tac", "toe"]):  # position and item
    print(i, v)

questions = ["name", "quest", "colour"]
answers = ["Lancelot", "the grail", "blue"]
for q, a in zip(questions, answers, strict=True):   # walk two lists side by side
    print(f"What is your {q}? {a}.")

for n in reversed(range(1, 4)):                # 3 2 1
    print(n, end=" ")
for fruit in sorted({"pear", "apple", "pear"}):    # unique and in order
    print(fruit)

strict=True makes zip raise an error if the lists have different lengths, which catches silent data loss.

• in / not in test membership: "a" in "cat".
• == asks “are the values equal?”. is asks “is it the very same object?”. Use is only for None, True and False.
• and / or short-circuit: they stop as soon as the answer is known, and they return one of their operands, not just True/False.

user = None
if user is not None and user.is_admin:   # second test never runs if user is None
    print("welcome admin")

name = "" or "guest"          # first truthy value wins -> 'guest'
limit = 0 or 10               # careful: 0 is falsy, so this is 10
print(0 < 5 <= 10)            # chained comparison: True

data = [1, 2, 3, 4, 5, 6]
if (n := len(data)) > 5:      # walrus: assign AND test in one step
    print(f"list is long ({n} items)")

Lists, tuples and strings compare like a dictionary sorts words: look at the first items; if they differ, that decides. If they are equal, move to the next. A shorter sequence that matches the start of a longer one is the smaller.

print((1, 2, 3) < (1, 2, 4))          # True   decided at the 3rd item
print([1, 2, 3] < [1, 2, 3, 4])       # True   shorter prefix is smaller
print("ABC" < "C" < "Pascal" < "Python")   # True
print((1, 2, ("aa", "ab")) < (1, 2, ("abc", "a"), 4))   # True

# Different kinds of things cannot be ordered:
# 1 < "2"   -> TypeError   (but 1 == "1" is simply False)

This is why sorting a list of (score, name) tuples works: it sorts by score first and uses the name to break ties.

A module is simply a .py file. Anything defined in it (functions, classes, variables) can be borrowed by another file with import. This keeps programs organised and lets you reuse work.

# shapes.py
PI = 3.14159

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

# main.py
import shapes                          # use as shapes.circle_area(...)
from shapes import circle_area         # use the name directly
from shapes import circle_area as area # rename it
import math as m                       # common shorthand

print(shapes.circle_area(2))           # 12.56636
print(m.sqrt(16))                      # 4.0

Making a file work as both a module and a program

# shapes.py (bottom of the file)
def main():
    print(circle_area(3))

if __name__ == "__main__":     # True only when run directly: python3 shapes.py
    main()                     # skipped when another file imports shapes

Python sets __name__ to "__main__" for the file you launch, and to the module’s own name when it is imported. The check stops your test code from running when someone merely imports you.

When you write import spam, Python walks a fixed checklist. It first checks whether it has already loaded it, then whether it is built in, and finally searches a list of folders called sys.path (the script’s folder first, then PYTHONPATH, then installed packages).

import sys
print(sys.path[:3])            # the folders Python searches, in order
print("json" in sys.modules)   # False until something imports it

import importlib
import spam
importlib.reload(spam)         # re-read the file after editing (interactive use)

Compiled files. To start faster, Python saves the bytecode of imported modules in a __pycache__ folder (for example spam.cpython-314.pyc). It re-compiles automatically when the source changes. These files are safe to delete and should not be committed to Git.

Python ships with hundreds of ready-made modules (the “standard library”): maths, dates, files, JSON, web requests, tests. Check there before installing anything. The built-in dir() lists the names a module or object offers.

import math
print([n for n in dir(math) if not n.startswith("_")][:5])
# ['acos', 'acosh', 'asin', 'asinh', 'atan']

import builtins
print(len(dir(builtins)) > 100)    # True: print, len, range, ... all live here

A package is a folder that groups related modules, so names are written with dots: shop.billing.invoice. Packages let a big project stay tidy.

shop/                      # the package
├── __init__.py            # runs on import; can be empty
├── catalog.py
├── billing/               # a sub-package
│   ├── __init__.py
│   ├── invoice.py
│   └── tax.py
└── utils.py

# inside shop/billing/invoice.py
from . import tax                   # sibling module (relative import)
from .tax import gst_rate           # a name from it
from ..utils import slugify         # one level up
from shop.catalog import Product    # absolute import: clearest, preferred

Put an f before a string and write any expression inside { }. After a colon you can add a format spec that controls decimals, width, alignment and more.

name, price, qty = "Tea", 12.5, 3
print(f"{name}: {price * qty:.2f}")        # Tea: 37.50
print(f"{1234567:,}")                      # 1,234,567
print(f"[{'hi':>6}] [{'hi':<6}] [{'hi':^6}]")   # [    hi] [hi    ] [  hi  ]
print(f"{0.256:.1%}")                      # 25.6%
print(f"{255:b} {255:x} {255:08.2f}")      # 11111111 ff 00255.00
print(f"{name!r}")                         # 'Tea'   (repr)
x = 7
print(f"{x=}")                             # x=7     great for quick debugging

You will meet older styles in existing code. They all do the same job as f-strings.

print("{} costs {:.1f}".format("tea", 12.456))        # tea costs 12.5
print("{1} before {0}".format("work", "play"))         # play before work
print("{who} owes {amt}".format(who="Raj", amt=40))    # named placeholders
print("%s has %d items" % ("cart", 3))                 # old printf style

for n in (1, 10, 100):
    print(str(n).rjust(4), str(n).zfill(4))            # manual alignment
print("title".center(11, "*"))                         # ***title***
print(str("a\nb"), repr("a\nb"))                       # str shows it, repr shows how to type it

str(x) is for people; repr(x) is for developers and shows the exact value, including quotes and escape characters.

open() gives you a file object. Always use it with with, which guarantees the file is closed when the block ends, even if an error happens halfway.

with open("notes.txt", "w", encoding="utf-8") as f:    # "w" = write (overwrites!)
    f.write("first line\n")
    f.write("second line\n")

with open("notes.txt", encoding="utf-8") as f:         # default mode "r" = read
    for line in f:                  # one line at a time: fine for huge files
        print(line.rstrip())

with open("notes.txt", "a", encoding="utf-8") as f:    # "a" = append to the end
    f.write("third line\n")

pathlib: file paths as objects

from pathlib import Path

p = Path("reports") / "2026" / "summary.txt"    # / joins parts on any OS
p.parent.mkdir(parents=True, exist_ok=True)
p.write_text("done\n", encoding="utf-8")
print(p.exists(), p.suffix, p.stem)             # True .txt summary
for f in Path("reports").rglob("*.txt"):        # find files recursively
    print(f.name)

JSON is a plain-text format that nearly every language understands. Python converts dictionaries, lists, strings, numbers, booleans and None to JSON and back.

import json

settings = {"theme": "dark", "volume": 7, "tags": ["a", "b"], "beta": None}

text = json.dumps(settings, indent=2)      # dict -> JSON text (string)
with open("settings.json", "w", encoding="utf-8") as f:
    json.dump(settings, f)                 # dict -> file

with open("settings.json", encoding="utf-8") as f:
    loaded = json.load(f)                  # file -> dict
print(loaded == settings)                  # True
print(json.loads('{"ok": true}'))          # {'ok': True}   text -> dict

There are two kinds of mistakes. A syntax error means Python cannot even read your code (a missing colon or bracket); nothing runs. An exception happens while the program runs, for example dividing by zero. If you do not handle it, the program stops and prints a traceback.

Traceback (most recent call last):
  File "shop.py", line 9, in <module>
    print(total / count)
          ~~~~~~^~~~~~~
ZeroDivisionError: division by zero

Read a traceback from the bottom up: the last line names the problem, the lines above show the path of calls that led there, ending at the line that failed.

Wrap risky code in try. If something goes wrong, Python jumps to the matching except block instead of crashing. else runs only when nothing went wrong. finally runs no matter what.

def read_int(text):
    try:
        number = int(text)
    except ValueError:
        print(f"{text!r} is not a whole number")
        return None
    else:
        print("conversion worked")
        return number
    finally:
        print("done checking")        # prints even though we returned above

read_int("42")      # conversion worked / done checking
read_int("4x2")     # '4x2' is not a whole number / done checking

try:
    risky()
except (TypeError, KeyError) as err:   # one handler for several types
    print("problem:", err)

Python programmers usually “ask forgiveness, not permission” (EAFP): just try the operation and handle the error, rather than checking every condition first. It also avoids race conditions, such as a file being deleted between “does it exist?” and “open it”.

You can raise an exception yourself when your function receives something it cannot work with. This is better than returning a quiet wrong answer.

def set_age(age):
    if age < 0:
        raise ValueError("age cannot be negative")
    return age

try:
    set_age(-5)
except ValueError as err:
    print("Rejected:", err)       # Rejected: age cannot be negative
    raise                          # a bare raise passes the same error upward

assert condition, "message" is a sanity check for developers (“this must be true”). It can be switched off with python -O, so never use it to validate user input.

Sometimes a low-level error should become a clearer high-level one, but you still want the original clue. raise NewError from original links them, and the traceback shows both.

def load_config(text):
    try:
        return int(text)
    except ValueError as exc:
        raise RuntimeError("config value must be a number") from exc

# raise ... from None   hides the original when it would only confuse the reader

Create your own error type by subclassing Exception. A descriptive name tells the reader what went wrong, and callers can catch exactly that case.

class BankError(Exception):
    """Base class for all errors from this module."""

class InsufficientFunds(BankError):
    def __init__(self, balance, needed):
        super().__init__(f"balance {balance} is less than {needed}")
        self.balance = balance
        self.needed = needed

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFunds(balance, amount)
    return balance - amount

try:
    withdraw(100, 250)
except InsufficientFunds as err:
    print("Short by", err.needed - err.balance)   # Short by 150
except BankError:
    print("some other bank problem")

Whatever is in finally runs on the way out, whether the block succeeded, failed, returned, or hit break. Use it to release things you took: files, network connections, locks. Many objects already know how to clean up and work with with, which is shorter and harder to get wrong.

# manual clean-up
f = open("data.txt", encoding="utf-8")
try:
    process(f.read())
finally:
    f.close()                 # always runs

# the same, without the ceremony
with open("data.txt", encoding="utf-8") as f:
    process(f.read())

When many tasks run at the same time, several can fail at once. An ExceptionGroup bundles unrelated errors into one object. except* picks out the kinds you can handle; the rest keep travelling.

def import_rows():
    raise ExceptionGroup("batch failed", [
        ValueError("bad value in row 3"),
        TypeError("bad type in row 7"),
        ValueError("bad value in row 9"),
    ])

try:
    import_rows()
except* ValueError as group:
    print("value problems:", [str(e) for e in group.exceptions])
except* TypeError as group:
    print("type problems:", [str(e) for e in group.exceptions])
# value problems: ['bad value in row 3', 'bad value in row 9']
# type problems: ['bad type in row 7']

You will mostly meet these when using asyncio.TaskGroup (see the async topic).

Catch an error, attach extra context with add_note(), and re-raise it. The notes appear under the original message in the traceback, so whoever debugs it sees both what happened and where in your process it happened.

def process_order(order_id, price):
    try:
        return 100 / price
    except ZeroDivisionError as err:
        err.add_note(f"while processing order {order_id}")
        raise

process_order(42, 0)
# ZeroDivisionError: division by zero
# while processing order 42

In Python a variable does not contain a value; it is a label pointing at an object that lives elsewhere. Writing b = a does not copy anything. It sticks a second label on the same object. This matters when the object can be changed (lists, dictionaries, sets).

a = [1, 2]
b = a              # a second label on the SAME list
c = a.copy()       # a NEW list with equal contents
print(a is b, a is c, a == c)    # True False True

b.append(3)
print(a)           # [1, 2, 3]   changed through b!
print(c)           # [1, 2]      unaffected

import copy
nested = [[1], [2]]
shallow = nested.copy()          # new outer list, SAME inner lists
deep = copy.deepcopy(nested)     # everything copied
nested[0].append(99)
print(shallow[0], deep[0])       # [1, 99] [1]

A namespace is a table of names. A scope is the region of code where a table is searched. When you use a name, Python looks in four places, from the inside out: Local, Enclosing, Global, Built-in.

def scope_test():
    def do_local():
        spam = "local spam"            # a new local name
    def do_nonlocal():
        nonlocal spam                  # use the enclosing function's name
        spam = "nonlocal spam"
    def do_global():
        global spam                    # use the module-level name
        spam = "global spam"

    spam = "test spam"
    do_local();    print("after local:   ", spam)    # test spam
    do_nonlocal(); print("after nonlocal:", spam)    # nonlocal spam
    do_global();   print("after global:  ", spam)    # nonlocal spam

scope_test()
print("in global scope:", spam)                      # global spam

A class is a blueprint. Each object made from it (an instance) has its own data, and shares the blueprint’s methods. __init__ runs when an object is created and sets it up. The first parameter of every method, conventionally self, is the object the method is working on.

class Dog:
    species = "Canis familiaris"      # class variable: shared by every dog

    def __init__(self, name):
        self.name = name              # instance variables: one set per dog
        self.tricks = []

    def add_trick(self, trick):
        self.tricks.append(trick)

    def __repr__(self):               # how the object prints in the console
        return f"Dog({self.name!r})"

fido = Dog("Fido")
buddy = Dog("Buddy")
fido.add_trick("roll over")
print(fido.tricks, buddy.tricks)      # ['roll over'] []
print(fido.species == buddy.species)  # True
print(fido)                           # Dog('Fido')

fido.add_trick("x") is shorthand for Dog.add_trick(fido, "x"). Python passes the object in as self for you.

Python has no strict “private” keyword. It uses conventions: a single leading underscore (_balance) says “internal, please do not touch”. A double underscore (__pin) makes Python rename the attribute to _ClassName__pin so subclasses do not clash with it by accident.

A property lets you run code when someone reads or sets an attribute, while it still looks like a plain attribute from outside.

class Account:
    def __init__(self, balance):
        self._balance = balance

    @property
    def balance(self):                 # read: acct.balance
        return self._balance

    @balance.setter
    def balance(self, value):          # write: acct.balance = 50
        if value < 0:
            raise ValueError("balance cannot be negative")
        self._balance = value

acct = Account(100)
acct.balance = 150                     # runs the setter and checks the rule
# acct.balance = -5                    # ValueError

Dataclasses: the “record” shortcut

If a class mostly holds data, @dataclass writes __init__, __repr__ and __eq__ for you.

from dataclasses import dataclass, field

@dataclass(frozen=True, slots=True)        # frozen: unchangeable; slots: lighter memory
class Employee:
    name: str
    dept: str
    salary: int = 0

@dataclass
class Team:
    name: str
    members: list[str] = field(default_factory=list)   # safe mutable default

e = Employee("John", "computer lab", 1000)
print(e)                    # Employee(name='John', dept='computer lab', salary=1000)
print(e == Employee("John", "computer lab", 1000))     # True

A class can be built on top of another. The new class (child) gets everything from the old one (parent) and can add or replace parts. Use super() to call the parent’s version.

class Vehicle:
    def __init__(self, name):
        self.name = name
    def move(self):
        return f"{self.name} moves"

class Bicycle(Vehicle):
    def move(self):                          # override
        return f"{self.name} is pedalled"

class Car(Vehicle):
    def __init__(self, name, fuel):
        super().__init__(name)               # let the parent set up name
        self.fuel = fuel
    def move(self):
        return super().move() + f" on {self.fuel}"

for v in [Bicycle("Hero"), Car("Swift", "petrol")]:
    print(v.move())              # same call, different behaviour (polymorphism)
# Hero is pedalled
# Swift moves on petrol

print(isinstance(v, Vehicle), issubclass(Car, Vehicle))   # True True

A class may have several parents. When both parents share a grandparent (the “diamond”), Python needs a clear order for searching methods. It computes one called the MRO (method resolution order), and super() simply means “the next class in the MRO”, not necessarily the direct parent.

class A:
    def hello(self): return "A"
class B(A):
    def hello(self): return "B>" + super().hello()
class C(A):
    def hello(self): return "C>" + super().hello()
class D(B, C):
    def hello(self): return "D>" + super().hello()

print(D().hello())                           # D>B>C>A   each class runs once
print([k.__name__ for k in D.__mro__])       # ['D', 'B', 'C', 'A', 'object']

Mixins are the safe everyday use: small classes that add one ability (JsonMixin adds .to_json()) and are listed alongside the main parent.

An iterable is anything you can loop over. A iterator is the helper that remembers where you are. A for loop calls iter() once to get the iterator, then calls next() again and again until StopIteration is raised.

it = iter(["a", "b"])
print(next(it), next(it))      # a b
# next(it)                      # StopIteration: nothing left

class Countdown:
    def __init__(self, start):
        self.current = start
    def __iter__(self):
        return self                        # this object is its own iterator
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

print(list(Countdown(3)))                  # [3, 2, 1]

A function that uses yield is a generator. Calling it does not run it; it returns an object you pull values from. Each next() runs the function until the next yield, hands that value back and freezes right there with all its local variables intact. The next next() unfreezes it.

def countdown(n):
    while n > 0:
        yield n            # pause here and hand back n
        n -= 1

gen = countdown(2)
print(next(gen), next(gen))      # 2 1
for x in countdown(3):
    print(x, end=" ")            # 3 2 1

def read_big_file(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            if "ERROR" in line:
                yield line.rstrip()      # only one line in memory at a time

def chain_all(*lists):
    for items in lists:
        yield from items         # hand over to another iterable

Generators can be chained into pipelines: read lines → filter → transform → write. Each stage pulls from the one before, so data flows through without ever being stored in full.

A generator expression is a list comprehension written with round brackets. It produces values one at a time instead of building a whole list first, which saves memory when you only need to consume the values once (for sum, max, any, all, join).

print(sum(i * i for i in range(10)))                 # 285
print(sum(i * i for i in range(10**6)))              # no giant list in memory

lines = ["short", "a longer line", "mid"]
print(max(len(l) for l in lines))                    # 13
print(any(l.startswith("mid") for l in lines))       # True
print(", ".join(str(n) for n in range(5)))           # 0, 1, 2, 3, 4

squares_list = [n * n for n in range(5)]             # real list: reusable, has len()
squares_gen = (n * n for n in range(5))              # one-shot stream
print(list(squares_gen), list(squares_gen))          # [0, 1, 4, 9, 16] []   already used up

These modules let your program do what you would do in a file manager: look around, make folders, copy and move files, and find files by pattern.

import os, shutil, glob

print(os.getcwd())                           # where am I?
os.makedirs("backup", exist_ok=True)         # make a folder if missing
for path in glob.glob("reports/*.txt"):      # wildcard search
    shutil.copy(path, "backup")              # copy each match
shutil.move("old.txt", "archive/old.txt")

print(os.environ.get("HOME"))                # read an environment variable

For new code, pathlib.Path (see the Input and Output chapter) is the friendlier way to handle paths.

A well-behaved command-line program reads options with argparse, prints normal results to stdout, prints warnings and errors to stderr, and ends with an exit code (0 means success). Other tools use those codes to know whether your program worked.

import argparse, sys

parser = argparse.ArgumentParser(prog="top", description="Show top lines of files")
parser.add_argument("filenames", nargs="+")
parser.add_argument("-l", "--lines", type=int, default=10)
args = parser.parse_args()

for name in args.filenames:
    try:
        with open(name, encoding="utf-8") as f:
            print("".join(f.readlines()[: args.lines]), end="")
    except FileNotFoundError:
        print(f"warning: {name} not found", file=sys.stderr)
        sys.exit(1)               # non-zero = failure

A regular expression is a mini-language for describing text patterns, like a wildcard search with superpowers. Always write them as raw strings (r"...") so backslashes stay intact.

import re

text = "Order #123 shipped on 2026-10-08, order #456 pending"
print(re.findall(r"#(\d+)", text))                 # ['123', '456']

m = re.search(r"(\d{4})-(\d{2})-(\d{2})", text)
print(m.groups())                                  # ('2026', '10', '08')
print(re.sub(r"\s+", " ", "too    many   spaces"))  # too many spaces

pattern = re.compile(r"^[\w.+-]+@[\w-]+\.[\w.]+$")  # a simple email shape check
print(bool(pattern.match("asha@example.com")))     # True

If a simple string method does the job (str.replace, startswith, split), prefer it. It is easier to read.

import math, random, statistics

print(math.sqrt(144), math.ceil(4.1), math.floor(4.9))   # 12.0 5 4
print(round(math.pi, 4))                                 # 3.1416

random.seed(7)                                  # same seed = same "random" numbers
print(random.choice(["red", "green", "blue"]))  # one item
print(random.sample(range(1, 50), 6))           # 6 different numbers (a lottery ticket)
print(random.random())                          # a float from 0.0 up to 1.0

data = [2, 4, 4, 4, 5, 5, 7, 9]
print(statistics.mean(data), statistics.median(data))    # 5 4.5
print(round(statistics.stdev(data), 3))                  # 2.138

The standard library can fetch web pages (urllib.request) and send email (smtplib). Most people use the friendlier third-party package requests (or httpx) for web APIs, but the built-in way needs no installation.

from urllib.request import urlopen
import json

with urlopen("https://httpbin.org/json", timeout=10) as response:
    data = json.load(response)          # an API reply parsed from JSON
print(type(data))                       # <class 'dict'>

# with the popular third-party package (pip install requests):
# import requests
# r = requests.get("https://httpbin.org/json", timeout=10)
# r.raise_for_status()
# print(r.json())

from datetime import date, datetime, timedelta
from zoneinfo import ZoneInfo

today = date(2026, 10, 8)
print(today + timedelta(days=30))              # 2026-11-07
print(date(2027, 1, 1) - today)                # 85 days, 0:00:00
print(today.strftime("%A, %d %B %Y"))          # Thursday, 08 October 2026

meeting = datetime(2026, 10, 8, 14, 30, tzinfo=ZoneInfo("Europe/Amsterdam"))
print(meeting.astimezone(ZoneInfo("Asia/Kolkata")))     # 2026-10-08 18:00:00+05:30

parsed = datetime.strptime("08/10/2026 09:15", "%d/%m/%Y %H:%M")   # text -> datetime
print(parsed.isoformat())                      # 2026-10-08T09:15:00

Compression

import zlib, zipfile

s = b"witch which has which witches wrist watch"
t = zlib.compress(s)
print(len(s), len(t))                  # 41 37
print(zlib.decompress(t) == s)         # True

with zipfile.ZipFile("backup.zip", "w") as z:     # make a zip archive
    z.write("notes.txt")

Measuring speed

Do not guess which version is faster; measure. timeit runs a snippet many times. cProfile shows where a whole program spends its time.

from timeit import timeit
print(timeit("a, b = b, a", setup="a = 1; b = 2", number=100_000))   # seconds, varies

# python3 -m cProfile -s cumtime my_program.py

Testing

Tests are small programs that check your code, so you notice breakage when you change something later. doctest runs examples found in docstrings; unittest is the built-in framework; pytest is a popular third-party one with less boilerplate.

import unittest

def average(values):
    """Return the mean of a list.

    >>> average([20, 30, 70])
    40.0
    """
    return sum(values) / len(values)

class TestAverage(unittest.TestCase):
    def test_basic(self):
        self.assertEqual(average([20, 30, 70]), 40.0)
    def test_empty_list(self):
        with self.assertRaises(ZeroDivisionError):
            average([])

if __name__ == "__main__":
    unittest.main()

import pprint, textwrap
from string import Template

config = {"server": {"host": "10.0.0.5", "ports": [80, 443, 8080]}, "debug": False, "tags": ["a", "b"]}
pprint.pprint(config, width=40)               # wraps nested data readably

paragraph = "Python is easy to learn and powerful, and its standard library is big."
print(textwrap.fill(paragraph, width=30))     # re-wrap to 30 columns

t = Template("Hello $name, your order $order_id has shipped.")
print(t.substitute(name="Asha", order_id=981))
print(t.safe_substitute(name="Li"))           # missing keys are left as they are

string.Template is a good fit when non-programmers write the text, because the placeholders are simple and cannot run code.

When you read file formats or network protocols, data arrives as raw bytes with a fixed layout. struct converts between Python values and that byte layout. The format string says what each field is (H = 2-byte unsigned integer, I = 4-byte unsigned integer, < = little-endian).

import struct

data = struct.pack("<HHI", 1, 2, 3)     # three numbers packed into 8 bytes
print(len(data), data.hex())            # 8 0100020003000000
print(struct.unpack("<HHI", data))     # (1, 2, 3)

A thread lets your program do several things at the same time, such as downloading three files at once. Threads are best when your program mostly waits (for networks, disks, databases). The advanced chapter explains why threads do not speed up heavy calculation in the standard build, and what to use instead.

import threading, time

def fetch(name, seconds):
    time.sleep(seconds)               # pretend to wait for a slow server
    print(f"{name} done")

threads = [threading.Thread(target=fetch, args=(f"job{i}", 1)) for i in range(3)]
for t in threads:
    t.start()                         # all three start together
for t in threads:
    t.join()                          # wait until each has finished
# about 1 second in total, not 3

lock = threading.Lock()
counter = 0
def add_many():
    global counter
    for _ in range(100_000):
        with lock:                    # only one thread at a time may change counter
            counter += 1

Logging records what your program is doing, with a severity level and a timestamp. You can turn detail up or down without editing the code, and send messages to a file.

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    filename="app.log",              # omit to print to the screen
)
log = logging.getLogger(__name__)

log.debug("detail only developers want")      # hidden at INFO level
log.info("server started on port %s", 8080)   # pass values as arguments
log.warning("disk 90%% full")
try:
    1 / 0
except ZeroDivisionError:
    log.exception("calculation failed")       # includes the traceback

A weak reference points at an object without keeping it alive. It is used for caches: you remember a result only as long as something else still needs it, and the memory is freed automatically afterwards.

import weakref

class Big:
    pass

cache = weakref.WeakValueDictionary()
obj = Big()
cache["report"] = obj
print("report" in cache)       # True
del obj                        # last normal reference gone
print("report" in cache)       # False (in CPython, freed immediately)

Other tools for lists: heapq keeps the smallest item instantly available (a priority queue), and bisect keeps a list sorted as you insert.

import heapq, bisect

tasks = [(3, "write report"), (1, "fix outage"), (2, "reply to client")]
heapq.heapify(tasks)
print(heapq.heappop(tasks))                  # (1, 'fix outage')   most urgent first
print(heapq.nsmallest(2, [9, 3, 7, 1]))      # [1, 3]

scores = [60, 70, 80, 90]
bisect.insort(scores, 75)
print(scores)                                # [60, 70, 75, 80, 90]

The decimal module does arithmetic the way humans do it on paper, with no hidden binary rounding. Use it for prices, invoices and tax.

from decimal import Decimal, ROUND_HALF_UP

price = Decimal("0.70")
tax = price * Decimal("0.05")
print(price + tax)                                    # 0.7350
print((price + tax).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))   # 0.74

print(sum([Decimal("0.1")] * 10) == Decimal("1.0"))   # True
print(sum([0.1] * 10) == 1.0)                         # False  (plain floats)

Always build a Decimal from a string (Decimal("0.1")). Decimal(0.1) copies the float’s tiny error along with it.

Third-party libraries (from PyPI, the Python Package Index) are installed with pip. If every project shared one pile of libraries, a project needing an old version of a library would clash with one needing the new version. A virtual environment is a private folder of libraries for one project.

# 1. create the environment inside your project folder
python3 -m venv .venv

# 2. switch it on
source .venv/bin/activate          # macOS / Linux
.venv\Scripts\activate             # Windows

# 3. install what you need (now it goes into .venv only)
pip install requests
pip install "requests==2.31.0"     # an exact version
pip list                           # what is installed here?

# 4. record and re-create the set of libraries
pip freeze > requirements.txt
pip install -r requirements.txt    # on another machine or in CI

deactivate                         # switch it off

Reading is only the first step. The fastest way to improve is to build small things you care about and look things up as you go.

• The Python standard library reference is the manual for every built-in module.
• The language reference has the exact rules, for when you need precision.
• The glossary explains terms like iterable and hashable.
• PyPI lists hundreds of thousands of installable packages.

The prompt remembers what you typed. Press ↑ to bring back earlier lines, Tab to complete names (type math.s then Tab), and Ctrl+R to search your history. Multi-line blocks can be edited as a whole.

If you want more, other prompts add colour, richer completion and inline help: IPython, bpython, and notebooks such as Jupyter, which mix code, charts and notes on one page and are very popular for data work.

Computers store decimals in binary. Some simple decimal fractions, like 0.1, have no exact binary form, just as 1/3 has no exact decimal form (0.3333…). The stored value is a very close approximation, and tiny errors can show up.

print(0.1 + 0.2)                  # 0.30000000000000004
print(0.1 + 0.2 == 0.3)           # False

import math
print(math.isclose(0.1 + 0.2, 0.3))     # True   compare floats with a tolerance

print((0.1).as_integer_ratio())   # (3602879701896397, 36028797018963968)   the real stored value
print(round(2.675, 2))            # 2.67   (2.675 is stored as slightly less)

from fractions import Fraction
print(Fraction(1, 10) + Fraction(2, 10) == Fraction(3, 10))   # True   exact

This is not a Python bug. Every language using standard hardware floats (JavaScript, Java, C) behaves the same way.

Executable scripts. On macOS and Linux, start a script with a shebang line and mark it executable, and you can run it like any other command.

#!/usr/bin/env python3
$ chmod +x tool.py
$ ./tool.py

Error handling in the prompt. After an error the prompt stays open and shows the traceback. Press Ctrl+C to cancel the current line and return to the primary prompt. Use python3 -i script.py to land at the prompt with your script’s variables still alive for inspection.

The startup file. Point the PYTHONSTARTUP environment variable at a file, and Python runs it every time you open the interactive prompt. People use it to pre-import favourite modules. Site-wide customisation lives in sitecustomize and usercustomize modules.

# ~/.pythonrc  (then: export PYTHONSTARTUP=~/.pythonrc)
import os, sys, math, json
from pathlib import Path
print("ready: os, sys, math, json, Path")

A decorator is a function that takes a function and returns a new one, usually adding something before or after the original runs. The @name line above a def is just shorthand for func = name(func). It builds on two ideas you already met: functions are values, and inner functions remember outer variables (closures).

import functools, time

def timed(func):
    @functools.wraps(func)              # keep the original name and docstring
    def wrapper(*args, **kwargs):       # accept anything, pass it along
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.3f}s")
        return result
    return wrapper

@timed                                  # same as: slow_sum = timed(slow_sum)
def slow_sum(n):
    return sum(range(n))

slow_sum(10_000_000)                    # slow_sum took 0.1xx s   (varies)

A decorator that takes its own settings

Add one more layer: the outer function receives the settings and returns the real decorator.

def retry(times):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    if attempt == times:
                        raise           # out of tries: let the error through
        return wrapper
    return decorator

@retry(times=3)
def fetch_data():
    ...

You already use decorators from the library: @property, @staticmethod, @classmethod, @dataclass, @functools.cache.

You have used with open(...). Any object with __enter__ and __exit__ can be used the same way. Python calls __enter__ on the way in and __exit__ on the way out, even if the block raised an error.

import time

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self                         # becomes the name after "as"
    def __exit__(self, exc_type, exc, tb):
        print(f"took {time.perf_counter() - self.start:.2f}s")
        return False                        # do not hide exceptions

with Timer() as t:
    sum(range(5_000_000))

The shortcut: contextlib

import os
from contextlib import contextmanager, suppress

@contextmanager
def working_directory(path):
    old = os.getcwd()
    os.chdir(path)                # runs on the way in
    try:
        yield                     # your with-block runs here
    finally:
        os.chdir(old)             # always restores, even after an error

with working_directory("/tmp"):
    print(os.getcwd())

with suppress(FileNotFoundError):  # "ignore this one specific error"
    os.remove("temp.txt")

Methods with double underscores on both sides are hooks that Python calls for you. When you write a + b, Python runs a.__add__(b). When you write len(x), it runs x.__len__(). By defining them, your own objects behave like built-in types.

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    def __mul__(self, k):
        return Vector(self.x * k, self.y * k)
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)
    def __hash__(self):                       # needed because __eq__ was defined
        return hash((self.x, self.y))
    def __abs__(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
    def __bool__(self):
        return bool(self.x or self.y)

v = Vector(3, 4)
print(v + Vector(1, 1))        # Vector(4, 5)
print(v * 2, abs(v))           # Vector(6, 8) 5.0
print(Vector(1, 2) == Vector(1, 2), bool(Vector(0, 0)))   # True False

Looking up a key in a dictionary does not scan all keys. Python turns the key into a number with hash(), uses it to jump straight to a slot in an internal table, and checks that slot. The time barely changes whether there are ten keys or ten million.

• Hashable means the hash never changes during the object’s life. That is why keys can be strings, numbers and tuples of those, but not lists or dicts.
• Equal objects must have equal hashes: hash(1) == hash(1.0).
• Membership test cost: x in my_list is O(n), x in my_set is O(1) on average. Convert a big list to a set before many lookups.

print(hash("apple") == hash("apple"))    # True within one run
# hash("apple") differs from run to run on purpose (security), so never store it

big = list(range(1_000_000)); lookup = set(big)
print(999_999 in big)       # scans up to a million items
print(999_999 in lookup)    # one jump

functools

@cache remembers results so the same call is never computed twice (memoisation). partial pre-fills some arguments. reduce folds a sequence into one value.

from functools import cache, partial, reduce
import operator

@cache
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)
print(fib(80))                          # 23416728348467685, instantly (naive recursion would take ages)

from_binary = partial(int, base=2)
print(from_binary("1010"))              # 10

print(reduce(operator.mul, [1, 2, 3, 4]))   # 24

itertools

Building blocks for working with streams of data without making big lists.

from itertools import count, islice, chain, combinations, product, accumulate, batched, groupby

print(list(islice(count(10, 5), 3)))            # [10, 15, 20]
print(list(chain([1, 2], "ab")))                # [1, 2, 'a', 'b']
print(list(combinations("ABC", 2)))             # [('A', 'B'), ('A', 'C'), ('B', 'C')]
print(list(product([1, 2], "ab")))              # [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
print(list(accumulate([1, 2, 3, 4])))           # [1, 3, 6, 10]   running total
print(list(batched(range(7), 3)))               # [(0, 1, 2), (3, 4, 5), (6,)]

orders = [("tea", "Asha"), ("tea", "Li"), ("coffee", "Raj")]   # must be sorted by key first
for item, group in groupby(orders, key=lambda o: o[0]):
    print(item, [name for _, name in group])    # tea ['Asha', 'Li'] / coffee ['Raj']

Beyond int and str, the typing system can describe flexible code: functions that work for any element type (generics), objects that merely need certain methods (protocols), and dictionaries with known keys (TypedDict). A checker such as mypy or pyright reads these hints and reports mistakes before you run anything.

from typing import Protocol, TypedDict, Literal, Callable

def first[T](items: list[T]) -> T:        # generic function (3.12+ syntax)
    return items[0]

class Greeter(Protocol):                   # structural typing: "has a greet() method"
    def greet(self) -> str: ...

class English:                             # no inheritance needed, it just fits
    def greet(self) -> str:
        return "Hello"

def welcome(g: Greeter) -> None:
    print(g.greet())

class Movie(TypedDict):                    # a dict with known keys
    title: str
    year: int

Mode = Literal["r", "w", "a"]              # only these exact values allowed
type Pair = tuple[int, int]                # type alias statement (3.12+)

def run(handler: Callable[[int], str], value: int) -> str:
    return handler(value)

welcome(English())                         # Hello

Abstract base classes

Use abc.ABC when you want to force subclasses to implement certain methods. Trying to create an object from a class with missing methods fails immediately.

from abc import ABC, abstractmethod

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

class Square(Shape):
    def __init__(self, side): self.side = side
    def area(self): return self.side ** 2

# Shape()          TypeError: can't instantiate abstract class
print(Square(3).area())    # 9

When a value can only be one of a few options (order status, traffic light, user role) an Enum is safer than loose strings. A typo in "shiped" goes unnoticed; Status.SHIPED fails immediately.

from enum import Enum, auto

class Status(Enum):
    PENDING = auto()
    SHIPPED = auto()
    DELIVERED = auto()

s = Status.SHIPPED
print(s.name, s.value)                    # SHIPPED 2
print(Status["PENDING"], Status(3))       # Status.PENDING Status.DELIVERED
print(s is Status.SHIPPED)                # True

for st in Status:                         # iterate all choices
    print(st.name)

def describe(status: Status) -> str:
    match status:                         # works nicely with match
        case Status.PENDING:  return "waiting"
        case Status.SHIPPED:  return "on its way"
        case Status.DELIVERED: return "arrived"

A str is a sequence of characters. A bytes object is a sequence of raw numbers (0 to 255). Files and networks carry bytes, so text must be encoded on the way out and decoded on the way in. The standard choice is UTF-8.

text = "café ₹"
data = text.encode("utf-8")
print(len(text), len(data))              # 6 9   six characters, nine bytes
print(data)                              # b'caf\xc3\xa9 \xe2\x82\xb9'
print(data.decode("utf-8") == text)      # True

# data.decode("ascii")    UnicodeDecodeError: wrong code book
print(data.decode("ascii", errors="replace"))   # shows ? for bytes it cannot read

import unicodedata
a, b = "é", "é"                    # one character vs e + combining accent
print(a == b)                            # False, though they look identical
print(unicodedata.normalize("NFC", b) == a)   # True

Python gives you three ways to do many things at once. Pick by asking: is my program mostly waiting (network, disk), or mostly calculating?

The GIL in one paragraph

In the standard build, CPython has a Global Interpreter Lock: only one thread executes Python bytecode at any instant. It makes the interpreter simpler and safe, and it is why threads do not speed up pure-Python calculation. Waiting for I/O releases the lock, so threads still help for downloads. An optional free-threaded build without the GIL exists (experimental in 3.13, officially supported but still optional from 3.14), and some libraries need updating to use it.

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import urllib.request

def size_of(url):
    with urllib.request.urlopen(url, timeout=10) as r:
        return len(r.read())

with ThreadPoolExecutor(max_workers=8) as pool:      # waiting overlaps
    sizes = list(pool.map(size_of, ["https://example.com", "https://example.org"]))

def heavy(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":                           # required for processes on Windows/macOS
    with ProcessPoolExecutor() as pool:              # one worker per core by default
        print(list(pool.map(heavy, [10**6] * 4)))

A function defined with async def is a coroutine: calling it creates a paused job instead of running it. The event loop runs many such jobs in one thread. When a job reaches await something, it says “I am waiting, someone else can go” and the loop switches to another job.

import asyncio

async def make_drink(name, seconds):
    print(f"{name}: started")
    await asyncio.sleep(seconds)          # hand control back while waiting
    print(f"{name}: ready")
    return name

async def main():
    async with asyncio.TaskGroup() as tg:            # starts them together, waits for all
        t1 = tg.create_task(make_drink("latte", 2))
        t2 = tg.create_task(make_drink("espresso", 1))
        t3 = tg.create_task(make_drink("tea", 1))
    print("all done:", t1.result(), t2.result(), t3.result())   # after ~2 s

asyncio.run(main())                       # start the event loop

• await only works inside async def, and only on things built for it (asyncio.sleep, async HTTP clients, async database drivers).
• A normal blocking call such as time.sleep(5) or requests.get() inside a coroutine freezes the whole loop. Move it to a thread with await asyncio.to_thread(func, ...).
• If tasks in a TaskGroup fail, you receive an ExceptionGroup (see the exceptions chapter).
• Limit waiting with async with asyncio.timeout(5):.

Every Python object keeps a count of how many names and containers point at it. When the count reaches zero, the object is freed at once. The one gap is a reference cycle (A points to B and B points to A): their counts never reach zero, so a separate garbage collector periodically hunts for such islands and frees them.

import sys, gc

a = []
print(sys.getrefcount(a))     # 2: the name a, plus the temporary argument itself
b = a
print(sys.getrefcount(a))     # 3
del b                         # back to 2

class Node:
    def __init__(self):
        self.other = None

x, y = Node(), Node()
x.other, y.other = y, x       # a cycle: each keeps the other alive
del x, y                      # names gone, but the objects still point at each other
print(gc.collect() > 0)       # True: the collector found and freed the island

• Memory “leaks” in Python are usually objects you still reference: a growing global list, a cache with no limit, an event handler never removed.
• Big lists of small objects cost memory. __slots__ or @dataclass(slots=True) remove the per-object dictionary.
• Use generators and iterators, not giant lists, for data that streams through.

Everything is an object, including classes. This opens deep customisation. Learn it to understand how frameworks (Django, SQLAlchemy, dataclasses, pydantic) work. Use it rarely in your own code.

Descriptors: reusable attribute rules

A descriptor is an object stored on a class that controls reading and writing an attribute. property is one. Write your own to share a rule across many attributes.

class Positive:
    def __set_name__(self, owner, name):
        self.name = "_" + name
    def __get__(self, obj, objtype=None):
        return getattr(obj, self.name)
    def __set__(self, obj, value):
        if value <= 0:
            raise ValueError(f"{self.name[1:]} must be positive")
        setattr(obj, self.name, value)

class Product:
    price = Positive()          # one rule, reused
    quantity = Positive()
    def __init__(self, price, quantity):
        self.price, self.quantity = price, quantity

p = Product(250, 3)
# p.price = -1                   ValueError: price must be positive

__init_subclass__: react when a class is subclassed

class Plugin:
    registry = {}
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        Plugin.registry[cls.__name__.lower()] = cls     # auto-register

class Csv(Plugin): ...
class Json(Plugin): ...
print(list(Plugin.registry))                            # ['csv', 'json']

Metaclasses: the class of a class

print(type(3), type(Product))        # <class 'int'> <class 'type'>
Dog = type("Dog", (), {"speak": lambda self: "woof"})   # build a class at run time
print(Dog().speak())                 # woof

Once a script grows into a project, give it a standard shape so tools, teammates and installers know where everything lives.

myproject/
├── pyproject.toml          # name, version, dependencies, commands
├── README.md
├── src/
│   └── myapp/
│       ├── __init__.py
│       ├── core.py
│       └── cli.py
└── tests/
    └── test_core.py

# pyproject.toml
[project]
name = "myapp"
version = "0.1.0"
requires-python = ">=3.10"
dependencies = ["requests>=2.31"]

[project.scripts]
myapp = "myapp.cli:main"        # installs a "myapp" command

# then, in a virtual environment:
pip install -e .                # editable install: edits take effect at once
pytest                          # run all tests

# tests/test_core.py
import pytest
from myapp.core import average

def test_average():
    assert average([20, 30, 70]) == 40

def test_empty_list():
    with pytest.raises(ZeroDivisionError):
        average([])

@pytest.mark.parametrize("values, expected", [([1, 2, 3], 2), ([10], 10)])
def test_many(values, expected):          # one test, many cases
    assert average(values) == expected

Useful companions: ruff (linting and formatting), mypy or pyright (type checking), and a CI job that runs all three on every commit.

This tutorial describes Python 3.14. These are the language and library changes most worth knowing. Check the official What’s New in Python 3.14 page for the complete list.

name = "world"
greeting = t"Hello {name}"           # a Template object, not a str (3.14+)
print(type(greeting).__name__)       # Template
print(greeting.strings)              # ('Hello ', '')
print(greeting.interpolations[0].value)   # world

Strings never change in place. Each method returns a new string.

Catching a parent catches all its children. except LookupError handles both KeyError and IndexError.

BaseException
├── KeyboardInterrupt, SystemExit      # do not catch these by accident
└── Exception                          # catch from here down
    ├── ArithmeticError  → ZeroDivisionError, OverflowError
    ├── LookupError      → KeyError, IndexError
    ├── OSError          → FileNotFoundError, PermissionError, TimeoutError
    ├── ValueError       → UnicodeError
    ├── TypeError
    ├── AttributeError
    ├── NameError        → UnboundLocalError
    ├── ImportError      → ModuleNotFoundError
    ├── RuntimeError     → RecursionError, NotImplementedError
    ├── StopIteration
    └── AssertionError

O(1) means “about the same time however big the data is”. O(n) means “time grows with the number of items”. Pick the structure whose common operation is cheap.

• Changing a list or dict while looping over it. Loop over a copy or build a new one.
• Using a list or dict as a default argument value (def f(x=[])).
• Comparing with is where you meant == (numbers, strings).
• Naming a variable list, dict, str, max, sum or id. It hides the built-in.
• Naming your file random.py, json.py or email.py. It hides the standard module.
• Forgetting that input() returns a string. Convert with int() or float().
• Comparing floats with ==. Use math.isclose() or Decimal.
• Catching everything with a bare except:. Name the error you expect.
• Opening files without with and without encoding="utf-8".
• Building a long string with += in a loop. Collect pieces and "".join(pieces).
• Blocking calls (time.sleep, requests.get) inside async def.
• Forgetting if __name__ == "__main__": around process-spawning code.
• Mixing tabs and spaces for indentation.