Python Cheat Sheet: Syntax, Data Types and File Handling

A compact Python 3.14 reference covering syntax, data types, files, errors and log parsing, with every example run on Python 3.14.8.

Published 9 Oct 2026 8 min read By srvScripts

Short answer: Python 3 code is built from a few core pieces: f-strings for formatting, lists, dicts and sets for data, for loops and match for control flow, def and class for structure, pathlib and with open() for files, and try/except for errors. The current stable release is Python 3.14. The tables below show the syntax you will use most, and every example was run on Python 3.14.8.

The examples in this Python cheat sheet were run with Python 3.14.8 on 9 October 2026. Features marked 3.12+ or 3.14 need at least that version; check yours with python3 --version.

Variables, numbers and f-strings

Syntax	What it does	Result
`port = 443`	Assign. No type declaration; the value carries the type	`int`
`x, y = y, x`	Swap two variables in one line
`7 / 2` · `7 // 2` · `7 % 2`	True division, floor division, remainder	`3.5` · `3` · `1`
`2 ** 10`	Power	`1024`
`int("42")` · `float("3.5")` · `str(10)`	Convert between types	`42` · `3.5` · `'10'`
`bool("")` · `bool("0")`	Empty values are falsy; any non-empty string is truthy	`False` · `True`
`f"{name}:{port}"`	f-string: insert values	`web01:443`
`f"{0.75:.1%}"`	Format as a percentage	`75.0%`
`f"{1234567:,}"`	Thousands separator	`1,234,567`
`f"{port:>6}"`	Right-align in 6 characters	`' 443'`
`f"{name=}"`	Debug form: prints the expression and its value	`name='web01'`
`isinstance(x, float)`	Type check (preferred over `type(x) == float`)	`True`/`False`

Floats are binary, so round(2.675, 2) gives 2.67, not 2.68. Use the decimal module for money or exact decimal maths.

Strings

Syntax	What it does
`s.strip()` · `s.lstrip()` · `s.rstrip()`	Remove surrounding whitespace (or the characters you pass)
`s.lower()` · `s.upper()`	Change case
`s.split(",")` · `s.split("=", 1)`	Split into a list; the second form splits only once
`s.split()`	Split on any run of whitespace, ignoring leading and trailing spaces
`"-".join(parts)`	Join a list of strings with a separator
`s.replace("old", "new")`	Replace every occurrence
`s.startswith("web")` · `s.endswith(".log")`	Prefix and suffix tests (accept a tuple of options)
`"error" in s`	Substring test
`s.removesuffix(".txt")`	Drop a suffix only if present (3.9+)
`s[0:4]` · `s[-4:]` · `s[::-1]`	Slice: first four, last four, reversed
`len(s)`	Length in characters
`"""..."""`	Triple quotes for text that spans several lines
`r"C:\temp\new"`	Raw string: backslashes are not escapes (use for regex)
`t"Hello {user}"`	Template string (3.14): a `Template` object, not a `str`, so a library can escape the values before use

Lists, tuples, dicts and sets

Syntax	What it does
`hosts = ["web01", "db01"]`	List: ordered, changeable
`hosts.append(x)` · `hosts.insert(0, x)`	Add at the end · at a position
`hosts.remove(x)` · `hosts.pop()`	Remove by value · remove and return the last item
`sorted(hosts, key=len, reverse=True)`	New sorted list; `hosts.sort()` sorts in place
`[h.upper() for h in hosts if h.startswith("web")]`	List comprehension with a filter
`point = (10, 20)` · `a, b = point`	Tuple (fixed) and unpacking
`first, *rest = [1, 2, 3, 4]`	Star unpacking: `rest` is `[2, 3, 4]`
`cfg = {"host": "db01", "port": 3306}`	Dict: key-value pairs, insertion order kept
`cfg.get("password", "unset")`	Read with a default instead of raising `KeyError`
`for k, v in cfg.items():`	Loop over keys and values
`cfg \| {"port": 3307}`	Merge into a new dict; right side wins (3.9+)
`{n: n**2 for n in range(4)}`	Dict comprehension
`{1, 2, 3} & {2, 3, 4}` · `a \| b` · `a - b`	Set intersection, union, difference
`Counter(items).most_common(10)`	Count occurrences (`from collections import Counter`)
`defaultdict(list)`	Dict that creates missing keys automatically
`enumerate(items, start=1)` · `zip(a, b)`	Index with value · pair two sequences

Control flow and match

if code < 300:
    print("ok")
elif code < 500:
    print("client error")
else:
    print("server error")

status = "up" if code < 500 else "down"   # conditional expression

for i in range(0, 10, 3):                  # 0 3 6 9
    print(i)

while retries < 3:
    retries += 1

if (m := re.search(r"\d+", "port 8080")):  # walrus: assign inside a test
    print(m.group())                        # 8080

break leaves a loop, continue skips to the next pass, and a for ... else block runs only when the loop ended without break. Structural pattern matching (3.10+) matches on shape, not just value:

match cmd.split():
    case ["restart", service]:
        return f"restarting {service}"
    case ["status" | "check", *services]:
        return f"checking {services}"
    case []:
        return "empty"
    case _:
        return "unknown"

Functions, lambdas and type hints

Syntax	What it does
`def connect(host: str, port: int = 22) -> str:`	Function with type hints and a default value
`def f(args, *kwargs):`	Accept any extra positional and keyword arguments
`def f(host, *, timeout=5.0):`	Arguments after `*` must be passed by name
`lambda n: n * n`	Anonymous one-expression function
`sorted(hosts, key=len)`	Pass a function as an argument
`yield value`	Makes the function a generator that produces values lazily
`sum(x for x in range(5))`	Generator expression, no intermediate list
`any(seq)` · `all(seq)` · `max(seq)` · `min(seq)`	Common built-ins on iterables
`int \| None`	Union type hint (3.10+); replaces `Optional[int]`
`type Port = int`	Type alias statement (3.12+)
`def first[T](items: list[T]) -> T:`	Generic function syntax (3.12+)

Type hints are not enforced at run time. Use a checker such as mypy or pyright to catch mistakes. Since 3.14, annotations are evaluated lazily, so a class can refer to itself in hints without quotes.

Classes and dataclasses

class Server:
    count = 0                                   # class attribute

    def __init__(self, name: str, ip: str):
        self.name = name                        # instance attributes
        self.ip = ip
        Server.count += 1

    def __repr__(self):
        return f"Server({self.name!r}, {self.ip!r})"

    @property
    def fqdn(self):
        return f"{self.name}.example.com"

    @classmethod
    def from_line(cls, line):                   # alternative constructor
        return cls(*line.split())

class WebServer(Server):                        # inheritance
    def __init__(self, name, ip, vhosts=0):
        super().__init__(name, ip)
        self.vhosts = vhosts

For classes that mostly hold data, a dataclass writes __init__, __repr__ and __eq__ for you:

from dataclasses import dataclass, field

@dataclass
class Disk:
    mount: str
    size_gb: int
    used_gb: int = 0
    tags: list[str] = field(default_factory=list)   # never use a bare [] default

d = Disk("/", 80, 13)
print(d)        # Disk(mount='/', size_gb=80, used_gb=13, tags=[])

Add @dataclass(frozen=True, slots=True) for an immutable, memory-lean record. Use enum.Enum for a fixed set of named values.

Files, paths and JSON

Syntax	What it does
`from pathlib import Path`	Object-oriented paths; prefer over `os.path`
`p = Path("/var/log") / "app.log"`	Join paths with `/`
`p.read_text(encoding="utf-8")`	Whole file as a string
`p.write_text(data, encoding="utf-8")`	Write (overwrites)
`p.exists()` · `p.stat().st_size`	Exists? · Size in bytes
`p.name` · `p.stem` · `p.suffix` · `p.parent`	`app.log` · `app` · `.log` · `/var/log`
`Path("conf").mkdir(parents=True, exist_ok=True)`	Create a directory tree
`p.glob(".conf")` · `p.rglob(".log")`	Match in one directory · recursively
`p.unlink(missing_ok=True)`	Delete a file without error if it is gone
`json.loads(text)` · `json.dumps(obj, indent=2)`	Parse JSON · write JSON
`csv.DictReader(f)`	Read CSV rows as dicts keyed by the header
`os.environ.get("HOME")`	Environment variable, or `None`

with open("/var/log/app.log", encoding="utf-8") as f:   # file closes automatically
    for line in f:                                     # reads line by line
        if "ERROR" in line:
            print(line.rstrip())

with open("out.txt", "a", encoding="utf-8") as f:       # "w" overwrite, "a" append
    f.write("appended\n")

Errors, exceptions and context managers

try:
    port = int(value)
except ValueError as e:
    print("bad port:", e)
except (KeyError, IndexError):
    pass
else:
    print("no error")          # runs only if nothing was raised
finally:
    print("cleanup")           # always runs

class ConfigError(Exception):
    pass

raise ConfigError("missing port")
raise RuntimeError("calc failed") from e   # keep the original cause

Python 3.14 allows except KeyError, IndexError: without brackets, but only when there is no as clause. Keep the brackets if your code must also run on older versions. To ignore one specific error, use with contextlib.suppress(FileNotFoundError): instead of a bare except:, which also swallows Ctrl+C.

For server admins: commands and log parsing

Syntax	What it does
`subprocess.run(["df", "-h", "/"], capture_output=True, text=True, check=True)`	Run a command without a shell; raises `CalledProcessError` on a non-zero exit
`r.returncode` · `r.stdout` · `r.stderr`	Exit code and captured output
`shutil.disk_usage("/").free`	Free bytes on a filesystem
`shutil.which("mysql")`	Full path to a command, or `None`
`datetime.strptime(s, "%d/%b/%Y:%H:%M:%S %z")`	Parse an Apache or Nginx log timestamp
`argparse.ArgumentParser()`	Command-line options and `--help` for your script

Count requests per IP and per status code in a combined-format access log:

import re
from collections import Counter

pat = re.compile(r'^(\S+) \S+ \S+ \[[^\]]+\] "(\S+) (\S+) [^"]*" (\d{3}) (\d+|-)')
ips, codes = Counter(), Counter()

with open("access.log", encoding="utf-8", errors="replace") as f:
    for line in f:
        if m := pat.match(line):
            ip, method, path, status, size = m.groups()
            ips[ip] += 1
            codes[status] += 1

print(ips.most_common(10))
print(codes)

Pass commands to subprocess.run as a list. Avoid shell=True with any value that comes from a user, a file or a log line: it allows shell injection. errors="replace" stops one bad byte in a log from crashing the whole script.

Create an isolated environment for each project instead of installing packages system-wide: python3 -m venv .venv, then source .venv/bin/activate and python -m pip install requests. On Debian 12 and later, pip refuses to install into the system Python (PEP 668), and on AlmaLinux, dnf itself runs on the system Python, so leave it alone.

Official documentation (checked 9 October 2026): The Python Tutorial · Built-in Types · What’s new in Python 3.14 · pathlib · re: regular expressions · subprocess