Python Advanced NEW

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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