Versión imprimible multipagina. Haga click aquí para imprimir.

Volver a la vista normal de esta página.

Python

    1. Introduction
      1. History of Python
        1. Origins and development by Guido van Rossum (1989–1991)
        2. Evolution from Python 1.x → 2.x → 3.x
        3. Design philosophy (PEP 20 — The Zen of Python)
        4. Open source governance and the Python Software Foundation (PSF)
        5. Python Enhancement Proposals (PEPs) and community process
        6. Major milestones (Unicode, async, typing, pattern matching)
      2. Python Versions and Compatibility
        1. Python 2 vs Python 3 differences and migration
        2. Maintenance and end-of-life policies
        3. Long-term support (LTS) versions
        4. Semantic versioning and release cadence
        5. Version detection (sys.version, platform.python_version())
        6. Backward and forward compatibility (PEP 563, PEP 585)
      3. Installing Python
        1. Official installers (python.org, Microsoft Store, Homebrew, apt, dnf)
        2. Platform-specific installation (Windows, macOS, Linux)
        3. Source builds and configuration options
        4. Multiple Python versions and environment isolation
        5. Verifying installation and PATH configuration
        6. Package managers (apt, brew, choco, scoop)
        7. Alternative distributions (Anaconda, Miniconda, ActivePython)
      4. Running Python Scripts and REPL
        1. REPL basics (python, python -i, exit())
        2. Script execution (python script.py, python -m module)
        3. Interactive debugging and inspection (help(), dir())
        4. Command-line flags and options (-O, -B, -m, -X)
        5. Shell integration (ipython, bpython, ptpython)
        6. Jupyter notebooks and interactive kernels
        7. Input/output redirection and pipes
      5. IDEs and Code Editors
        1. Full IDEs (PyCharm, VS Code, Spyder, Thonny)
        2. Lightweight editors (Sublime Text, Atom, Vim, Emacs)
        3. REPL integration and interactive terminals
        4. Code completion and IntelliSense
        5. Linters and formatters integration
        6. Debugging tools and breakpoints
        7. Notebooks and mixed-language environments (Jupyter, Colab)
      6. Virtual Environments
        1. Environment creation (venv, virtualenv)
        2. Activation and deactivation
        3. Project isolation and dependency management
        4. Environment configuration files (pyvenv.cfg)
        5. Integration with editors and build tools
        6. Cross-platform management (conda, tox, nox)
        7. Reproducibility and sharing (requirements.txt, lock files)
      7. Package Management (pip)
        1. Installing, upgrading, uninstalling packages (pip install)
        2. Requirements files (requirements.txt, constraints)
        3. Package discovery and search (pip search, pip index)
        4. Local and editable installs (pip install -e)
        5. Dependency resolution (pip check, pipdeptree)
        6. Source distributions vs wheels
        7. Virtual environment integration
        8. Caching and offline installs (pip download, pip cache)
        9. Custom indexes and mirrors (--index-url, --extra-index-url)
        10. Package auditing and signing (pip-audit, hash-checking-mode)
    2. Fundamentals
      1. Basic Data Types
        1. Variables and assignments
          1. Declaration and initialization
          2. Dynamic typing and rebinding
          3. Variable lifetime and scope
        2. Booleans (bool, logical evaluation rules)
        3. Numeric types
          1. int (arbitrary precision, base conversions)
          2. float, decimal, fractions
          3. complex (real/imaginary parts, polar form)
        4. Strings, multiline strings, raw strings
          1. String creation and immutability
          2. Indexing, slicing, concatenation, repetition
          3. f-strings, interpolation, and formatting
          4. Unicode handling and encoding basics
        5. Objects and mutability
          1. Identity vs equality (is vs ==)
          2. Mutable vs immutable built-ins
          3. Copy semantics (copy, deepcopy)
        6. None and sentinel values
          1. Null semantics and truthiness
          2. Sentinel patterns for optional behavior
        7. Hashables and immutability
          1. Requirements for dict/set keys
          2. Custom hash implementation (__hash__, __eq__)
        8. Type conversion and coercion
          1. Implicit vs explicit casting
          2. Numeric promotions
          3. Common built-ins (int(), float(), str(), etc.)
      2. Operators
        1. Arithmetic (+, -, *, /, //, %, ``)
        2. Comparison (==, !=, <, >, <=, >=)
        3. Logical (and, or, not)
        4. Bitwise (&, |, ^, ~, <<, >>)
        5. Identity (is, is not)
        6. Membership (in, not in)
        7. Assignment and augmented assignment (+=, -=, etc.)
        8. Walrus operator (:=, PEP 572)
        9. operator module (functional forms of ops)
        10. del statement (object deletion and reference removal)
        11. Operator precedence and associativity
        12. Short-circuit evaluation behavior
      3. Control Flow
        1. Conditionals (if, elif, else)
        2. Loops (for, while, for-else, while-else)
        3. Control statements (pass, continue, break)
        4. match / structural pattern matching (PEP 634–636)
          1. Literal, sequence, mapping, and class patterns
          2. OR-patterns and guards (if clauses)
        5. Loop control flags and sentinel conditions
      4. Functions
        1. Namespaces and variable lookup rules
        2. Scopes: local, global, nonlocal
        3. Function definition and return semantics
        4. Default argument values and evaluation timing
        5. Keyword and positional arguments
        6. Special parameters (*args, kwargs, /, *)
        7. Argument unpacking (iterables and mappings)
        8. Lambda and anonymous functions
        9. Function attributes (__name__, __doc__, __defaults__, __annotations__)
        10. Closures and free variables
        11. Higher-order functions and decorators (intro)
        12. Callable objects and partial application
      5. Exceptions
        1. try, except, else, finally blocks
        2. raise and re-raising
        3. Custom exceptions (inheritance from Exception)
        4. Exception chaining (raise … from …)
        5. Exception groups (PEP 654)
        6. Exception notes (add_note)
        7. Context and traceback objects (sys.exc_info, traceback)
        8. Common built-in exceptions (ValueError, TypeError, etc.)
        9. Suppressing exceptions (contextlib.suppress)
      6. Builtins
        1. Keywords (keyword module)
        2. Built-in functions (len, range, map, filter, etc.)
        3. Constants
          1. True, False, None
          2. NotImplemented
          3. Ellipsis (...)
          4. __debug__
        4. Built-in types (int, float, str, list, dict, etc.)
        5. Built-in exceptions (hierarchy and usage)
        6. Standard type hierarchy and object model
      7. Modules
        1. Import system (absolute, relative, from, *, aliasing)
        2. Search paths and environment (sys.path, PYTHONPATH)
        3. Module inspection (dir, help, vars, globals, locals)
        4. Basic standard modules
          1. math, cmath
          2. random
          3. os, pathlib
          4. sys
          5. datetime, time
          6. functools, itertools
          7. json, re, collections
    3. Structures and data manipulation
      1. Data Structures
        1. Lists
          1. Creation and initialization
          2. Indexing and slicing
          3. Mutability and in-place operations
          4. Methods (append, extend, insert, pop, remove, clear)
          5. Sorting (sort, sorted, key functions, stability)
          6. Membership and iteration
          7. Copying and references
        2. Stacks (list, collections.deque)
          1. LIFO principle
          2. Push/pop operations
        3. Queues (queue.Queue, collections.deque)
          1. FIFO principle
          2. Thread-safe queues (queue, multiprocessing.Queue)
        4. Deques (collections.deque)
          1. Bidirectional operations
          2. Rotation and indexing
          3. Thread safety
        5. Tuples
          1. Immutability and performance
          2. Named tuples (collections.namedtuple, typing.NamedTuple)
          3. Tuple packing and unpacking
        6. Sets
          1. Unique element storage
          2. Set operations (union, intersection, difference, symmetric difference)
          3. Frozen sets
          4. Membership and comprehensions
        7. Dicts and mappings
          1. Key-value pairs
          2. Dictionary methods (get, pop, update, items, keys, values)
          3. Dictionary views and iterators
          4. Default dicts (collections.defaultdict)
          5. OrderedDict, ChainMap, Counter
          6. Dictionary comprehensions
        8. Unpacking and extended unpacking
          1. Parallel assignment
          2. * and `` unpacking in function calls and literals
        9. Comparison between data structures
          1. Performance considerations (lookup, insertion, order)
          2. Mutability, hashability, and ordering
        10. Copying and views
        11. Shallow vs deep copy
        12. copy module
        13. Views (dict.items(), set views)
      2. Iterators and Generators
        1. Sequences and iteration protocol
        2. Iterator vs iterable
        3. Built-in functions: iter, next, len, reversed
        4. Custom iterators (__iter__, __next__)
        5. Generators and yield, yield from
        6. Generator expressions and lazy sequences
        7. Infinite iterators (itertools.count, cycle, repeat)
        8. Slices (slice, itertools.islice)
        9. Lazy evaluation and memory efficiency
        10. Generator cleanup and StopIteration
      3. Comprehensions
        1. List comprehensions
        2. Set comprehensions
        3. Dict comprehensions
        4. Nested comprehensions
        5. Conditional comprehensions (if and if-else)
        6. Generator expressions vs comprehensions
        7. Performance and readability trade-offs
      4. String Manipulation
        1. String operations
          1. Concatenation (+)
          2. Multiplication (*)
          3. Membership (in, not in)
          4. Slicing and indexing
        2. Formatting and interpolation
          1. f-strings
          2. .format()
          3. Old-style % formatting
          4. string.Template
        3. String methods (split, join, replace, strip, startswith, endswith)
        4. Bytes and bytearrays (bytes, bytearray, encoding/decoding)
        5. Format specification mini-language
        6. Utilities (textwrap, string, re, difflib)
        7. Unicode and encodings
          1. unicodedata, normalization (NFC, NFD, NFKC, NFKD)
          2. UTF-8, UTF-16, Latin-1, etc.
        8. uuid module
        9. Advanced operations (str.translate, maketrans, case folding)
      5. Regular Expressions
        1. re syntax (groups, lookahead, lookbehind, backreferences)
        2. Flags (IGNORECASE, MULTILINE, DOTALL, VERBOSE)
        3. re module methods (search, match, findall, split, sub, compile)
        4. Regex objects and performance
        5. Third-party regex module (Unicode categories, recursion, timeouts)
        6. Comparison with parsing libraries
          1. fnmatch and glob
          2. parse
          3. shlex and tokenize
          4. string methods vs regex trade-offs
      6. Files
        1. File system access
          1. pathlib (modern path interface)
          2. os and os.path
          3. File existence, metadata, and permissions (stat)
        2. File I/O operations
          1. open, close, read, write, append, seek
          2. Context managers (with)
          3. Binary vs text modes
        3. Basic file formats
          1. .ini / config (configparser)
          2. .env (dotenv libraries)
          3. .toml (tomllib, tomli, tomlkit)
          4. .csv (csv, pandas)
          5. .json (json, orjson, ujson)
          6. .sqlite3 (SQL databases)
        4. Serialization
          1. struct (binary data)
          2. codecs
          3. pickle, dill, cloudpickle
          4. marshal
          5. base64, binascii
        5. Temporary files (tempfile)
        6. Compression and archiving
          1. zip/deflate (zipfile)
          2. gzip
          3. bzip2
          4. lzma/lzma2
          5. lz4
          6. xz
          7. zstd
          8. tar (tarfile)
        7. File permissions and metadata (os.stat, chmod, access)
        8. Binary file handling (struct, memoryview, array)
      7. Specific Files
        1. Markup
          1. HTML (html, html.parser, BeautifulSoup)
          2. XML (xml.etree.ElementTree, lxml)
        2. Document and ebook
          1. PDF (PyPDF2, fitz)
          2. DOCX (python-docx)
          3. EPUB (ebooklib)
        3. Calendar and scheduling
          1. ICS (ics, icalendar)
          2. CSV-based planners
        4. Mailing and messaging
          1. email, smtplib, imaplib
          2. eml, msg parsing
        5. Image processing
          1. PIL/Pillow
          2. OpenCV
          3. imageio, matplotlib for I/O
        6. Audio processing
          1. wave, aifc, sunau
          2. pydub, audioread, soundfile
        7. Video handling
          1. cv2
          2. moviepy
          3. ffmpeg-python
        8. Security and cryptography
          1. ssl, hashlib, secrets, hmac
          2. Certificate and key handling
        9. Geographic and spatial data
          1. GeoJSON
          2. shapefile, fiona, shapely, geopandas
      8. Time and Date
        1. datetime and time modules
        2. calendar module
        3. Time zones (zoneinfo, pytz)
        4. Time arithmetic (timedelta, rounding, truncation)
        5. Parsing and formatting dates (strptime, strftime, dateutil)
        6. High-resolution timers (time.perf_counter, process_time, monotonic)
        7. Scheduling and delays (sleep, sched, asyncio.sleep)
        8. Measuring performance (timeit, perf_counter_ns)
        9. Timestamp conversion and epoch time
    4. Structured and Modular Programming
      1. Object-Oriented Programming (OOP)
        1. Classes and objects
          1. Defining and instantiating classes
          2. The __init__ and __new__ methods
          3. The object model and __class__ attribute
        2. Attributes and methods
          1. Class vs instance attributes
          2. Attribute lookup order and MRO
          3. Attribute hiding and naming conventions (_, __)
          4. Dynamic access (getattr, setattr, delattr, hasattr)
        3. Encapsulation and abstraction
          1. Private vs public members (naming conventions)
          2. Getters, setters, and deleters (@property)
          3. Read-only attributes
        4. Inheritance
          1. Single and multiple inheritance
          2. super() and cooperative MRO
          3. Method overriding and extension
          4. Abstract base classes (abc module)
          5. Mixins and shared behavior
          6. Composition vs inheritance
        5. Class mechanics
          1. __slots__ and memory optimization
          2. Metaclasses and dynamic class creation
          3. type() and runtime class manipulation
          4. types module utilities
        6. Special / magic / dunder methods
          1. __repr__, __str__, __len__, __getitem__, etc.
          2. Operator overloading (__add__, __eq__, etc.)
          3. Context management (__enter__, __exit__)
          4. Callable objects (__call__)
          5. Iteration protocols (__iter__, __next__)
        7. Advanced typing and design
          1. Generics and typing.Generic
          2. Protocols (PEP 544)
          3. Covariance and contravariance
          4. Duck typing and structural subtyping
          5. Casting (typing.cast)
        8. Utilities and modern OOP helpers
          1. dataclasses (auto-generated methods, immutability)
          2. attrs (third-party library)
          3. pydantic (data validation models)
          4. enum (enumerations and flag enums)
          5. collections.abc (interfaces for containers)
      2. Decorators
        1. Function decorators
          1. Basic decorator syntax
          2. Multiple decorators
          3. @staticmethod, @classmethod, @property
        2. Class decorators
          1. Decorating entire classes
          2. Injecting attributes or methods dynamically
        3. Parameterized decorators
          1. Nested closures for arguments
          2. Factory pattern for decorators
        4. functools.wraps
          1. Preserving metadata (__name__, __doc__)
          2. Common pitfalls and best practices
        5. Practical applications
          1. Logging and timing
          2. Memoization (functools.lru_cache)
          3. Access control and validation
          4. Class registration and plugin systems
      3. Modules (advanced)
        1. Packages and __init__.py
          1. Namespace packages (PEP 420)
          2. Relative and absolute imports
          3. Module-level constants and configuration
        2. Standard modules (extended list)
          1. Input/output (io, os, pathlib, shutil)
          2. Argument parsing (argparse, getopt, sys.argv)
          3. Mathematical utilities (math, cmath, statistics)
          4. Data structures (collections, collections.abc, array, enum)
          5. Memory and performance (copy, sys, resource)
          6. Console utilities (curses, readline)
        3. CLI modules
          1. sys, argparse, getopt
          2. Subcommands and command dispatchers
          3. CLI design patterns (subparsers, help messages)
        4. Import system internals
          1. importlib and module reloading
          2. sys.meta_path, loaders and finders
          3. Module caching and sys.modules
          4. Dynamic imports (__import__, importlib.import_module)
          5. Executing packages as scripts (python -m)
      4. Logging
        1. logging module fundamentals
          1. Logger hierarchy and propagation
          2. Logging levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
          3. Handlers, formatters, filters
          4. Configuration (basicConfig, dictConfig, fileConfig)
          5. Custom loggers and modular logging
        2. Structured and external logging
          1. JSON logging (jsonlogger)
          2. Log rotation (logging.handlers.RotatingFileHandler)
          3. Integration with monitoring tools (ELK, Prometheus)
        3. Distributed tracing and OpenTelemetry
          1. Traces, spans, and metrics
          2. Exporters and backends
          3. Integration with logging and asyncio
      5. Documentation
        1. Docstrings
          1. Inline documentation conventions
          2. Access via help() and .__doc__
        2. Docstring formats
          1. reStructuredText (reST)
          2. Google style
          3. NumPy style
          4. Epydoc and Sphinx roles
        3. doctest (testing from docstrings)
          1. Embedding examples
          2. Running tests from documentation
        4. Documentation generators and renderers
          1. sphinx (reST → HTML/PDF)
          2. readthedocs hosting
          3. mkdocs and Material for MkDocs
          4. pdoc3 (auto API documentation)
          5. Doxygen + Breathe integration
          6. JupyterBook for literate programming
          7. Integration with CI/CD (auto-generated docs)
      6. Testing
        1. Testing frameworks
          1. unittest (standard library)
          2. pytest (most popular)
          3. nose2 and legacy options
        2. Code coverage
          1. coverage.py basics
          2. pytest-cov integration
          3. Coverage thresholds and reports
        3. Testing types
          1. Unit Testing (unittest, pytest)
          2. Integration Testing (unittest, pytest)
          3. Functional Testing (unittest, pytest)
          4. Acceptance Testing (unittest, behave)
          5. Regression Testing (unittest, pytest)
          6. Performance Testing (timeit, pytest-benchmark)
          7. Load / Stress Testing (asyncio, locust)
          8. Security Testing (unittest, bandit)
          9. Property-Based Testing (unittest, hypothesis)
          10. Fuzz Testing (unittest, atheris)
          11. Snapshot Testing (unittest, syrupy)
          12. Contract Testing (unittest, pact)
          13. API Testing (http.client, pytest + requests)
          14. UI / E2E Testing (unittest, playwright)
          15. Database Testing (sqlite3, pytest + testcontainers)
          16. Async/Concurrency Testing (asyncio, pytest-asyncio)
          17. Data Quality / Validation Testing (json, great_expectations)
          18. Compatibility / Cross-env Testing (venv, tox)
          19. Smoke / Sanity Testing (unittest, pytest)
          20. Accessibility Testing (unittest, playwright)
        4. Fixtures and parametrization
          1. Test Lifecycle Hooks (unittest setUp/tearDown, pytest)
          2. Fixture Scopes (unittest class/module, pytest function/class/module/session)
          3. Autouse Fixtures (unittest base classes, pytest)
          4. Parametrized Tests (unittest subTest, pytest.mark.parametrize)
          5. Factory Fixtures (unittest helpers, pytest fixture factories)
          6. Temporary Paths and Files (tempfile, pytest.tmp_path)
          7. Environment and Patching (unittest.mock, pytest.monkeypatch)
          8. Capturing Output (contextlib.redirect_stdout, pytest.capsys/capfd)
          9. Logging Capture (logging, pytest.caplog)
          10. Time Control (time, freezegun)
          11. Network Isolation (socket, pytest + responses)
          12. Async Fixtures (asyncio, pytest-asyncio)
          13. Database Fixtures (sqlite3, pytest + testcontainers)
          14. Data Builders (json, factory_boy)
          15. Randomness Control (random, pytest-randomly)
        5. Advanced testing tools
          1. Mocking and Spies (unittest.mock, pytest-mock)
          2. Patch Utilities (unittest.mock.patch, pytest.monkeypatch)
          3. Coverage and Reports (trace, coverage.py)
          4. Parallel and Distributed Tests (multiprocessing, pytest-xdist)
          5. Flaky Test Control (unittest reruns, pytest-rerunfailures)
          6. Timeouts and Slow Tests (signal, pytest-timeout)
          7. Benchmarking (timeit, pytest-benchmark)
          8. Mutation Testing (ast, mutmut)
          9. HTTP Mocking (http.server, responses)
          10. Recording HTTP (VCR) (urllib, vcrpy)
          11. Contract & Schema Testing (json, schemathesis)
          12. Snapshot Testing (pickle, syrupy)
          13. Test Data Generation (random, faker)
          14. Test Selection & Caching (importlib, pytest-testmon)
          15. HTML/Allure Reports (unittest XML, pytest-html)
          16. CI/CD Integration (subprocess, tox)
          17. Profiling for Tests (cProfile, pyinstrument)
          18. Static Analysis (lint/type) (ast, ruff)
          19. Containerized Tests (subprocess, testcontainers)
          20. Async/Trio/AnyIO Tools (asyncio, pytest-anyio)
      7. Debugging
        1. Standard debuggers
          1. pdb
          2. bdb, ipdb, pudb
          3. IDE-integrated debuggers (VSCode, PyCharm)
        2. Remote and distributed debugging
          1. debugpy (VSCode protocol)
          2. rpdb, pydevd
        3. Traceback and runtime analysis
          1. Stack traces and frames
          2. Traceback objects and inspection
          3. faulthandler for low-level tracing
        4. Code tracing tools
          1. trace module (execution flow)
          2. inspect module (live introspection)
          3. sys._getframe, locals/globals inspection
          4. Profiling vs debugging differences
        5. Exception debugging
          1. Post-mortem debugging
          2. Context display (contextlib, traceback.print_exc)
          3. Custom exception hooks (sys.excepthook)
    5. Advanced Structures and Functional Programming
      1. Functional Programming
        1. Functional paradigms and immutability
        2. Higher-order functions (map, filter, reduce)
        3. Anonymous functions (lambda)
        4. functools utilities
          1. partial, cmp_to_key, cache, lru_cache, reduce
        5. operator module (functional equivalents for arithmetic/logical ops)
        6. Closures and free variables
        7. Currying and partial application
        8. Immutability and purity
        9. Function composition and pipelines
        10. Functional iteration (itertools, more-itertools)
        11. Side effects and referential transparency
        12. Recursion and tail call optimization
        13. Persistent data structures (immutables, pyrsistent)
      2. Itertools / Advanced Generators
        1. Combinatorial tools (product, permutations, combinations, combinations_with_replacement)
        2. Accumulators and counters (accumulate, count, cycle, repeat)
        3. Sequence utilities (chain, compress, dropwhile, takewhile, islice, starmap, tee, zip_longest, groupby)
        4. Infinite and lazy sequences (itertools, more-itertools)
        5. Generator delegation (yield from)
        6. Generator-based pipelines and streams (toolz, funcy)
      3. Memory Views
        1. Buffer protocol (low-level binary access)
        2. memoryview objects and slicing
        3. Byte arrays and binary manipulation (bytearray, array)
        4. Dict views (keys, items, values)
        5. Shared memory across processes (multiprocessing.shared_memory)
        6. Interfacing with C-level buffers (ctypes, numpy)
      4. Benchmarking and Profiling
        1. Timing and microbenchmarks (timeit, perf_counter)
        2. CPU profiling (cProfile, profile, pstats)
        3. Memory profiling (tracemalloc, memory_profiler)
        4. Line-level profiling (line_profiler)
        5. Statistical and sampling profilers (py-spy, scalene, yappi)
        6. Async profiling (aiomonitor, asyncio-run-instrument)
        7. Visualization tools (snakeviz, tuna, speedscope)
        8. Benchmark frameworks (pytest-benchmark, asv)
      5. Code Quality Tools
        1. Style and formatting (flake8, autopep8, black, isort)
        2. Type checking (mypy, pyright, pytype)
        3. Linting (pylint, ruff, prospector)
        4. Security analysis (bandit, safety)
        5. Metrics and complexity (radon, wily)
        6. Code modernization (pyupgrade, futurize, modernize)
        7. Git and pre-commit automation (pre-commit, tox, nox)
        8. Docstring and naming validation (pydocstyle, pep8-naming)
        9. Dead code and dependency analysis (vulture, pip-check)
        10. Refactoring tools (rope, bowler)
      6. Security
        1. Common Algorithms and Concepts
          1. Symmetric encryption (AES, ChaCha20)
          2. Asymmetric encryption (RSA, ECC)
          3. Hashing (SHA, BLAKE2, PBKDF2)
          4. Key derivation and stretching (scrypt, Argon2)
          5. Digital signatures and verification
          6. Certificates and PEM handling
          7. Public Key Infrastructure (PKI)
          8. Randomness and entropy pools
        2. Standard Library
          1. hashlib (hash algorithms, digests)
          2. secrets (secure randomness)
          3. ssl (TLS, context management)
          4. hmac (hash-based message authentication)
          5. base64 (binary encoding)
        3. Third-Party Libraries
          1. bcrypt
          2. passlib
          3. cryptography
          4. pyjwt
          5. argon2-cffi
          6. fernet
      7. Type Hints
        1. Function and variable annotations
        2. typing module fundamentals
        3. Type aliases (TypeAlias)
        4. Generic types (TypeVar, Generic)
        5. Protocols (PEP 544)
        6. Unions and optionals (Union, Optional)
        7. Literal types (Literal)
        8. NewType and nominal typing (NewType)
        9. Typed mappings (TypedDict)
        10. Self type and recursive references (Self, PEP 673)
        11. Parameter and return specifications (ParamSpec, Concatenate, PEP 612)
        12. Advanced static typing (mypy_extensions, typing_extensions)
        13. Runtime type checking (beartype, typeguard)
        14. Dataclass typing and validation (dataclasses, pydantic)
        15. Gradual typing and static analysis (mypy, pyright, ruff --extend-select TYP)
    6. Concurrency, Async, Low Level
      1. Async and Concurrency
        1. Thread-based concurrency (threading, concurrent.futures.ThreadPoolExecutor)
        2. Process-based parallelism (multiprocessing, concurrent.futures.ProcessPoolExecutor)
        3. Global Interpreter Lock (GIL) and its implications
        4. Synchronization primitives
          1. Locks (Lock, RLock)
          2. Semaphores, Events, Barriers, Conditions
          3. Queues (queue, asyncio.Queue, multiprocessing.Queue)
        5. Parallelism vs concurrency concepts
        6. Asynchronous programming (asyncio)
          1. async / await keywords
          2. Coroutines and cooperative multitasking
          3. Async iterators and async generators
          4. Async comprehensions
          5. Async context managers (async with)
          6. Event loop internals (asyncio.get_event_loop, policies)
          7. Task scheduling (create_task, gather, wait, shield)
          8. Synchronization primitives (Lock, Event, Semaphore, Condition)
          9. Exception handling and cancellation (CancelledError)
          10. Third-party event loops (uvloop, trio, anyio, curio)
          11. Green threads (greenlet, gevent)
          12. Background tasks and concurrency with async frameworks
          13. Integration with threads and processes (to_thread, run_in_executor)
          14. Async profiling and debugging (aiomonitor, asyncio.run, tracemalloc)
      2. Networking
        1. Networking fundamentals
          1. TCP/IP basics
          2. IP addressing and subnetting (ipaddress)
        2. Low-level networking (socket)
          1. TCP and UDP sockets
          2. Non-blocking I/O and selectors
          3. Socket options and timeouts
        3. High-level networking
          1. HTTP protocol basics
          2. URL handling (urllib, urllib3)
          3. HTTP clients (requests, httpx, aiohttp)
          4. WebSockets (websockets, aiohttp, fastapi.websockets)
          5. Email and SMTP (smtplib, imaplib, poplib, email)
          6. FTP and SFTP (ftplib, paramiko)
        4. Web application interfaces
          1. WSGI (wsgiref, flask)
          2. ASGI (fastapi, starlette, aiohttp)
          3. HTTP servers (http.server, aiohttp.web, uvicorn, hypercorn)
        5. Networking concurrency
          1. Async sockets (asyncio.start_server, asyncio.open_connection)
          2. Connection pooling and throttling
          3. DNS and async resolvers (aiodns)
          4. SSL/TLS contexts (ssl)
          5. Performance testing and benchmarking (ab, wrk, locust)
      3. Metaprogramming
        1. Metaclasses (type, __new__, __init__)
        2. Descriptors (__get__, __set__, __delete__)
        3. Difference between class decorators and metaclasses
        4. Dynamic class and attribute creation (setattr, getattr)
        5. Attribute access customization (__getattr__, __getattribute__)
        6. Decorator-based metaprogramming patterns
        7. Code generation and reflection (ast, inspect, types)
        8. Runtime modification of objects (monkey patching, proxy classes)
        9. Introspection and dynamic imports (importlib, sys.modules)
      4. Context Managers
        1. with statement semantics
        2. Built-in context managers (open, decimal.localcontext, threading.Lock)
        3. contextlib module
          1. contextmanager decorator
          2. ExitStack, redirect_stdout, suppress
        4. Async context managers (async with, @asynccontextmanager)
        5. Custom context managers (__enter__, __exit__)
        6. Resource cleanup and exception safety
        7. Nested and chained contexts (ExitStack)
      5. Monitoring
        1. Runtime monitoring (sys.monitoring, PEP 669)
        2. Code tracing (sys.settrace, sys.setprofile)
        3. Logging and telemetry integration (logging, OpenTelemetry)
        4. Application performance monitoring (APM) (sentry-sdk, datadog, newrelic)
        5. Resource usage tracking (resource, psutil)
        6. System-level inspection (os, platform, tracemalloc)
        7. Custom metrics and exporters (prometheus_client)
        8. Distributed tracing (opentelemetry, jaeger-client)
      6. Garbage Collection
        1. Reference counting and object lifetime
        2. gc module (manual control, thresholds, debug flags)
        3. Weak references (weakref, WeakKeyDictionary, WeakValueDictionary)
        4. Circular reference detection and cleanup
        5. Finalization and destructors (__del__, atexit)
        6. Object tracking and introspection (gc.get_objects, gc.get_referrers)
        7. Memory leaks and object retention analysis (objgraph, pympler)
        8. Interaction with C extensions and native memory
        9. Performance tuning and garbage collection strategies (gc.freeze, tuning generations)
    7. Implementation & Distribution
      1. General Environment Tools
        1. Virtual environments (venv, virtualenv)
        2. Interactive environments (jupyter, IPython)
        3. Package installation and dependency management (pip, requirements.txt)
        4. Modern build systems (pyproject.toml, poetry, flit, uv, pdm)
        5. Conda environments (conda, mamba)
        6. Python version management (pyenv, asdf, tox)
        7. Dependency resolution and locking (pip-tools, poetry.lock, uv.lock)
        8. Environment reproducibility (pip freeze, conda env export)
        9. Project isolation and sandboxes (direnv, nix-shell)
        10. Environment variables and configuration management (dotenv, pydantic-settings)
      2. Implementations
        1. Building Python from source (configure, make, installation paths)
        2. CPython internals and command-line interface
          1. Bytecode compilation (dis, compile)
          2. Interpreter flags (-O, -m, -B, -I)
          3. Debug builds and symbol tables
        3. Alternative implementations
          1. PyPy (JIT compiler and performance profiling)
          2. Cython (C extensions, pyximport, cythonize)
          3. Codon (Python-to-native compiler for performance)
          4. MicroPython (embedded systems)
          5. RustPython, GraalPy, Jython, IronPython
        4. Binary distribution
          1. pyinstaller (single-file executables)
          2. cx_Freeze (cross-platform packaging)
          3. nuitka (C++ compilation and optimization)
          4. shiv, pex (self-contained zip apps)
        5. Web runtimes and browser targets
          1. PyScript (Python in HTML, WASM-based)
          2. Pyodide (WASM + scientific stack)
          3. Brython (transpiles Python to JavaScript)
          4. Transcrypt (typed Python → JS transpiler)
        6. Embedding Python in other languages
          1. C API (Python.h)
          2. ctypes and cffi
          3. Integration in C/C++, Rust, and Go projects
          4. Cross-language execution (subprocess, ffi, wasmer)
        7. Extending Python with native code
          1. C extensions and modules
          2. pybind11, Cython, cffi
          3. Shared libraries and ABI compatibility
      3. Packaging
        1. Packaging process
          1. setuptools and setup.py
          2. setup.cfg (declarative configuration)
          3. pyproject.toml (PEP 517/518 compliant builds)
          4. Build artifacts (sdist, wheel)
          5. Distribution upload (twine, flit publish, poetry publish)
          6. Package signing and verification (gpg, twine --sign)
        2. Package indexes
          1. PyPI (official package index)
          2. TestPyPI (staging environment)
          3. pypiserver (self-hosted registries)
          4. Private and enterprise registries (devpi, artifactory, nexus)
        3. Versioning and metadata
          1. Semantic versioning (PEP 440)
          2. Metadata and classifiers (setup.cfg, pyproject.toml)
          3. Dynamic versioning tools (setuptools_scm, bumpver, versioneer)
        4. Dependency management and resolution (pip, resolverlib)
        5. Package auditing and signing (pip-audit, gpg, sigstore)
        6. Cross-platform builds and reproducibility (build, cibuildwheel, tox)
      4. CLI Apps
        1. CLI argument parsing
          1. argparse (std lib)
          2. optparse (legacy)
          3. getopt (low-level)
        2. Command frameworks
          1. click
          2. typer
          3. python-fire
        3. Console utilities
          1. colorama (color support)
          2. rich (formatting, live tables, progress bars)
          3. prompt_toolkit, inquirer (interactive prompts)
        4. CLI packaging
          1. Entry points (console_scripts)
          2. Shell completion generation
          3. Cross-platform support (os, shutil.which)
      5. Graphical Apps
        1. GUI frameworks
          1. tkinter (standard library)
          2. PyQt5, PySide6 (Qt bindings)
          3. Kivy, KivyMD (mobile and touch support)
          4. wxPython (native widgets)
          5. Dear PyGui (immediate-mode GUI)
          6. PyGObject, GTK3/4
        2. Game and multimedia frameworks
          1. pygame, arcade, ursina
        3. GUI builders and design tools (Qt Designer, Glade)
        4. Cross-platform packaging (pyinstaller, briefcase)
      6. Internationalization (i18n) and Localization (l10n)
        1. Text translation and message catalogs
          1. gettext (std lib)
          2. babel (third-party)
          3. polib (PO file management)
        2. Locale management (locale, setlocale, environment vars)
        3. Number, date, and currency formatting
          1. babel.numbers, babel.dates
          2. locale.format_string
        4. Unicode normalization and encoding handling (unicodedata)
        5. Time zones and calendars (zoneinfo, dateutil)
        6. Multi-language configuration and packaging (gettext, pybabel extract/update)
    8. Internals
      1. Python Compiler & Interpreter
        1. Abstract Syntax Tree (AST) (ast, compile)
        2. Bytecode inspection (dis, opcode)
        3. Tokenization and lexing (tokenize, token)
        4. Lexical analysis and parsing pipeline
        5. Symbol tables and scoping (symtable)
        6. Compilation stages (source → AST → bytecode)
        7. Evaluation loop (CEval)
        8. Frame objects (sys._getframe, inspect)
        9. Code objects (__code__, types.CodeType)
        10. Bytecode caching (.pyc, __pycache__)
        11. Optimization flags (-O, -OO)
        12. Dynamic code execution (eval, exec)
        13. Compile-time constants and folding
        14. Abstract interpretation and future statements (__future__)
      2. Execution Model
        1. Call stack and stack frames
        2. Function call mechanics and parameter passing
        3. Coroutine scheduling and task switching (asyncio, trio)
        4. Import execution and module caching (importlib, sys.modules)
        5. Global state and thread safety (threading, contextvars)
        6. Context variables (PEP 567)
        7. Event loop interaction and scheduling
        8. Exception propagation across async boundaries
        9. Interpreted vs compiled function calls (builtin_function_or_method)
        10. Trampolines and frame reuse optimizations
        11. Generator and async state machines
      3. Data Model
        1. ctypes and C-compatible structures
        2. Object memory layout and slots (__slots__)
        3. PyObject structure and reference model
        4. Type objects and inheritance hierarchy
        5. Method resolution order (C3 linearization)
        6. Data vs non-data descriptors (__get__, __set__, __delete__)
        7. Dynamic attribute resolution (__getattr__, __getattribute__)
        8. Numeric and sequence protocols (__add__, __getitem__, etc.)
        9. Callable protocol (__call__)
        10. Context manager protocol (__enter__, __exit__)
        11. Iterator protocol (__iter__, __next__)
        12. Coroutine protocol (__await__, __anext__)
        13. Mapping, hashing, and equality semantics (__hash__, __eq__)
      4. Python C Model
        1. CPython C API (Python.h)
        2. PyObject structure and reference counting
        3. Extending Python with C modules (PyModuleDef, PyMethodDef)
        4. Embedding Python in C/C++ applications (Py_Initialize, PyRun_SimpleString)
        5. Argument parsing (PyArg_ParseTuple, Py_BuildValue)
        6. Error and exception handling (PyErr_SetString, PyErr_Occurred)
        7. Memory management (Py_INCREF, Py_DECREF)
        8. GIL internals and state management (PyGILState_Ensure, PyEval_SaveThread)
        9. Frame and thread state (PyThreadState, PyInterpreterState)
        10. C API headers (object.h, listobject.h, dictobject.h)
        11. Subinterpreters and isolated runtimes (_xxsubinterpreters, PEP 684)
        12. Cython bridge and interoperability (cython, pyximport)
        13. ABI stability and limited API (Py_LIMITED_API, PEP 384)
        14. Capsule and pointer exchange (PyCapsule)
      5. Extensions
        1. Protocols and Foreign Function Interfaces (FFI)
          1. ctypes
          2. cffi
          3. pybind11
          4. SWIG
        2. Inter-language data marshaling and memory safety
        3. Extending and embedding with native languages
          1. C
          2. C++
          3. Rust (PyO3, rust-cpython, maturin)
          4. Go (gopy, cgo, pygo)
        4. WASM integration (wasmer, wasmtime-py)
        5. Cross-language RPC frameworks (grpc, capnp, flatbuffers)
        6. Plugin systems and dynamic loading (importlib.machinery, ctypes.CDLL)
        7. Binary interface and FFI debugging (gdb, valgrind, lldb-python)