• Coroutine model and event loop: how concurrency is achieved
•  Waiting and coordinating tasks: await, gather, task groups
•  Typical asynchronous code errors: blocking loops, race conditions, memory leaks
•  Green flows and other alternatives

Practice: 

Task orchestration using a semaphore, choosing a concurrency/concurrency strategy for different types of tasks

• Process launch models: fork, spawn
•  Data exchange between processes: queues, pipes, shared memory
•  IPC and process coordination
•  Choosing the number of processes: balancing performance and processor capabilities

 Practice:

 Centralized logging, parallel computing, and data sharing using IPC and shared memory

• How and why thread races arise
•  Locking primitives: mutex, lock and their impact on performance
•  Thread-safe interaction through queues and data exchange
•  Thread Coordination: Semaphore, Event, Condition
•  Choosing the Number of Threads: A Tradeoff Between Concurrency and Overhead

Practice:

Implementation of a multi-threaded log collector, implementation of thread-safe structures

• The role of the GIL in CPython and its impact on performance
•  Thread switching: how Python handles I/O-bound and CPU-bound tasks
•  GIL interaction with thread scheduler and signals
•  GIL implementation: mutexes, semaphores, pthreads conditional variables  

Practice: 

Choosing an execution strategy and explaining the results taking into account the impact of GIL

• Local and external caches (in-memory vs Redis): when is which approach appropriate?
•  Typical caching errors: stale data, cache stampede, uncontrolled growth
•  Cache-eviction policies (LRU, LFU, TTL) and their impact on memory and hit-rate
•  Approaches to choosing cache size: a trade-off between memory consumption, performance, and stability  

Practice: 

Choosing an approach for the task, implementing an LRU cache, analyzing the impact of the cache on performance and algorithm behavior

• Vectorization and abandonment of Python loops NumPy and alternatives: PyArrow, JAX — usage scenarios
•  Zero-copy approach: buffer protocol, memoryview, mmap — working with data without copies
•  Compilation and JIT optimization: Cython, Numba. When it's justified and when it's not

 Practice:

 Working with byte data without copies, choosing the optimal data processing approach for a specific task

• Shallow, deep, and hidden copying: where Python creates new objects
•  Memory fragmentation: causes and accumulation
•  The impact of copying and fragmentation on memory consumption and system stability
•  What to use instead of copies: working with references and view approaches (generators, weak references, slots, named tuples, dataclasses)  

 Practice:

 Implementation of Copy-On-Write array, analysis of hidden allocations, memory profiling

• CPython's internal object model: PyObject, reference counting, the role of GC
•  Memory management levels: heap, arenas, pools, blocks and pymalloc logic
•  Typical patterns of overallocation and memory fragmentation in Python code
•  Measurement and diagnostic tools: tracemalloc, gc, sys.getsizeof, practical analysis techniques

Practice: Writing code without unnecessary allocations

• Deep understanding of parsing techniques

• Working with lists and trees