Python essentials
Core Python 3.14 syntax and standard-library patterns for everyday lookup, from bindings and ABCs to asyncio, typing, and tooling.
Python 3.14 1 page when printed
Bindings and branches
name = value bind or rebind a name without copying the object first, *middle, last = values unpack the middle items into a new list result = value if condition else fallback evaluate and return only the selected branch if (match := pattern.search(text)): evaluate once, then retain the match object match command: evaluate one subject against cases from top to bottom case {'action': action, **rest}: capture one mapping value and the unmatched keys Collections
items[start:stop:step] select a sequence slice without changing the source [project(item) for item in items if keep(item)] filter and transform into a new list {key(item): value(item) for item in items} build a dictionary from generated key-value pairs unique = set(items) deduplicate hashable values without preserving input order mapping.get(key, fallback) return the fallback only when the key is absent sorted(items, key=key_fn, reverse=True) return a new list ordered by a derived key Functions and scope
def fetch(url, /, timeout=5, *, retries=2): make url positional-only and retries keyword-only def collect(*items, **options): collect extra positional and keyword arguments result = function(*args, **kwargs) unpack an iterable and mapping into a call nonlocal count rebind the nearest enclosing function binding @functools.wraps(function) copy wrapper metadata and expose the wrapped function @functools.cache memoize calls with an unbounded cache of hashable arguments Objects and ABCs
from abc import ABC, abstractmethod import the helpers for abstract base classes class Service(ABC): declare a class governed by ABCMeta @abstractmethod require concrete subclasses to override the marked method super().__init__() call the next initializer in the method resolution order @dataclass(slots=True, frozen=True) generate a slotted data class that blocks field assignment items: list[str] = field(default_factory=list) create a fresh list for each data-class instance Iteration and lazy pipelines
enumerate(items, start=1) pair each item with a one-based counter zip(left, right, strict=True) raise ValueError when iterable lengths differ (project(item) for item in items) create a lazy generator expression yield from source delegate iteration and generator protocol operations itertools.islice(source, start, stop) take a lazy slice from an iterator itertools.chain.from_iterable(groups) flatten one iterable level lazily Errors and cleanup
raise ValueError(message) reject an invalid value explicitly raise DomainError(message) from error preserve the original failure as the direct cause except (ValueError, TypeError) as error: catch only the listed exception types with open(path, encoding='utf-8') as stream: close the text stream when the block exits with contextlib.suppress(FileNotFoundError): ignore only the named exception from the block with contextlib.ExitStack() as stack: release a dynamic set of resources in reverse order Async and concurrency
asyncio.run(main()) run one top-level coroutine and close its event loop result = await coroutine() suspend the current task until the awaitable completes async with asyncio.TaskGroup() as group: wait for all child tasks before leaving the scope task = group.create_task(work()) start a coroutine owned by the task group async with asyncio.timeout(5): limit the awaits inside the block to five seconds result = await asyncio.to_thread(blocking_call) move blocking I/O off the event-loop thread Paths and processes
path = Path('data/config.toml') construct a path without accessing the filesystem text = path.read_text(encoding='utf-8') read, decode, and close a text file path.write_text(text, encoding='utf-8') overwrite, encode, and close a text file path.mkdir(parents=True, exist_ok=True) create missing parent directories idempotently result = subprocess.run(args, check=True, text=True, capture_output=True) capture text output and raise on a nonzero exit status with tempfile.TemporaryDirectory() as directory: remove the temporary directory when the block exits Data boundaries
data = json.loads(text) parse JSON text into Python values text = json.dumps(data, ensure_ascii=False) serialize JSON without escaping non-ASCII characters with path.open(newline='', encoding='utf-8') as stream: let the CSV module handle embedded newlines correctly rows = csv.DictReader(stream) read each CSV record as a header-keyed mapping digest = hashlib.sha256(payload).hexdigest() hash bytes and return the digest as hexadecimal text token = secrets.token_urlsafe(32) generate a URL-safe token from 32 random bytes Text and time
clean = ' '.join(text.split()) trim and collapse runs of whitespace match = re.fullmatch(r'[A-Z]{2}\d{4}', text) require the regular expression to match the whole string block = textwrap.dedent(block) remove indentation shared by nonblank lines now = datetime.now(timezone.utc) create an aware current UTC datetime stamp = datetime.fromisoformat(text) parse a supported ISO 8601 date-time string local = now.astimezone(ZoneInfo('Europe/Paris')) convert the same instant to an IANA time zone Type hints
name: str = value annotate a binding for static tools without runtime enforcement def parse(text: str) -> int: annotate parameter and return types type Result[T] = T | Exception declare a generic type alias def first[T](items: Sequence[T]) -> T: declare a generic function with one type parameter class Reader(Protocol): describe a structural interface for static checking class Config(TypedDict): describe the expected keys and values of a dictionary Testing and local tools
python -m venv .venv create an isolated virtual environment python -m unittest -v discover and run standard-library tests verbosely python -m pdb script.py start the script under the Python debugger breakpoint() pause at the configured debugger hook python -m compileall src precompile source files to bytecode python -m timeit 'sum(range(1000))' benchmark a small statement repeatedly Say it precisely to your AI
rules pack · Python
Python rules for your coding agent
Download the track's pitfalls and review checks in the format your coding agent reads.