Python – Async IO: Coroutines in Python (PYTH4)

Programming, Python

Have you mastered all the common aspects of Python and only asynchronous coroutines are missing? Python offers the possibility of programming tasks processed by a scheduler within a single program thread. Together with a library for processing asynchronous communication and events, it is also possible to program using cooperative tasks in Python.

Sign up for a practical workshop that will guide you from simple iterators and generators to writing asynchronous coroutines. Learn to write event-based programs and multi-step cooperative tasks. Try an efficient programming style suitable for more demanding programmers.

THIS TRAINING COURSE WILL HELP YOU:

    Understanding and implementing asynchronous coroutines in Python, mastering event-based programming and multi-step cooperative tasks.

WHO SHOULD ATTEND?

    Intermediate to advanced Python programmers.

COURSE LOCATION AND AVAILABLE DATES



Public courses are usually delivered in Czech, but this course is also available in English. We can arrange private training for your team online, at your premises or in our classrooms, and tailor the content to your needs.

For groups of around 4 or more participants, private training can already be comparable in price to booking individual places on a public course. Send us your requirements and we’ll recommend the best format and provide an exact quote.

Request training in English

Course content:

Hide details
  • Basics of cooperative programming
    1. Concurrency of events and tasks
    2. Concurrent processing without threads
    3. Asynchronous tools in Python
  • Comparison of concurrent processing options
    1. Coroutines and callbacks
    2. Multithreaded applications
    3. Multiprocess applications
  • First coroutines
    1. Processing in parts
    2. Simple generators
    3. From generators to coroutines
    4. Non-blocking waiting
  • Input and output
    1. Integration with the operating system
    2. Waiting for events (futures)
  • Practical asynchronous programming
    1. Event loop
    2. Network communication
    3. User input and output
    4. Cooperative computational tasks
  • Important theory
    1. Asymptotic complexity of algorithms
    2. Cooperative cycles
  • Combination with operating system threads
    1. Multithreading and multiprocessing
    2. Integration of threads and event loop
    3. Existing I/O libraries and their integration
  • General recommendations
    1. Choice of tools for concurrent processing
    2. Multiprocessing, multithreading, coroutines
    3. Writing understandable code
Prerequisites:
Basic knowledge of Python programming.
Recommended previous course:
Python – Design Patterns (PYTH3)
Schedule:
3 days (9:00-17:00)

Training and learning environment