Glossary

You create a variable with the assignment operator =: the name on the left starts referring to the value on the right. The same name can be reassigned at any time, and it can hold any type of value, text, a number, a list, and so on.

Names may contain letters, digits, and underscores, cannot start with a digit, and are case-sensitive, age and Age are two different variables.

Variables are everywhere: storing user input, counting progress in a loop, holding an API response, or remembering a filename to write to later.

A variable isn’t a class with methods, but a few built-ins inspect what a name points to:

• type(value), show what kind of object a name points to
• isinstance(value, int), check whether it points to a given type
• del name, remove a name so it no longer points to anything

Official documentation: Python Language Reference: Assignment statements

• Variables Explained Simply

• String
• Integer
• Object

Syntax is the set of grammar rules every Python program must follow: a colon after an if, for, or def line; consistent indentation for the block underneath; and matching quotes and brackets. Break a rule and Python reports a SyntaxError and refuses to run the file at all, nothing executes until it's fixed.

Syntax governs every line you write. A syntax error stops the program before it runs at all, unlike a runtime error that happens mid-execution.

Official documentation: Python Tutorial: Syntax Errors

• Common Python Errors

• Exception
• Variable

A string is text wrapped in single or double quotes, both styles are equivalent. You can join strings with +, read one character by position with text[0], take a slice with text[1:4], and call built-in methods such as .upper() or .replace().

Strings are immutable: a method never changes the original, it returns a brand-new string.

Strings show up whenever you touch text: cleaning user input, building filenames, formatting a report line, or reading a row from a CSV.

str is a built-in type with many methods, the ones you’ll use most:

• .upper() / .lower(), return an upper/lowercased copy
• .strip(), remove surrounding whitespace
• .replace(old, new), swap one substring for another
• .split(sep), break text into a list of parts
• ' '.join(parts), join a list of strings back together
• .startswith(x) / .endswith(x), test how the text begins or ends
• f'{value}', f-strings drop values straight into text

Official documentation: Python Library Reference: Text Sequence Type, str

• Strings

• List
• Integer
• Variable

An integer (int) is a whole number, positive or negative, with no fractional part. Python integers have unlimited size. They never overflow, so you can compute enormous numbers exactly. Use // for floor (whole-number) division and % for the remainder.

Whole numbers count things, index into sequences, drive loop ranges, and store money in whole cents to avoid rounding errors.

• int('42'), turn a string of digits into an int
• a // b, floor (whole-number) division
• a % b, the remainder
• abs(n), distance from zero
• 2 ** 10, exact powers, no overflow
• divmod(a, b), quotient and remainder together

Official documentation: Python Library Reference: Numeric Types, int, float, complex

• Numbers

• Float
• Boolean
• String

A float is a number with a decimal point, used for measurements and any value that isn't whole. The division operator / always produces a float, even for something like 10 / 2. Floats are stored in binary, so a few decimals can't be represented exactly and you may see a tiny rounding error.

Floats handle anything with a fractional part: averages, prices, measurements, and percentages.

• float('3.14'), parse a decimal string
• round(x, 2), round to a number of decimal places
• abs(x), drop the sign
• f'{x:.2f}', format to a fixed number of decimals
• import math, math.floor, math.ceil, math.sqrt, …

Official documentation: Python Tutorial: Floating-Point Arithmetic — Issues and Limitations

• Numbers

• Integer
• String

A boolean (bool) holds one of just two values: True or False. Comparisons such as 5 > 3 evaluate to a boolean, and booleans drive if statements and while loops. Combine them with and, or, and not.

Python also treats other values as "truthy" or "falsy": 0, 0.0, an empty string, an empty list [], and None all count as false inside a condition.

Booleans drive every decision: the condition in an if or while, validating input, and toggling features on or off.

• and / or / not, combine and invert conditions
• == != < > <= >=, comparisons that produce True/False
• any(items) / all(items), is any/are all of them truthy
• bool(x), see how a value is judged truthy or falsy

Official documentation: Python Library Reference: Truth Value Testing

• Booleans and None

• Conditional
• if statement
• Integer

A list is an ordered, changeable collection written in square brackets, like [1, 2, 3]. Items keep their order, can be of mixed types, and are reached by position starting at 0, items[0] is the first and items[-1] the last. Lists are mutable: you can append, insert, replace, and remove items after creating them.

Lists collect things in order: rows read from a file, a queue of tasks, or results you build up as a loop runs.

list is a built-in type, the methods you’ll reach for most:

• .append(x), add one item to the end
• .extend(items), add several items
• .insert(i, x), add at a position
• .remove(x), delete the first matching item
• .pop(i), remove and return an item
• .sort() / sorted(seq), order in place / return a sorted copy
• len(seq), seq[1:3], x in seq, length, slice, membership

Official documentation: Python Tutorial: More on Lists

• Lists

• Tuple
• Set
• Dictionary
• Loop

A tuple is like a list, but immutable, once created, its items cannot be changed. You write one in parentheses (or just commas), index it like a list, and unpack it into several variables at once. Tuples are ideal for a fixed group of values, like an (x, y) coordinate or the several results a function returns.

Tuples show up as coordinates, database rows, dictionary keys, and any time a function returns several values at once.

• (1, 2, 3), create a tuple with parentheses
• x, y = point, unpack into variables
• point[0], index like a list
• len(point), item in point, length and membership
• tuple([1, 2]), convert a list to a tuple

Official documentation: Python Library Reference: Tuples

• Tuples

• List
• Set
• Dictionary

A set stores unique values, no duplicates, with no fixed order. It is built for fast membership tests (x in s) and set math: union, intersection, and difference. Create one with braces or set(...). Note that {} makes an empty dictionary, so use set() for an empty set.

Sets are perfect for removing duplicates, testing membership quickly, and comparing two collections, who is in list A but not list B.

• .add(x), add an item
• .discard(x), remove without error if missing
• a | b, union, items in either
• a & b, intersection, items in both
• a - b, difference, in a but not b
• set(items), drop duplicates from a list

Official documentation: Python Library Reference: Set Types

• Sets

• List
• Tuple
• Dictionary

A dictionary stores data as key/value pairs inside curly braces, like {'name': 'Sam'}. Instead of a numeric position you look things up by key. Keys must be unique, so assigning to an existing key overwrites its value, and .get() returns a fallback you choose when a key might be missing.

Dictionaries map keys to values: counting how often things occur, holding configuration, or modeling JSON-like records you look up by name.

dict is a built-in type with its own methods:

• .get(key, default), read safely instead of raising KeyError
• .keys() / .values(), view all keys or all values
• .items(), loop over key/value pairs together
• .setdefault(key, default), read a key, inserting a default if missing
• .update(other), merge another dict’s pairs in
• .pop(key, default), remove a key and return its value

Official documentation: Python Tutorial: Dictionaries

• Dictionaries

• List
• Loop
• Object

A conditional chooses which code to run based on a Boolean test. if runs its block when the condition is true; optional elif branches test further conditions; else catches everything left over. Only the first matching branch runs.

Conditionals are behind every decision a program makes: validating input, choosing a code path, handling edge cases.

• if / elif / else, branch on one or more conditions
• and / or / not, combine conditions
• x if cond else y, a one-line conditional expression
• ==, in, <, >, the tests that produce True/False

Official documentation: Python Tutorial: if Statements

• if Statements

• if statement
• Boolean
• Loop

An if statement is the most common conditional: it tests a Boolean condition and runs the indented block beneath it only when that condition is True. Add elif for extra cases and else for the fallback.

If statements guard risky actions, pick between options, and check results throughout every real program.

• if condition:, run a block conditionally
• elif other:, test another case
• else:, the fallback branch
• if x and y:, combine conditions

Official documentation: Python Tutorial: if Statements

• if Statements

• Conditional
• Boolean
• for loop

A loop runs the same block of code more than once. A for loop repeats once per item in a sequence (a list, string, range, and so on), binding each item to a variable in turn. A while loop keeps going as long as a condition stays True. Inside either, break stops the loop early and continue skips to the next round.

Loops do the repetitive work: processing each file, row, or item; retrying until something succeeds; or building a list one piece at a time.

• range(n), loop a fixed number of times
• enumerate(seq), loop with an index
• zip(a, b), loop over two sequences together
• break / continue, stop early / skip to the next item
• [x for x in seq], a comprehension, a loop that builds a list

Official documentation: Python Tutorial: for Statements

• Loops: Repeating Work

• for loop
• while loop
• Conditional
• Generator

A for loop walks through a sequence — a list, string, range, dictionary, or any iterable, binding each item to a variable in turn and running its body once per item. It is the go-to loop when you know what you are iterating over.

For loops process each file in a folder, each row in a CSV, each result from an API, anywhere you handle a collection one item at a time.

• range(n), loop a fixed number of times
• enumerate(seq), loop with an index
• zip(a, b), loop two sequences together
• break / continue, stop early / skip an item
• for k, v in d.items(), loop a dictionary’s pairs

Official documentation: Python Tutorial: for Statements

• for Loops

• Loop
• while loop
• Iterator

A while loop repeats its body over and over as long as a condition is True, checking the condition before each round. Use it when you do not know in advance how many times to repeat, waiting for valid input, retrying, or running until a total is reached. Something inside must eventually make the condition false, or the loop never ends.

While loops drive menus, retry-until-success logic, and any process that runs until a condition changes rather than a fixed number of times.

• while condition:, repeat while it stays True
• break, leave the loop immediately
• continue, skip to the next check
• while True: … break, loop until you decide to stop

Official documentation: Python Language Reference: The while statement

• while Loops

• Loop
• for loop
• Boolean

An exception is an error that happens while a program runs, as opposed to a syntax error, which is caught before it starts. When something goes wrong (dividing by zero, a missing key, bad input), Python raises an exception that stops the program with a traceback unless you catch it. Wrap risky code in try / except to handle the problem and keep running.

Exceptions show up wherever things can go wrong: bad user input, a missing file, a failed network call. Handling them keeps a script from crashing.

• try / except, run risky code and catch failures
• except ValueError, catch one specific kind of error
• else / finally, run on success / always run (cleanup)
• raise, signal an error yourself
• ValueError, KeyError, FileNotFoundError, common built-in types

Official documentation: Python Tutorial: Errors and Exceptions

• Exceptions and try/except

• try / except
• Syntax
• Unit test

try / except is how Python handles exceptions. Code that might fail goes in the try block; if it raises an error, the matching except block runs instead of the program crashing. Add else for code to run when nothing failed, and finally for cleanup that always runs.

You will wrap file reads, network calls, and type conversions in try/except so one bad input does not take down the whole script.

• try: / except:, run risky code and catch failures
• except ValueError as e, catch a type and inspect it
• except (A, B), catch several types at once
• else:, run only if no error
• finally:, always run (cleanup)
• raise, re-raise or signal an error

Official documentation: Python Tutorial: Handling Exceptions

• Exceptions and try/except

• Exception
• Syntax
• Context manager

A traceback is Python telling you exactly what went wrong and how it got there. It is printed from the outside in: the first call at the top, the place the error actually happened at the bottom, and the error itself on the very last line.

That ordering is why tracebacks look intimidating and why the reading rule is simple. Read the last line first: it names the exception type and its message. Then scan upwards for the deepest frame in a file you wrote; frames below that usually sit inside a library and are rarely where the fault is.

Each middle entry is a frame: a file, a line number, and the function that was running. Together they are the chain of calls that led to the failure, which is what makes a traceback more useful than a plain error message.

Official documentation: Python docs: traceback — print or retrieve a stack traceback

• A Debugging Playbook That Always Works

You define a function with the def keyword, an optional list of parameters in parentheses, and an indented body. Calling the function runs that body, and a return statement hands a value back to whoever called it. A function with no return hands back None.

Functions let you write a piece of logic once and reuse it with different inputs, which keeps programs short and easier to fix.

Functions organize scripts, remove repetition, and make larger programs easy to read and test one piece at a time.

Patterns you’ll reach for constantly once you write your own:

• def greet(name='friend'), default values make an argument optional
• *args, **kwargs, accept any number of positional/keyword arguments
• def total(x: int) -> int, type hints document inputs and output
• return, hand a value back (no return means None)

Official documentation: Python Tutorial: Defining Functions

• Functions

• Parameter
• Argument
• Return value
• Lambda

Parameters are the names listed in parentheses when you def a function. They act as placeholders: when the function is called, each parameter is filled with the matching argument. A parameter can have a default value, which makes it optional.

Every function you write or call uses parameters, from a script’s settings to a web route’s inputs.

• def f(a, b), positional parameters
• def f(a, b=10), a default value makes it optional
• def f(*args), accept any number of positional values
• def f(**kwargs), accept any number of keyword values
• def f(a: int), type-hint a parameter

Official documentation: Python Glossary: parameter

• Functions

• Argument
• Function
• Return value

An argument is the real value handed to a function at call time, filling one of its parameters. You can pass arguments positionally (by order) or as keyword arguments (by name), which is clearer when there are several.

Arguments feed data into every function call, a filename to open, a URL to fetch, options for a command-line tool.

• f(1, 2), positional arguments, matched by order
• f(name='Sam'), keyword argument, matched by name
• f(*my_list), unpack a list into positional arguments
• f(**my_dict), unpack a dict into keyword arguments

Official documentation: Python Glossary: argument

• Functions

• Parameter
• Function
• Command-line argument

A return statement ends a function and sends a value back to whoever called it, so you can store or use the result. A function with no return hands back None. Returning is different from printing: print() shows text on screen, while return gives a value back to your program.

Return values let functions build on each other, one function’s result becomes another’s input, which is how larger programs are assembled.

• return value, hand one value back
• return a, b, return several values as a tuple
• return, exit early, handing back None
• result = f(), capture what a function returns

Official documentation: Python Language Reference: The return statement

• Functions

• Function
• Parameter
• Argument

A lambda is a tiny function with no name, written inline: lambda x: x * 2. It lists its arguments before the colon and returns the single expression after it, no def or return needed.

Lambdas shine as a quick argument to functions like sorted(), map(), or filter() when a full named function would be overkill. For anything longer, use def.

Lambdas shine as short, throwaway functions passed to other functions. Most often the key= for sorting or finding a max.

• lambda x: x * 2, an inline, unnamed function
• sorted(items, key=lambda r: r['age']), sort by a computed key
• max(items, key=lambda x: len(x)), pick by a computed value

Official documentation: Python Tutorial: Lambda Expressions

• Flexible Functions: args, kwargs, and Lambdas

• Function
• List

A decorator is written as @something on the line above a function definition. It takes the function below it and returns a modified version, a clean way to add behavior without changing the function's own code.

You'll meet decorators most often when using a web framework: Flask's @app.route("/") is a decorator that registers a function as a route.

Decorators add behavior, logging, timing, access checks, web routing, without editing the function they wrap.

• @something, apply a decorator to the function below
• functools.wraps, keep the wrapped function’s name/help
• @property, a built-in decorator for class attributes
• @app.route('/'), Flask routing is a decorator

Official documentation: Python Glossary: decorator

• Decorators: Wrapping Functions Without Rewriting Them

• Function
• Route
• Method

A generator is a function that uses yield instead of return. Each yield hands back one value and pauses the function, keeping its variables; the next request resumes it right where it left off. So a generator produces a sequence one item at a time rather than building the whole thing up front.

That makes generators lazy (nothing runs until you iterate) and great for streaming large files or long sequences with very little memory. They’re also a kind of iterator, and they’re one-shot: once consumed, you make a new one to iterate again.

Generators stream values one at a time, so you can process a huge file or an endless sequence without loading it all into memory.

• yield value, hand back one value and pause
• next(gen), pull the next value
• (x for x in seq), a generator expression
• import itertools, ready-made generator building blocks

Official documentation: Python Tutorial: Generators

• Generators and the yield Keyword

• Iterator
• Loop
• Function

An iterator is anything you can pull values from one at a time with next(), until it runs out. Every for loop uses one under the hood: it calls next() repeatedly and stops when the iterator is exhausted.

You rarely write the iterator protocol by hand, a generator is the easiest way to make one. Lists, strings, and files are iterable: ask them for an iterator with iter() and step through it with next().

Iterators are anything you can loop over: files, ranges, dict views, and your own classes that define how to step through their contents.

• iter(obj), get an iterator from an iterable
• next(it), pull the next value (StopIteration at the end)
• for x in it, the loop that uses them automatically
• import itertools, chain, islice, count, and friends

Official documentation: Python Glossary: Iterator

• How for Loops Really Work: The Iterator Protocol

• Generator
• Loop
• List

A docstring is a string literal placed as the very first statement of a function, class, or module. By convention it uses triple quotes, so it can run to several lines without escaping anything.

The thing that makes it different from a comment is that Python keeps it. A docstring is stored on the object as __doc__, which is how help(), your editor's tooltips, and documentation generators can all show it. A # comment is discarded when the code is compiled and exists only in the source file.

One line is enough for most functions: say what it returns, not how it works. Save the longer form for when the arguments genuinely need explaining.

Official documentation: PEP 257: Docstring Conventions

• Writing Clean Python: Names, Functions, and Docstrings

A class defines a new type. You write it once with the class keyword, then create as many objects from it as you like. The special __init__ method runs automatically when each object is created and sets up its starting attributes via self.

Functions defined inside a class are its methods, behavior that lives with the data. Grouping data and behavior together is the core idea of object-oriented programming.

Classes model real things, a User, an Account, a Report, bundling related data and the behavior that goes with it.

• def __init__(self, ...), set up each new instance
• self, the current instance inside a method
• Account(100), call the class to create an object
• isinstance(obj, Account), check an object’s type

Official documentation: Python Tutorial: Classes

• Classes and Objects Explained Simply

• Object
• Method
• Attribute
• Inheritance

An object (or instance) is created by calling a class like a function: Dog("Rex"). Each object carries its own attributes, so two objects of the same class can hold different values.

In Python everything is an object, numbers, strings, lists, even functions and classes themselves. You work with an object through its attributes and methods, reached with a dot.

Everything in Python is an object, numbers, strings, functions, and every instance of your own classes.

• type(obj), what class made this object
• isinstance(obj, Cls), is it that type (or a subclass)
• dir(obj), list its attributes and methods
• vars(obj), its instance data as a dict

Official documentation: Python Language Reference: Objects, values and types

• Classes and Objects Explained Simply

• Class
• Attribute
• Method

A method is a function defined inside a class. Its first parameter is self, the particular object it was called on, so it can read and change that object's attributes.

You call a method with a dot and parentheses: account.deposit(50). Built-in types have methods too, "hi".upper() and [3, 1, 2].sort() are method calls.

Methods are the behavior attached to objects, text.upper(), items.append(x), and the actions on your own classes.

• obj.method(), call a method with the dot
• self, the instance the method belongs to
• @property, expose a method as if it were an attribute
• @staticmethod / @classmethod, methods not tied to one instance

Official documentation: Python Tutorial: Method Objects

• Attributes, Methods, and Object State

• Function
• Class
• Attribute
• Dunder method

An attribute is a value attached to an object or a class. You usually create per-object attributes in __init__ by assigning to self, then read them with a dot: dog.name. Together, an object's attributes make up its state.

Attributes set on self belong to one object; attributes set in the class body are shared by every object of that class.

Attributes hold an object’s state, a user’s name, an account’s balance, and they can differ from one instance to the next.

• obj.attr, read or set an attribute directly
• getattr(obj, 'x', default), read by name, with a fallback
• setattr(obj, 'x', value), set by name
• hasattr(obj, 'x'), check whether it exists

Official documentation: Python Tutorial: Class and Instance Variables

• Attributes, Methods, and Object State

• Object
• Class
• Method

Inheritance lets a child class reuse the attributes and methods of a parent class: class Dog(Animal):. The child can add new behavior or override a method to replace the parent's version.

Call super() to reuse the parent's version from inside the child. Reach for inheritance only when the child genuinely is a kind of the parent.

Inheritance shares behavior across related classes, the pattern behind framework base classes for forms, models, and views you customize.

• class Car(Vehicle), Car inherits everything from Vehicle
• super().__init__(...), run the parent’s setup too
• def describe(self), override a method to specialize it

Official documentation: Python Tutorial: Inheritance

• Inheritance Without the Headache

• Class
• Method
• Dunder method

A dunder method (“double-underscore”, also called a special or magic method) has a name like __init__, __str__, or __len__. You rarely call them directly; Python calls them for you when you create an object, print it, or use len().

Defining them lets your own objects behave like built-in types, print(obj) uses __str__ and len(obj) uses __len__.

Dunder methods make your objects work with built-in syntax, print(), len(), for, and == all call them behind the scenes.

• __init__, set up a new instance
• __str__ / __repr__, how the object prints
• __len__, make len(obj) work
• __eq__, define what == means
• __iter__ / __next__, make the object loopable

Official documentation: Python Language Reference: Special method names

• Special Methods: Making Objects Feel Pythonic

• Method
• Class
• Iterator

A descriptor is any object defining __get__ or __set__ that is then used as a class attribute. Python routes attribute access through it, so the descriptor decides what reading or assigning that attribute actually does.

You have been using them all along without the name: property, classmethod, staticmethod, and even ordinary methods are descriptors underneath. Writing your own is worth it when the same managed-attribute logic is needed on several attributes, because one descriptor class covers all of them where a property would have to be copied per attribute.

__set_name__ is the piece that makes them practical: Python calls it as the class is created and tells the descriptor which name it was assigned to, so a single class works for name, email, and city alike.

Official documentation: Python HOWTO: descriptors

• Advanced Python: What's Left, and When You'll Need It

Python has always cared what an object can do rather than what it is: if it has a close() method you can close it, whatever its class. That is duck typing, and typing.Protocol is how you describe it to a type checker.

A protocol lists the methods something must have. Any class with those methods satisfies it — no inheritance, no import, no registration. That is the difference from a base class: a protocol describes a shape, and matching is structural rather than declared.

Adding @runtime_checkable lets you use isinstance() against it, with one honest limit: at runtime only the presence of each method is checked, not its signature or return type. The full check belongs to a checker such as mypy, before the program runs.

Official documentation: Python docs: typing.Protocol

• Advanced Python: What's Left, and When You'll Need It

In Python a class is itself an object, so something has to create it. That something is its metaclass, and by default it is type. Writing your own means running code at the moment a class is defined rather than when one is used: validating that subclasses declare a required attribute, say, or recording each subclass in a registry.

They are worth recognizing and almost never worth writing. Nearly every historical use is now better served by __init_subclass__, a normal method on a normal class that Python calls whenever a subclass is defined, or by a class decorator.

The reason to prefer those is not style: code whose behavior was decided during class creation is genuinely hard to debug, and the person doing that debugging is usually you, later.

Official documentation: Python docs: metaclasses

• Advanced Python: What's Left, and When You'll Need It

pathlib represents a filesystem path as a Path object instead of a plain string. You build paths with the / operator (Path("data") / "file.txt") and read their parts with .name, .stem, and .suffix.

Because it behaves the same on Windows, macOS, and Linux, pathlib is the modern, cross-platform way to find, inspect, and rename files.

pathlib is the backbone of file automation: finding, reading, writing, and renaming files without fragile string paths.

The Path object carries useful methods and properties:

• Path('data') / 'in.csv', join paths with /
• .exists(), does it exist
• .glob('*.txt'), find matching files
• .read_text() / .write_text(), read or write a whole file
• .suffix / .name / .parent, extension, filename, folder
• .mkdir(parents=True, exist_ok=True), create folders safely

Official documentation: Python Library Reference: pathlib

• File and Folder Automation with pathlib

• File path
• Module
• CSV

A file path tells the program where a file lives. Paths can be absolute (from the drive root) or relative (from the current folder). Because separators and rules differ across operating systems, the modern approach is pathlib’s Path, which builds and inspects paths safely with the / operator.

File paths appear whenever you read or write files: opening a config, saving a report, or walking a folder of images.

• Path('a') / 'b.txt', join path parts safely
• .name / .suffix / .parent, filename, extension, folder
• .exists(), check if it is there
• .absolute(), get the full path
• Path.home(), Path.cwd(), home and current folders

Official documentation: Python Library Reference: pathlib

• Paths and Folders

• pathlib
• Module
• CSV

A module is simply a .py file whose functions, classes, and variables you can reuse elsewhere with import. Python ships with a large standard library of ready-made modules, for math, dates, random numbers, files, and much more. After importing, reach inside with a dot (math.sqrt) or pull specific names out with from math import sqrt.

Modules let you reuse code across files and tap the standard library, os, json, datetime, and many more.

• import json, bring in a whole module
• from pathlib import Path, import just one name
• import numpy as np, import under a shorter alias
• dir(module), list what a module offers
• help(thing), read its built-in documentation

Official documentation: Python Tutorial: Modules

• Modules and Imports

• Import
• Package
• pip

import brings code from another module into your file. import math loads the whole module (use it as math.sqrt); from math import sqrt pulls one name in directly; import numpy as np gives it a shorter alias. Imports usually go at the top of a file.

Every script beyond a few lines starts with imports, the standard library and the installed packages you build on.

• import module, load a whole module
• from module import name, import one name
• import module as alias, import under a shorter name
• from module import *, import everything (usually avoid)

Official documentation: Python Language Reference: The import system

• Modules and Imports

• Module
• Package
• pip

When you start a program with something like python greet.py Ada, everything after the script name is a command-line argument. Python collects them in sys.argv, a list of strings: sys.argv[0] is the script's own name, and your arguments start at index 1. They let one script work on any file or value instead of a hard-coded one.

Command-line arguments let one script behave differently each run, pass it a filename or an option instead of editing the code.

• import sys, sys.argv holds the raw arguments
• sys.argv[1:], everything after the script name
• argparse, the standard way to define real flags and help

Official documentation: Python Library Reference: sys.argv

• Command-Line Arguments

• argparse
• Module

argparse turns command-line input into usable values. You create an ArgumentParser, declare the arguments you expect with add_argument, and call parse_args() to read them. It handles positional arguments, optional --flags, type conversion, and an automatic -h help screen.

It saves you from hand-parsing sys.argv and gives users clear errors when they get the command-line arguments wrong.

argparse powers real command-line tools: named flags, defaults, types, and an auto-generated --help.

• ArgumentParser(), create the parser
• .add_argument('path'), declare a positional argument
• type=int, default=..., convert and supply a fallback
• action='store_true', an on/off flag
• .parse_args(), read the arguments into an object

Official documentation: Python Library Reference: argparse

• Command-Line Scripts with argparse

• Command-line argument
• Module

JSON (JavaScript Object Notation) is the common language of web APIs and config files, and it looks almost exactly like Python dictionaries and lists. Python’s built-in json module converts between JSON text and Python objects: json.loads reads text into objects, json.dumps writes objects back to text.

JSON is how you read API responses, save structured settings, and move data between programs.

• json.loads(text), parse JSON text into Python
• json.dumps(obj), turn Python into JSON text
• json.load(file), read JSON from a file
• json.dump(obj, file), write JSON to a file
• indent=2, pretty-print with indentation

Official documentation: Python Library Reference: json

• Dictionary
• API
• CSV

CSV (comma-separated values) is the lingua franca of spreadsheets and data exports. Each line is a row; commas separate the columns. Python’s built-in csv module reads and writes it safely, handling quoting and commas inside fields, and csv.DictReader gives each row as a dictionary keyed by column name.

CSV is where data work often starts: exports from spreadsheets, reports, and simple datasets you clean or summarize.

• csv.reader(f), read rows as lists
• csv.DictReader(f), read rows as dicts by header
• csv.writer(f), write rows
• csv.DictWriter(f, fieldnames), write dicts as rows
• newline='', open CSV files with this to avoid blank lines

Official documentation: Python Library Reference: csv

• JSON
• Dictionary
• File path

A context manager guarantees setup and cleanup around a block of code, using the with statement. The classic example is with open(...) as f:, the file is closed automatically when the block ends, even if an error is raised. You can write your own with contextlib.contextmanager or by defining __enter__ and __exit__.

You will use with for files, database connections, locks, and temporary changes that must be undone afterwards.

• with open(path) as f, auto-close a file
• with a, b:, manage several resources at once
• contextlib.contextmanager, write one from a generator
• __enter__ / __exit__, the methods that define one

Official documentation: Python Language Reference: Context managers

• Context Managers and the with Statement

• try / except
• Generator
• File path

A virtual environment is a private folder holding its own Python and its own installed packages. Creating one per project keeps each project's dependencies separate, so upgrading a package for one project can't break another.

Create one with python -m venv .venv, then activate it before installing anything with pip. Your shell prompt usually changes to show it's active.

A virtual environment keeps each project’s packages separate, so upgrading one project can’t break another.

• python -m venv .venv, create one in the project folder
• source .venv/bin/activate, activate it (macOS/Linux)
• deactivate, step back out
• which python, confirm which Python is active

Official documentation: Python Library Reference: venv

• Virtual Environments

• pip
• requirements.txt
• Module

pip installs packages that aren't part of the standard library, downloading them from the Python Package Index (PyPI). The basic command is pip install <package>, and you can pin a version with pip install flask==3.0.0.

Always install into an active virtual environment so packages stay project-local, and record them in requirements.txt for reproducibility.

pip adds third-party libraries, requests, flask, pandas, that aren’t in the standard library.

• pip install requests, install a package
• pip install requests==2.31.0, install a specific version
• pip uninstall requests, remove it
• pip list / pip freeze, see what’s installed
• pip install -r requirements.txt, install from a list

Official documentation: Python Documentation: Installing Python Modules

• Installing Packages with pip

• Virtual environment
• requirements.txt
• Module

A package groups related modules under one name so they can be imported together (from urllib import request). In everyday use, “package” also means a third-party library you install from PyPI with pip, requests, flask, pandas, then import like any other module.

Almost every real project pulls in packages, for HTTP, data, or web apps, installed with pip and listed in requirements.txt.

• pip install name, install a package from PyPI
• import name, use an installed package
• from pkg import module, import a package’s module
• pip show name, see a package’s details

Official documentation: Python Tutorial: Packages

• Installing Packages with pip

• Module
• pip
• Import

A dependency is any package your code imports and therefore cannot run without. They are listed in your requirements file or your pyproject.toml, and pip installs them.

The part that catches people is that dependencies have dependencies. Asking for one package regularly installs five or twenty, and every one of those is code you now ship, pin, and inherit the security advisories of. pip show <package> lists the direct ones; the full tree is usually deeper than expected.

Which is why a dependency is a commitment rather than a free feature: it has to keep working when Python releases a new version, someone has to bump it, and a future reader has to learn it. That is not an argument against dependencies (writing your own HTTP client would be far worse), but it is an argument for checking one before adding it.

Official documentation: Python Packaging: managing application dependencies

• Is This Library Worth Installing?

requirements.txt records the packages your project needs, one per line, normally pinned to an exact version like flask==3.0.0. Anyone can recreate your environment with pip install -r requirements.txt and get the same versions you used.

Generate it from your active virtual environment with pip freeze > requirements.txt. Pinning versions is what makes a project reproducible.

requirements.txt lets anyone (including future you) recreate a project’s exact set of packages on a new machine.

• pip freeze > requirements.txt, record current packages
• pip install -r requirements.txt, install them all
• requests==2.31.0, pin a version for reproducibility

Official documentation: pip Documentation: Requirements File Format

• Virtual Environments, requirements.txt, and Reproducibility

• pip
• Virtual environment

Version control tracks the history of your files as a series of commits, saved snapshots you can return to. It lets you experiment safely, see what changed and when, and undo mistakes. Git is by far the most widely used system.

The everyday loop is small and repeatable: stage your changes, commit them with a message, and repeat. Small, frequent commits make the history easy to read and to roll back.

Version control is your safety net: checkpoints before risky edits, a full history to undo mistakes, and a way to collaborate without overwriting work.

• git init, start tracking a folder
• git add / git commit, stage and save a checkpoint
• git status / git log, see changes and history
• git diff, see exactly what changed

Official documentation: Git Documentation

• Git Checkpoints and Testing Before You Trust a Script

• Unit test
• requirements.txt

A unit test runs a small part of your program with known inputs and checks the result. The simplest form is an assert statement: it raises an error if a condition isn't true and stays silent when it is. Testing pure helper functions lets you verify logic without touching real files or servers.

Python ships with the unittest module, and the popular third-party tool pytest lets you write tests as plain functions and runs them for you.

Unit tests prove a function works and catch regressions when you change code later, essential before trusting a script that touches real files.

• assert result == expected, the simplest check
• pytest, find and run test files
• def test_thing():, pytest collects functions named test_*
• pytest.raises(ValueError), assert that an error is raised

Official documentation: Python Library Reference: unittest

• Git Checkpoints and Testing Before You Trust a Script

• Exception
• Version control
• Function

Profiling means running your code under a tool that records how long each function took and how often it was called. The rule it exists to enforce is short: never optimize before measuring, because intuition about which line is slow is wrong often enough to be worthless.

Python ships two tools. cProfile answers “which part of my program is slow?”: run python -m cProfile -s cumtime script.py and read the tottime column, which is time spent in a function excluding what it called. timeit answers the narrower “which of these two lines is faster?” by running a snippet many times and reporting the best result.

Most real slowness, though, is not about how fast each operation is. It is about how many operations you do — and that you can often count without any tool at all.

Official documentation: Python docs: the Python profilers

• Advanced Python: What's Left, and When You'll Need It

pyproject.toml is the single file that turns a folder of Python into something pip can install. It replaces the older setup.py, setup.cfg and MANIFEST.in that you will still meet in existing projects.

It has three jobs. [build-system] names the tool that builds the package. [project] describes it: name, version, description, supported Python versions, and dependencies. [project.scripts] declares the terminal commands it installs.

It is worth being clear about how this differs from requirements.txt, because the two are constantly confused. requirements.txt reproduces an environment for someone developing the project. pyproject.toml ships an artifact for someone who just wants to use it.

Official documentation: Python Packaging User Guide: writing your pyproject.toml

• Packaging: Turn Your Script Into an Installable Tool

An entry point is what turns a script into a tool. Writing tidyup = "tidyup.cli:main" under [project.scripts] says: create a command called tidyup that imports the module tidyup.cli and calls the function main inside it. The colon separates the module from the function.

On install, pip writes a small launcher into the environment's bin/ directory. That directory is already on your PATH, which is why the command then works from any folder — the entire difference between typing python /some/path/tool.py and typing tidyup.

The mechanism is far less magical than it looks. As the example shows, resolving module:function is just an import followed by getattr.

Official documentation: Python Packaging User Guide: entry points specification

• Packaging: Turn Your Script Into an Installable Tool

Continuous integration means a server checks out your project on a fresh machine and runs your checks, on every push, without being asked. On GitHub this is GitHub Actions, configured by a YAML file in .github/workflows/.

The value is in the word clean. That machine has none of your locally installed packages, none of your uncommitted files, and no residue from an earlier test, so it catches a category of bug that is invisible on your own computer by definition. A dependency you installed months ago and forgot to declare will fail there and nowhere else.

A workflow contains jobs, and each job is a list of steps run in order. Any step that exits non-zero fails the job and stops the rest, which is why the whole thing needs no wiring beyond listing the commands.

Official documentation: GitHub Actions docs: building and testing Python

• Continuous Integration with GitHub Actions

A container is a running instance of an image: a built, unchanging bundle containing a stripped-down operating system, a Python installation, your dependencies, and your code. Docker is the usual tool for building and running them. The image is to a container what a class is to an object: one definition, many instances.

The point is what it captures that smaller tools do not. A virtual environment pins your Python packages and nothing else; a container pins the Python version, the operating system, and the system libraries underneath as well.

Two things surprise everyone once. A container cannot see your files unless you deliberately mount a folder into it, and anything it writes outside such a folder disappears when it stops. Both are the isolation working as intended.

Official documentation: Docker docs: Dockerfile reference

• Containers in Plain English (and a First Dockerfile)

YAML is a configuration format designed to be read and edited by people. Structure comes from indentation rather than brackets or braces, which makes it look a lot like Python and reads far more comfortably than JSON for anything hand-written.

You will meet it as soon as you touch tooling: GitHub Actions workflows, Docker Compose files, Kubernetes manifests, and countless application config files are all YAML. In Python it is read with yaml.safe_load() from the third-party PyYAML package (pip install pyyaml), which turns a document into ordinary dictionaries and lists.

Always use safe_load rather than load. Plain load can construct arbitrary Python objects from a document, so a hostile file could run code.

Official documentation: PyYAML documentation

• Continuous Integration with GitHub Actions

A web framework takes care of the repetitive parts of serving a website, listening for HTTP requests, matching URLs to code, and building responses, so you write only the parts unique to your app. You map a URL to a function, and the framework runs it when a request arrives.

Flask is a small, beginner-friendly Python framework; Django is a larger, batteries-included one. Both let your Python code answer requests with web pages.

Web frameworks (Flask, Django) handle the repetitive parts of serving a site, routing, templates, requests, so you write the interesting bits.

• @app.route('/'), map a URL to a function
• render_template('page.html'), fill an HTML template
• request, read the incoming request
• return, the response sent back to the browser

Official documentation: Flask Documentation

• How Websites Use Python

• Route
• HTTP
• Template

HTTP (HyperText Transfer Protocol) is the language of the web. A browser sends an HTTP request for a URL, and a server sends back an HTTP response, usually an HTML page, along with a status code like 200 (OK) or 404 (Not Found).

Requests use methods: GET fetches a page, while POST sends data to change something (like submitting a form). Your Python code runs on the server and produces the response.

HTTP is the language of every web request: browsers, APIs, and your own requests.get() calls all speak it.

• GET / POST, fetch data / send data
• 200, 404, 500, OK, not found, server error
• headers, extra info like content type
• requests.get(url), make an HTTP request from Python

Official documentation: MDN Web Docs: HTTP

• How Websites Use Python

• Web framework
• Route
• HTML form

An API (application programming interface) is a contract that lets one program request data or actions from another. On the web, you call an API by sending an HTTP request to a URL and usually get JSON back. In Python the requests library is the usual tool, and a status_code tells you whether it worked.

APIs power live data in your scripts: weather, prices, maps, payments, and your own web services.

• requests.get(url), fetch data from an API
• requests.post(url, json=...), send data
• .status_code, 200 OK, 404 not found, and so on
• .json(), parse the JSON response
• params={…}, headers={…}, query parameters and headers

Official documentation: requests: HTTP for Humans

• HTTP
• JSON
• Web framework

In a web framework, a route connects a URL path like /about to a function (a view function) that builds the response. In Flask you create one with the @app.route("/path") decorator placed above the function.

When a request arrives, the framework reads the path, finds the matching route, runs its function, and sends back whatever it returns.

Routes connect URLs to view functions, the map that decides which code runs for /, /about, or /users/42.

• @app.route('/path'), bind a URL to a function
• methods=['GET', 'POST'], accept form submissions too
• /user/<id>, capture part of the URL as a value

Official documentation: Flask Documentation: Routing

• Your First Flask App

• Web framework
• HTTP
• Decorator
• Template

A template keeps your HTML in its own file with placeholders for the changing parts, so markup stays separate from Python logic. Flask uses the Jinja template engine: {{ name }} drops in a value and {% for item in items %} repeats a block.

render_template("index.html", name="Ada") loads the file from the templates/ folder and fills in the values you pass. Jinja auto-escapes them, so user text can't inject HTML.

Templates generate HTML pages with data filled in, the list of notes, the logged-in user’s name, without pasting HTML into your Python.

• {{ value }}, drop a value into the page
• {% for x in items %}, repeat markup for each item
• {% if user %}, show markup conditionally
• url_for('static', filename=...), build links safely

Official documentation: Flask Documentation: Rendering Templates

• Flask Templates and HTML Pages

• Web framework
• Route
• Static file
• HTML form

An HTML <form> gathers user input, text boxes, checkboxes, buttons, and sends it to a server when submitted. Each field has a name, which becomes the key your server code reads. A form that changes data uses method="post".

In Flask, submitted values arrive in request.form, which works like a dictionary keyed by each field's name. Always validate that input before trusting it.

Forms collect user input on the web, logins, search boxes, comment fields, and send it to a route that validates and stores it.

• method='post', send data in the request body, not the URL
• name='email', the key your server reads the value by
• request.form['email'], read a submitted value in Flask
• .strip() and validate, never trust input as-is

Official documentation: MDN Web Docs: Web Forms

• Handling Forms in Flask

• HTTP
• Route
• Template

Static files don't change per visitor, so the server sends them exactly as they are, no code runs to build them. In Flask they live in a static/ folder, separate from the templates that Python fills in.

Link to them with url_for("static", filename="style.css") rather than hardcoding the path, so the URL stays correct even if the app moves.

Static files are the CSS, JavaScript, and images a site serves unchanged, the parts that make pages look and behave the way they do.

• static/ folder, where CSS, JS, and images live
• url_for('static', filename='main.css'), build a static URL
• link / script / img, the tags that load them

Official documentation: Flask Documentation: Static Files

• Static Files, Styling, and Simple Layout

• Template
• Web framework
• Route

Concurrency means a program makes progress on several tasks during the same stretch of time instead of finishing each one before starting the next. It is what turns ten network requests that take two seconds in a row into ten requests that take a fifth of a second together.

The crucial limit is that it only reclaims waiting. If your program is genuinely busy calculating, there is no idle time to fill and concurrency buys you nothing. That case needs separate processes and more CPU cores. Ask which one you have before choosing a tool: is the program working, or is it waiting?

Python offers two everyday routes. A thread pool hands the jobs to a small team of workers, and is usually the simplest change to make. async/await keeps one worker that switches tasks whenever it would otherwise sit idle.

Official documentation: Python docs: concurrent.futures

• Waiting vs Working: Why Programs Are Slow

A coroutine is a function that can pause partway through and be resumed. You write one with async def, and mark its pause points with await.

The part that catches everyone out: calling a coroutine function does not run it. You get a coroutine object back, the work packaged up and ready, waiting for something to drive it. That something is normally an event loop, started by asyncio.run(). Inside async code, await both drives a coroutine and hands you its result.

The point of pausing is that while one coroutine waits at an await, the loop runs another. One worker, never idle — which is how a single thread can keep thousands of connections busy.

Official documentation: Python docs: Coroutines and Tasks

• async and await Explained Simply

A dataclass is a normal class with the boilerplate written for you. Decorate it with @dataclass, list the fields with type hints, and Python generates the constructor, a readable __repr__, and field-by-field equality.

It sits between a dictionary and a hand-written class. A dict is flexible but a mistyped key is a silent bug; a hand-written class means writing the methods yourself. A dataclass gives you named fields, a useful printout, and a real type a checker understands, for about three lines.

Official documentation: Python docs: dataclasses

A DataFrame is the pandas object holding a whole table, a spreadsheet Python can ask questions about. Columns have names, rows have index labels, and unlike a NumPy array each column can hold a different type, so names, dates and numbers live together comfortably.

Two operations do most of the work. Selecting picks columns: single brackets for one (giving a Series), double brackets for several. Filtering picks rows by writing a condition, which produces True/False per row and keeps the True ones.

The habit worth building is to look before calculating: df.head() to see it, df.shape to size it, df.isna().sum() to count what is missing.

Official documentation: pandas docs: 10 minutes to pandas

• Pandas DataFrames: Tables in Python

An event loop is what makes a program interactive rather than something that runs once and stops. It repeats forever: check whether anything happened, decide what it means, update the state, and display the result.

Games write the loop by hand: a while loop calling pygame.event.get(). GUI toolkits run it for you and call the functions you attached to each widget, which is what root.mainloop() does in Tkinter. Web frameworks and asyncio are the same idea again.

The important contrast is with input(), which blocks: the program stops dead until someone presses Enter. A game loop never blocks — it keeps turning whether or not you touch anything, which is why animation continues while you sit still.

Official documentation: Python docs: tkinter — Python interface to Tcl/Tk

• How Interactive Programs Think

A feature is an input. In a table of houses, size and bedrooms are features; the price you want to predict is the label (or target). Every row pairs its features with its answer.

By convention the features live in a two-dimensional array called X (capital, because it is a table) with one row per example and one column per feature. The labels live in a single column called y. Every Python machine-learning example you read will use those two names.

Deciding which columns are features and which is the label is the first step of any project, and choosing good features usually matters more than choosing a clever algorithm.

Official documentation: scikit-learn docs: preprocessing data

• What Machine Learning Really Means

The Global Interpreter Lock is a lock inside CPython (the standard Python) that allows only one thread to run Python code at any single instant. Threads take turns holding it, swapping many times a second.

For waiting this costs nothing: a thread hands the GIL back the moment it blocks on the network or the disk, so other threads run during that gap. This is exactly why thread pools make network code dramatically faster.

For calculation it is decisive. Four threads crunching numbers take turns on one lock and finish in roughly the time one thread would, plus the cost of swapping. The answer there is ProcessPoolExecutor: separate processes each get their own interpreter, their own GIL, and their own CPU core.

Official documentation: Python docs: Global interpreter lock

• The GIL, Processes, and Shared State

Logging is the grown-up replacement for scattered print() calls. Python's built-in logging module records messages with a level saying how much each one matters: DEBUG, INFO, WARNING, ERROR, and CRITICAL.

The point is that you choose a threshold when the program runs, not when you write it. Set it to INFO and the DEBUG messages disappear; set it to DEBUG when something is wrong and they all come back, without editing a single line. Logs can also carry timestamps and be written to a file, which is what lets you work out what a script did while nobody was watching.

Official documentation: Python docs: Logging HOWTO

Machine learning is what you do when the rule is not knowable in advance. Rather than writing the logic yourself, you supply examples and let a program work out the pattern that connects them.

In supervised learning (nearly all of it in practice) each example arrives with the right answer attached. Predicting a number is regression; predicting a category is classification. In unsupervised learning there are no answers, and the job is to find structure in the data itself.

Two things are worth holding onto. A model always produces an answer, however nonsensical the input, so a prediction without an evaluation is worthless. And a model reproduces whatever its training data contained, including biases nobody intended.

Official documentation: scikit-learn docs: an introduction to machine learning

• What Machine Learning Really Means

Matplotlib turns a table into a picture. It is imported as import matplotlib.pyplot as plt by near-universal convention, and you build a chart by calling functions in order: create a figure, draw something, label it, show it.

Choosing the chart type is the real skill, because each answers a different question. plt.bar() compares separate categories, plt.plot() shows change over a continuous run such as time, plt.scatter() shows how two numbers relate, and plt.hist() shows how one set of numbers is distributed — the one that reveals whether an average is hiding two different groups.

Always add a title and both axis labels. An unlabeled chart shows a shape without saying what it measures, which makes it decoration rather than evidence.