Python

Indentation as structure, dynamic typing and naming - Python's readability is a feature you maintain.

Arithmetic, string methods, slicing and formatting - the everyday data you'll manipulate most.

if/elif, for/while, range and match - plus comprehensions as the idiomatic loop replacement.

Default args, *args/**kwargs, return values and docstrings - functions that do one thing, named well.

Mutability, slicing, sorting with keys - and when an immutable tuple communicates intent.

Key-value workhorse: get/setdefault, iteration, dict comprehensions and counting patterns.

Membership at O(1), dedupe in one line, and set algebra for comparisons.

List/dict/set comprehensions and generator expressions - transformation as expression, not ceremony.

__init__, methods, class vs instance attributes - objects as data with behaviour attached.

__repr__, __eq__ and @dataclass - Pythonic objects without boilerplate.

try/except/else/finally, raising your own, and exception chaining - loud, useful failure.

The iteration protocol and yield - lazily processing data too big for memory.

Packages, __main__ and project layout - code you can import, test and reuse.

venv + requirements - reproducible projects from day one, no global-site chaos.

with-open patterns, csv and json modules - the daily bread of automation and data work.

Paths, dates, collections, itertools - the batteries that make Python feel effortless.

requests: status codes, params, JSON and pagination - pulling data from the web reliably.

argparse, environment variables and scheduling - replace one manual chore this week.

Test functions, fixtures and parametrize - tests as executable documentation.

pandas in ten minutes and a first notebook - the doorway to analysis and ML paths.

Functions wrapping functions - logging, caching (functools.lru_cache) and auth checks without repetition.

with-blocks and writing your own via contextlib - guaranteed cleanup for files, locks and connections.

The re module: matching, groups and substitution - surgical text processing when string methods run out.

Annotations, Optional/Union, and mypy/pyright - the typed Python professional codebases now expect.

threading vs multiprocessing vs asyncio - what the GIL actually limits and choosing the right model per workload.

uv/poetry for environments, ruff for lint+format - the 2020s toolchain that replaced a decade of ad-hoc setups.

Typed, async-first APIs with automatic docs - the modern default for Python services.

Micro vs batteries-included - the long-standing frameworks you'll meet in existing codebases.

Data analysis, ML and automation paths - Python as the junction language of modern careers.

Take the OneRoadmap Python certification - verified proof in under 15 minutes.