Python

Trace Python from its early design through Python 2, Python 3, open-source governance, and today’s ecosystem. Connect ideas such as readability, backward compatibility, and PEPs to the way modern Python is written.

Work with numbers, booleans, variables, expressions, operators, identity, equality, and the value `None`. Practice predicting and checking how Python evaluates expressions and converts between types.

Create, combine, slice, search, and format strings using Unicode-aware operations and f-strings. Handle bytes, encodings, and common text problems without corrupting data.

Store and transform data with lists, tuples, dictionaries, and sets. Choose a collection based on ordering, uniqueness, lookup cost, mutability, and the shape of the problem.

Control program behavior with conditions, loops, `break`, `continue`, assignment expressions, and structural pattern matching. Turn everyday rules into clear branching and repetition.

Define functions with parameters, return values, default arguments, keyword arguments, and variable-length argument lists. Break a larger problem into small functions with clear responsibilities.

Recognize syntax errors, runtime failures, and incorrect results, then isolate their causes with tracebacks, assertions, and debugger tools. Raise and handle exceptions without hiding important failures.

Build collections with list, dictionary, and set comprehensions while keeping expressions readable. Use `map`, `filter`, sorting keys, and small lambda functions where they improve clarity.

Split programs into reusable modules and packages, control imports, and work with namespaces. Structure a multi-file application without circular imports or accidental execution.

Read and write text, binary files, CSV, and JSON using safe path operations. Handle directories, temporary files, streams, and serialization boundaries responsibly.

Use standard-library facilities for dates, decimal arithmetic, random values, collections, statistics, configuration, command execution, and operating-system tasks. Practice finding reliable functionality before adding a third-party dependency.

Search, validate, extract, and replace structured text with regular expressions. Build maintainable patterns and recognize when a parser is safer than a complex expression.

Model data and behavior with classes, instances, methods, properties, class methods, and data classes. Favor composition where it keeps relationships simpler than inheritance.

Work with special methods that control representation, comparison, arithmetic, containment, iteration, and call behavior. Design objects that cooperate naturally with Python’s built-in syntax and protocols.

Use iterable and iterator protocols, write generator functions, and build lazy processing pipelines. Evaluate when laziness saves memory and when eager evaluation is clearer.

Treat functions as values, create closures, and use decorators to add reusable behavior. Preserve metadata and avoid wrappers that make execution difficult to follow.

Manage files, locks, database connections, and other resources with `with` statements. Create class-based and generator-based context managers that clean up reliably after success or failure.

Annotate functions, collections, unions, callables, generics, and protocols with modern type hints. Use a static type checker to catch interface mistakes while preserving Python’s runtime flexibility.

Create isolated environments and manage direct, development, and transitive dependencies. Use lock files and reproducible installation practices to prevent “works on my machine” failures.

Track changes with Git, organize commits, work with branches, and resolve common merge conflicts in Python projects. Configure ignore rules so environments, secrets, caches, and generated files stay out of the repository.

Format, lint, document, and review Python code with a consistent project configuration. Apply PEP 8, meaningful naming, docstrings, and automated checks without treating style rules as substitutes for judgment.

Write unit, integration, parameterized, and property-based tests with fixtures and test doubles. Measure useful coverage and test observable behavior rather than private implementation details.

Add structured logging, useful diagnostics, metrics, and error context to applications. Investigate failures locally and in production without exposing secrets or overwhelming operators with noise.

Define build metadata with `pyproject.toml`, choose a source layout, build wheels and source distributions, and publish packages safely. Apply versioning, dependency constraints, and release practices that downstream users can trust.

Implement stacks, queues, linked structures, trees, heaps, graphs, searching, and sorting in Python. Analyze time and space costs, then compare hand-built structures with optimized built-ins.

Build command-line programs with arguments, options, configuration, exit codes, and helpful error messages. Automate file organization, reporting, and scheduled system tasks without writing fragile shell glue.

Use SQL to create tables, query data, join records, enforce constraints, and manage transactions. Connect through Python’s database interfaces and build a small persistent application with SQLite.

Map Python objects to relational tables, model relationships, and manage schema changes with migrations. Recognize query inefficiencies, transaction boundaries, and cases where direct SQL is the better tool.

Send HTTP requests, work with URLs and headers, encode parameters, handle authentication, and parse JSON responses. Build a resilient API client with timeouts, retries, pagination, and rate-limit handling.

Collect permitted public data from web pages by parsing HTML and following links carefully. Respect terms, robots directives, rate limits, privacy, and the difference between browser automation and direct HTTP access.

Build server-rendered applications using the WSGI model and frameworks such as Flask or Django. Handle routing, templates, forms, sessions, authentication, database access, and common web security controls.

Create typed JSON services using ASGI frameworks such as FastAPI and Starlette. Define request schemas, validation, dependency injection, authentication, background work, and automatically generated API documentation.

Create event-driven desktop interfaces with windows, controls, layouts, and background tasks. Package a small graphical application while keeping interface code separate from business logic.

Use Jupyter notebooks for experiments, explanations, and reproducible analysis. Control hidden state, separate reusable code from presentation, and convert exploratory work into tested modules.

Represent numerical data with multidimensional arrays and apply vectorized indexing, broadcasting, aggregation, and linear algebra. Replace slow Python loops with clear array operations while controlling shapes and data types.

Load, clean, reshape, join, aggregate, and export tabular data with pandas. Handle missing values, dates, categorical data, and performance problems in a repeatable analysis pipeline.

Communicate patterns and uncertainty with appropriate charts, labels, scales, and visual encodings. Produce reusable visualizations with Matplotlib and higher-level statistical plotting tools.

Apply numerical integration, optimization, interpolation, signal processing, and scientific statistics with SciPy. Validate numerical results by checking assumptions, units, stability, and error tolerance.

Build Python data pipelines that ingest, validate, transform, and publish datasets. Use columnar formats, workflow orchestration, partitioning, and data-quality checks to make repeated processing reliable.

Prepare features, train classical models, evaluate them correctly, and assemble reusable pipelines with scikit-learn. Guard against leakage, overfitting, misleading metrics, and unreproducible experiments.

Build and train neural networks with tensor libraries such as PyTorch. Work with automatic differentiation, GPUs, data loaders, checkpoints, and experiment tracking while diagnosing unstable training.

Call language models from Python, validate structured outputs, manage prompts, and connect models to tools and application data. Evaluate quality, cost, latency, privacy, prompt injection risk, and failure-handling strategies.

Use threads for overlapping I/O and processes for CPU-bound work while accounting for the global interpreter lock. Coordinate workers with executors, queues, locks, cancellation, and clean shutdown procedures.

Write asynchronous programs with coroutines, tasks, event loops, and async context managers. Build concurrent network workflows with timeouts, cancellation, backpressure, and limits on shared resources.

Measure execution time, memory use, and hot paths before changing code. Apply profiling, caching, vectorization, algorithmic improvements, and implementation-level optimization without sacrificing correctness.

Examine names, objects, references, mutability, bytecode, stack frames, garbage collection, and interpreter behavior. Use this model to explain subtle bugs and memory retention without relying on implementation myths.

Create descriptors, dynamic attributes, class decorators, and metaclasses when ordinary functions and composition are insufficient. Build plugin systems and runtime extension points while keeping hidden behavior controlled.

Protect Python applications against injection, unsafe deserialization, path traversal, dependency attacks, weak secret handling, and authorization mistakes. Add dependency scanning, safe defaults, and threat-focused tests to a project.

Call native libraries through foreign-function interfaces and build compiled extensions with C, Cython, or Rust-based tooling. Manage memory ownership, binary compatibility, error boundaries, and performance tradeoffs.

Run Python on constrained devices with MicroPython or CircuitPython. Read sensors, control hardware, manage limited memory, and design programs that remain reliable outside a desktop operating system.

Automate formatting, type checks, tests, builds, and releases whenever code changes. Design CI/CD pipelines with caching, test matrices, protected secrets, and controlled deployment approvals.

Containerize Python applications with small, reproducible images and production-safe runtime settings. Configure processes, health checks, environment values, persistence, and deployment to managed cloud or container platforms.

Adapt Python handlers to event-driven and serverless platforms. Manage cold starts, stateless execution, time limits, retries, idempotency, observability, and connections to managed services.

Use coding assistants to draft, explain, refactor, and test Python while retaining responsibility for the result. Verify generated code for correctness, licensing, security, dependency choices, and fabricated APIs.

Take a Python service from a written requirement through design, implementation, database changes, tests, review, packaging, deployment, monitoring, and maintenance. Produce a repository whose decisions, setup, verification, and operating procedures another developer can follow.

Map Python skills to backend, data, automation, scientific, machine-learning, testing, security, and platform roles. Build proof-of-skill projects, assess optional certifications, contribute to open source, and stay current through release notes, PEPs, documentation, and community channels.