Standard Library

Write (?P<name>...) to name a group. The match object then exposes it as m.group('name'), and m.groupdict() returns a dict mapping every named group to the text it captured; unnamed numbered groups are not included.

A backslash means something to both the string-literal parser and the regex engine. A raw literal stops Python consuming it first, so the engine sees what you typed. Otherwise you must double every backslash.

re.match only tries the pattern at the start of the string, re.search scans forward and returns the first match anywhere, and re.fullmatch requires the pattern to consume the whole string. All three return a Match object or None.

.* is greedy: it grabs as much text as it can, then gives characters back only when the rest of the pattern fails. .*? is lazy: it starts empty and grows one character at a time, only when forced.

The inner a+ and the outer + can carve the run of as up in about 2^n ways. The trailing ! makes $ fail, so the backtracking engine must try every one of those splits before reporting no match.

'w' truncates the file to zero bytes, creating it if absent. 'a' leaves the contents alone and writes at the end. 'x' refuses to touch an existing file and raises FileExistsError.

pathlib.Path overloads the division operator, so Path("exports") / "schedule.json" builds a new path object with the right separator. On that result .name is "schedule.json", .stem is "schedule", .suffix is ".json" and .parent is Path("exports").

tempfile.TemporaryDirectory gives a whole scratch directory removed when its with-block ends. tempfile.NamedTemporaryFile gives one auto-deleted open file. tempfile.mkstemp gives a raw file descriptor plus a path you must close and unlink yourself.

The new contents go into a temporary file in the target's own directory; os.replace(tmp, target) then swaps the directory entry in one step, so a reader sees either the whole old file or the whole new one.

On Python 3.14 a text-mode open() with no encoding= uses the machine's locale encoding, not UTF-8. The same script can read a file on one machine and raise UnicodeDecodeError on another, so pass encoding= explicitly.

A comma inside a quoted field is data, not a separator, so str.split(',') tears such a row apart. csv.reader runs the quoting state machine over the file object and yields each record as a list of strings.

The trailing s means string. json.loads parses JSON text already in memory and json.load reads it from an open file object; json.dumps returns a JSON string, while json.dump writes that text straight into a file object.

A pickle stream is a small program for a stack machine, not a data document. Its opcodes can import any importable name and call it, so pickle.loads on attacker-controlled bytes runs the attacker's code before you inspect any value.

tomllib.load reads bytes and decodes them as UTF-8 itself, because a TOML document is UTF-8 by definition. A file opened in text mode has already been decoded with the platform encoding, so load raises TypeError; open the path with 'rb'.

Element.find returns the first match or None, findall returns a list of every match at that path, and iter walks the whole subtree recursively, including the element itself, yielding each element with the given tag.

time.monotonic() only ever moves forward, so the difference between two readings is a true duration. time.time() names a wall-clock instant, and NTP or an operator can step it forwards or backwards, corrupting any elapsed-time calculation.

A datetime is aware when it carries a tzinfo whose utcoffset() returns a real offset; otherwise it is naive. datetime.datetime(2026, 9, 5, 12, 0) is naive, and passing tzinfo=datetime.timezone.utc makes the same reading aware.

ZoneInfo('Europe/Berlin') carries that region's full IANA rule history, so the offset it reports depends on the moment in question. A datetime.timezone built from a timedelta is one frozen number and is wrong for part of every year.

fold is a 0-or-1 flag that says which pass through a repeated local wall time you mean: 0 the first occurrence, 1 the second. It defaults to 0 and only changes anything across an offset change.

A naive datetime states no offset, so there is no shared instant to order against an aware one, and Python refuses to guess. Ordering and subtraction raise TypeError; equality does not raise — it quietly returns False.

The leading dashes decide. add_argument("dataset") defines a positional argument: required, matched by its place on the command line. add_argument("--dataset") defines an optional argument: matched by name, and when absent it takes its default. Both land on the Namespace.

Subscripting os.environ raises KeyError when the variable is unset; os.getenv returns None, or the default you pass. Subscript settings the program cannot run without, so it fails loudly at startup, and use os.getenv only where a default is genuinely correct.

subprocess.run() blocks until the child exits and returns a CompletedProcess carrying args, returncode, stdout and stderr. Pass capture_output=True and text=True to get output as str, and check=True to raise CalledProcessError when the exit code is not zero.

Exit 0 for success and a small non-zero code for failure via sys.exit, which raises SystemExit. Send results a caller might pipe to sys.stdout, and diagnostics, warnings and errors to sys.stderr so they survive redirection.

With the default shell=False, args is a sequence and each element becomes exactly one argv entry, executed directly with no shell parsing. With shell=True on POSIX, args should be a single string handed to /bin/sh -c, so the shell re-parses it and metacharacters inside interpolated values take effect.

Every logging call carries a severity level, a logger name and a timestamp, and where it goes is decided once at startup rather than at the call site. print() writes an unconditional bare line to stdout with none of that.

Both write to one file and roll it aside, but RotatingFileHandler rolls over when the file would exceed maxBytes, while TimedRotatingFileHandler rolls over on a clock boundary chosen by when and interval. Each keeps backupCount old files.

logging.getLogger(name) returns a logger named after the module's import path, so every record says where it came from and configuration can be aimed at one package. Calling logging.info goes through the root logger, which loses that origin.

Levels filter twice. The logger's own effective level decides whether a record is created at all, and then every handler applies its own level before emitting. A handler left at WARNING silences DEBUG no matter what the logger says.

Each key in the extra mapping becomes an attribute on the LogRecord itself, so a formatter can emit it as a field. Logger.makeRecord raises KeyError if a key collides with an existing record attribute or with message or asctime.

base64.b64encode is a bytes-to-bytes function: it needs a bytes-like object and returns bytes. Encode text first with str.encode('utf-8'), then call .decode('ascii') on the result to get a str for JSON.

struct.pack takes a format string plus values and returns a bytes object laid out exactly as that format describes. struct.unpack reverses it and always returns a tuple, even when the format has a single field.

uuid.uuid4 fills 122 bits from the operating system's random source. uuid.uuid1 encodes a timestamp plus the host's 48-bit node address. uuid.uuid5 hashes a namespace UUID together with a name, so the same name always produces the same UUID.

zlib.compress takes one bytes object and returns another, so both the whole input and the whole output sit in memory at once. Stream instead: zlib.compressobj(), feed it chunks with compress(), and finish with flush().

The '@' prefix means native byte order with native alignment, so struct inserts pad bytes before the int — typically eight bytes in total. The '<' prefix selects little-endian standard sizes with no alignment padding, giving exactly five.

The server creates a socket, binds it to a local address, calls listen, then blocks in accept, which returns a new socket for one client; only that socket carries data. The client creates its own socket and calls connect.

A socket is writable whenever its kernel send buffer has room, which is almost always. Register selectors.EVENT_WRITE only while unsent bytes are actually queued for that socket; otherwise select() returns instantly every pass and the loop spins at full CPU.

TCP is a byte stream with no message boundaries, so recv returns whatever has arrived, up to the size you asked for. Frame messages yourself with a length prefix or a delimiter, and loop until one message is complete.

HTTPError means the server answered with a status urllib treats as an error; URLError means no HTTP answer arrived at all, such as a name-resolution or connection failure. HTTPError is a subclass of URLError, so catch it first.

It asks the kernel which of many registered sockets are ready right now, so one thread can serve thousands of connections. A blocking socket.recv() parks that thread on one connection until that single connection has data.

All three read from one cursor's open result set and advance the same position. fetchone() returns the next row or None when exhausted, fetchmany(n) returns up to n rows in a list, and fetchall() returns every remaining row.

sqlite3 compiles the statement once and binds each Python value as a typed parameter, so no quoting or escaping ever happens. An f-string splices the value into the statement text, where it can change what the SQL means.

PEP 249 connections are transactional by default and open a transaction implicitly, with no BEGIN call in the API. Only commit() makes the work durable; close() without it performs an implicit rollback, so the writes are discarded.

By default sqlite3 opens a transaction implicitly before an INSERT, UPDATE, DELETE or REPLACE and leaves it open until you call Connection.commit; nothing else commits for you. Setting Connection.autocommit to True or False replaces that legacy behaviour with explicit modes.

PEP 249 makes every driver module expose a paramstyle string naming the placeholder syntax it accepts: qmark, numeric, named, format or pyformat. Because the driver fixes the style, statements written for one driver do not run on another.

Decimal(0.1) converts the float exactly, so it stores 0.1000000000000000055511151231257827..., the binary approximation the float already was. Decimal("0.1") parses the decimal digits you actually wrote and stores exactly one tenth.

It resets the internal state of the one Mersenne Twister generator that backs the random module's functions. Any run that seeds with the same value then replays the identical sequence of numbers in the same order.

quantize takes a pattern Decimal such as Decimal("0.01") and returns a value with that same exponent, rounding the extra digits away. The rounding rule comes from the current decimal context, whose default is ROUND_HALF_EVEN.

statistics.mean averages every value, so one outlier drags it; statistics.median returns the middle value and ignores how extreme the tail is. statistics.stdev divides by n-1 for a sample, statistics.pstdev by n for a whole population.

math.fsum tracks exact partial sums and rounds once at the end, so its total is always correctly rounded. The built-in sum() has compensated since Python 3.12, but its single correction term can still drift across widely separated magnitudes.