Advanced Python

Overview

This course dives into the deeper layers of Python, covering internals, advanced OOP, concurrency, and static analysis. Learners will explore how Python executes code, manage memory efficiently, and build scalable systems using async and parallel constructs. The curriculum emphasizes practical application through real-world examples and capstone projects that integrate multiple advanced topics.

Objectives

• Understand Python's internal mechanisms including memory management, bytecode execution, and object lifecycle.
• Master advanced object-oriented programming techniques such as descriptors, metaclasses, and multiple inheritance.
• Develop proficiency in asynchronous and concurrent programming using threading, multiprocessing, and asyncio.
• Apply static analysis tools like mypy and Pyright to improve code quality and maintainability.

Key topics

• Python Internals & Memory Model
• Advanced OOP & Metaclasses
• Concurrency — Threading & Multiprocessing
• Async Programming (asyncio)
• Type Hints & Static Analysis
• Design Patterns in Python

Expected outcomes

• Build high-performance applications using async and concurrent paradigms.
• Implement robust software design patterns tailored to Python’s strengths.
• Analyze and optimize code performance with profiling and benchmarking tools.
• Package, deploy, and manage Python projects using modern tooling like Poetry and uv.

How the AI Tutor can help

How the Skillama AI Tutor helps with the listed lectures: explanations, follow-up questions, and running or debugging practice code.

Who this is for

This course is for developers who want to deepen their Python expertise through hands-on exploration of advanced concepts.

Curriculum

1. 1. Python Internals & Memory Model

   • Python execution model & bytecode
   • CPython vs PyPy vs Jython
   • Memory management: heap, stack, reference counting
   • Garbage collection (cyclic GC)
   • Object identity vs equality
   • Interning & memory optimization
   • __slots__ for memory efficiency
   • Inspect bytecode with dis module
   • Profile memory with tracemalloc
   • Benchmark __slots__ vs dict-based classes
   • Visualize object lifecycle

2. 2. Advanced OOP & Metaclasses

   • MRO & cooperative multiple inheritance (super())
   • Descriptors (__get__, __set__, __delete__)
   • Metaclasses: __new__, __init_subclass__
   • Abstract Base Classes (ABC)
   • Class decorators
   • Data classes & __post_init__
   • Build a custom ORM-style descriptor
   • Create a metaclass for auto-registering plugins
   • Implement a validated dataclass
   • Explore MRO with complex hierarchies

3. 3. Decorators & Context Managers

   • First-class functions & closures
   • Functional decorators (with/without arguments)
   • Class-based decorators
   • Stacked decorators & decorator order
   • contextlib utilities
   • __enter__ / __exit__ protocol
   • Async context managers
   • Build retry decorator with exponential backoff
   • Create a timing/logging decorator
   • Write a transaction context manager
   • Implement @singledispatch

4. 4. Iterators, Generators & Functional Tools

   • Iterator protocol (__iter__, __next__)
   • Generator functions & yield
   • yield from & generator delegation
   • Generator expressions vs list comprehensions
   • itertools deep-dive
   • functools: reduce, partial, lru_cache, cached_property
   • Lazy evaluation patterns
   • Build infinite sequence generators
   • Implement a data pipeline with generators
   • Replace nested loops with itertools
   • Memoize expensive functions with lru_cache

5. 5. Concurrency — Threading & Multiprocessing

   • GIL: what it is and isn't
   • Threading module: Thread, Lock, RLock, Event, Semaphore
   • Thread pools (ThreadPoolExecutor)
   • Multiprocessing: Process, Queue, Pipe, shared memory
   • Process pools (ProcessPoolExecutor)
   • Deadlocks, race conditions & thread-safe patterns
   • concurrent.futures unified interface
   • Benchmark GIL impact on CPU-bound tasks
   • Build a concurrent file downloader
   • Parallelize image processing with multiprocessing
   • Detect & fix a deadlock scenario

6. 6. Async Programming (asyncio)

   • Event loop internals
   • async / await syntax
   • Coroutines, Tasks & Futures
   • asyncio.gather, wait, as_completed
   • Async generators & comprehensions
   • Aiohttp for async HTTP calls
   • Async context managers & iterators
   • Mixing sync and async code
   • Build an async web scraper
   • Create a real-time chat server with asyncio
   • Fetch 100 APIs concurrently
   • Migrate a sync script to async

7. 7. Type Hints & Static Analysis

   • Type annotation syntax (PEP 484, 526, 604)
   • Generic types: List, Dict, Optional, Union, Literal
   • TypeVar, Generic classes, Protocol
   • Runtime type checking with beartype / pydantic
   • mypy configuration & error resolution
   • Pyright & Pytype overview
   • Typed dicts & dataclasses
   • Annotate a full module and run mypy
   • Build a typed REST client with Pydantic
   • Define a Protocol-based interface
   • Refactor legacy code with type hints

8. 8. Testing & Quality Engineering

   • pytest: fixtures, parametrize, markers
   • patch & MagicMock (unittest.mock)
   • Property-based testing with Hypothesis
   • Test coverage with pytest-cov
   • Mutation testing (mutmut)
   • Performance testing with pytest-benchmark
   • TDD workflow
   • Write parametrized tests for a data parser
   • Mock external API calls
   • Generate 1000 edge cases with Hypothesis
   • Achieve 90%+ coverage on a module

9. 9. Performance & Profiling

   • Profiling tools: cProfile, line_profiler, py-spy
   • Memory profiling: memory_profiler
   • Benchmarking with timeit
   • Numpy & vectorization for numerical work
   • Cython basics for C-speed extensions
   • Numba JIT compilation
   • Algorithmic complexity & big-O review
   • Profile a slow script and optimize by 10×
   • Replace pure Python loop with numpy
   • Compile a hot function with Cython
   • JIT-accelerate a simulation with Numba

10. 10. Packaging, Dependency & Project Management

    • pyproject.toml (PEP 517/518)
    • setuptools vs Poetry vs Hatch
    • Semantic versioning & changelogs
    • Virtual environments: venv, virtualenv, conda
    • uv — fast dependency resolver
    • Publishing to PyPI
    • Private package registries
    • Package a library with Poetry
    • Publish a test package to TestPyPI
    • Create a reproducible environment with uv
    • Write a GitHub Actions release workflow

11. 11. Design Patterns in Python

    • Creational: Singleton, Factory, Builder
    • Structural: Adapter, Decorator, Proxy, Facade
    • Behavioral: Observer, Strategy, Command, Chain of Responsibility
    • Pythonic alternatives to GoF patterns
    • Dependency Injection
    • Event-driven architecture
    • Implement Observer for a stock ticker
    • Build a plugin system with Factory
    • Refactor spaghetti code using Strategy
    • Design a DI container

12. 12. Capstone Project

    • Track A — High-Performance Data Pipeline (async + multiprocessing)
    • Track B — CLI Tool with Rich UI (typer + rich)
    • Track C — REST API (FastAPI + Pydantic + async)
    • Track D — Extensible Plugin Framework (metaclasses + DI)
    • Code review & optimization
    • Documentation & packaging
    • Build the chosen project end-to-end
    • Profile & optimize critical paths
    • Write unit + integration tests (≥80% coverage)
    • Package and publish to TestPyPI
    • Peer code review session
    • Present architecture decisions

13. 13. Mini project

    • Web Scraping & Price Tracker
    • Website Data Extraction
    • Product Data Processing
    • Price Comparison
    • Price History Storage
    • Price Change Detection
    • Report Generation