Python in depth: the rest of the language

Functions in depth 5 topics

• Entry check: are you ready for the depth?
  A forty-minute check of the skills this course builds on, with a pointer to the Python from zero topic to revisit for each one.
• Names and scope
  Where names live (LEGB), reading and changing globals, hiding built-ins by accident, keywords and pass.
• Flexible functions: *args and **kwargs
  Positional and named arguments, defaults, collecting with args and kwargs, unpacking in a call, keyword-only parameters and the mutable-default trap.
• Functions as values: closures, lambda, map, filter, reduce
  Functions stored, passed and returned; closures and nonlocal; lambda; map, filter and reduce; functools.partial.
• Recursion
  Functions that call themselves: base case and smaller case, the call stack, recursion on lists and on nested data, and when a loop is better.

Data in depth 4 topics

• Text and regular expressions
  Tidying text, formatting numbers with format specs, and finding and changing patterns with regular expressions and groups.
• The right container: defaultdict, deque, heapq, namedtuple, array
  Choosing the right container: defaultdict for grouping, Counter for ranking, deque for queues and windows, heapq for the smallest or largest, namedtuple for records and…
• Iterators and generators
  How for loops work (iter and next), generators with yield, laziness and memory, generator expressions, one-use iterators and the itertools tools islice, chain and count.
• Speed and choice: complexity, bisect, caching
  How the work grows with the data (constant, linear, quadratic), why sets and dictionaries are fast, binary search and bisect, and caching with lrucache.

Objects in depth 4 topics

• Classes properly: class methods, properties, encapsulation
  Class and instance attributes, class and static methods, properties with validation, the underscore conventions and repr.
• Inheritance and polymorphism
  Child classes, super(), overriding, polymorphism, duck typing, isinstance, and when to inherit.
• Contracts and special methods: abstraction, dunder methods, dataclasses
  Special methods that make objects work with Python's operators and built-ins, abstract base classes as contracts, and dataclasses for record-like classes.
• Decorators and context managers
  Decorators that wrap functions, functools.wraps, decorators with settings, context managers with with, enter and exit, and contextlib.contextmanager.

Robust programs 4 topics

• Exceptions in depth
  try, except, else and finally; the exception family tree; raising your own exceptions; chaining with raise from; EAFP; and keeping a loop running after one bad item.
• Type hints and clear contracts
  Type hints for parameters, results, collections and optional values; static checkers; docstrings as written contracts; and reading hints at run time.
• Doing many things at once: threads, processes, asyncio
  I/O-bound and CPU-bound work, threads, processes and asyncio, the GIL, race conditions, locks and deadlocks, and reasoning about workers with numbers.
• Projects studio: four mini-projects
  Four small projects built from testable rules: rock-paper-scissors, number guessing, tic-tac-toe and a bank account, with a method for planning, testing and reviewing.

Infrastructure behind your Python 4 topics

• The infrastructure map: what runs your Python
  The parts that run your Python: file, interpreter and bytecode, the call stack, memory manager, standard library, process and cores, with a card for each and the path of…
• Memory, speed and the call stack
  Estimating memory, finding the bottleneck with a profiler, caches that must be bounded, recursion depth as arithmetic, and failure drills.
• Concurrency: resources and failure
  Workers, queues, locks and the scheduler as resources; sizing workers with arithmetic, the queue as an early warning, failure drills, and security and data handling.
• Running and watching Python programs
  Logging with levels, exit codes, configuration and secrets, versions and dependencies, monitoring and alerts, a one-page runbook and a handover note.

Interview ready 3 topics

• Interview ready: functions, data and speed
  The questions people really ask about functions, data structures and speed, with model answers, timed problems and a mock round.
• Interview ready: objects and robust code
  The questions people really ask about classes, inheritance, decorators, context managers, exceptions and type hints, with model answers, design problems and a mock round.
• Interview ready: performance, concurrency and design
  The questions people really ask about speed, concurrency and running programs, with model answers, design problems with numbers, and a mock estimation round.

The ordering core

A tested Python package for Chai Corner's ordering backend: classes, a discount contract, a cache, JSON in and out, custom exceptions and logging.

Infrastructure and interview sheet

Seven component cards for your own program, a worker sizing for a stated load, one failure drill, and a recorded self-review of one interview answer.

Why take this course

• Learn the parts of Python that real programs rely on
• Write code on every page, with hints and checks
• Prepare for interviews as part of the course

You will build

• A tested ordering core with a discount contract and a cache
• Decorators and context managers
• A worker sizing and a runbook for your own program

What you can do afterwards

• Design classes, functions and data flows that stay clear as programs grow
• Explain what runs your Python and how to size and watch it
• Answer common interview questions and solve timed problems aloud