Skip to content

Python Profiling and Performance Tuning

About

  • Level: Intermediate to Advanced
  • Lectures: 20 hours
  • Self-study: 10 hours
  • Exercises: 22
  • Lines of Code to write: 118
  • Format: e-learning + weekly online teleconference with instructor
  • Language: English or Polish

Description

This hands-on course teaches practical profiling and performance tuning for Python applications using the syllabus as its roadmap. Students explore CPU and memory architecture, latency concepts and complexity analysis, and the Faster CPython project and recent interpreter improvements. Through exercises in micro-benchmarking, identifying bottlenecks, CPU and memory profiling, and visualization of results, participants learn how to spot performance regressions and apply targeted optimizations, including when to transpile hot code to C or apply concurrency and parallelism patterns.

Advantages

Participants will be able to measure and reduce latency and resource use in real applications by applying profiler-driven workflows and benchmarking best practices. The course teaches practical techniques for finding and fixing hotspots, improving memory usage, choosing between multithreading, multiprocessing and async approaches, and visualizing results for stakeholders — skills that lead to faster, more efficient software and lower operational cost.

Target Audience

  • Backend and application developers who need to optimize Python code and reduce latency and resource consumption in production.
  • Performance engineers and SREs responsible for diagnosing bottlenecks and tuning services for throughput and reliability.
  • Data engineers and ML engineers who must profile and speed up numeric and ETL workloads to meet production SLAs.
  • QA and test engineers focused on load testing, benchmarking, and performance regression detection.
  • Architects and technical leads who evaluate trade-offs between design choices, concurrency models, and deployment strategies.
  • Advanced students and developers who want practical, hands-on skills to profile, benchmark, and optimize Python applications.

Format

The course is delivered as a blended learning experience, comprising numerous short videos that progressively introduce concepts and techniques through a series of practical examples. The course format combines e-learning modules with weekly online teleconferences with the instructor for Q&A, discussions, and code reviews.

During the self-study phase, students complete practical exercises that apply the learned techniques. Each exercise is designed to have 100% test coverage, allowing students to verify their solutions. Additionally, students will have access to a spreadsheet to track their progress.

Students will also receive downloadable resources, including code samples, exercise templates, and reference materials to support their learning journey. Since 2015, we have refined our materials based on student feedback to ensure clarity, engagement, and practical relevance. All code listings undergo automatic testing (over 28,000 tests) to ensure accuracy and reliability. All materials, code listings, exercises, and assignments are handcrafted by our trainers without the use of AI. All case studies and examples are based on real-world scenarios drawn from our extensive experience in software engineering.

Working language of the course is either English or Polish.

Course Outline

  1. Introduction:

    • The Faster CPython project
    • Changes in versions 3.11, 3.12, 3.13, 3.14, 3.15, ...
    • CPU and memory architecture
    • The concept of latency
    • Code complexity concepts (memory, computational, cyclomatic, cognitive)

  2. Optimization:

    • Computational complexity of operations on built-in data types
    • Manual and automatic identification of complex code
    • Load testing
    • Transpiling Python code to C

  3. Performance tuning:

    • Techniques for measuring code performance
    • Microbenchmarking and its pitfalls
    • Identifying bottlenecks
    • Results visualization

  4. Profiling:

    • CPU profiling
    • Memory profiling
    • Profilers in Python 3.15

  5. Introduction to concurrency and parallel processing:

    • GIL – Global Interpreter Lock
    • Multiprocessing
    • Multithreading
    • Asynchronous programming

Our Experience

AATC trainers have been teaching software engineering since 2015. We have already delivered over 11,000 (eleven thousand) hours of software engineering training to more than 32,000 (thirty-two thousand) students worldwide.

Requirements

  • Intermediate knowledge of Python programming
  • Familiarity with using an IDE (e.g., PyCharm, VSCode)
  • Familiarity with using version control systems (e.g., Git)

Setup

  • Newest version of Python
  • IDE of your choice (e.g., PyCharm, VSCode)
  • Git installed and configured
  • GitHub account
  • Web browser (e.g., Chrome, Firefox, Safari, etc.)

Apply

If you are interested in taking this course, please contact us at info@astronaut.center