Python Advanced¶

About¶

Level: Advanced
Lectures: 40 hours
Self-study: 20 hours
Exercises: 137
Lines of Code to write: 666
Format: e-learning + weekly online teleconference with instructor
Language: English or Polish

Description¶

This advanced, hands-on course explores modern Python features and idioms needed to design robust, maintainable, and high-performance applications. Following the syllabus, students work through advanced syntax, deep object-oriented patterns, operator overloading and accessor protocols, functional programming techniques, metaprogramming, and asynchronous programming; labs emphasize applying these concepts to real problems such as building performant APIs, safe concurrency patterns, and extensible libraries.

Advantages¶

Participants will gain practical mastery of advanced Python tools and patterns that reduce bugs, improve code clarity, and boost performance. The course teaches techniques for better API design, refactoring, debugging and testing of async code, and using metaprogramming safely; these skills help engineers ship features faster, maintain larger codebases with confidence, and take on architecture or library-authoring roles.

Target Audience¶

Senior and backend Python developers who want to master advanced language features and architecture patterns.
Library and framework authors who require metaprogramming and API design skills to build extensible, well-tested code.
Software architects and technical leads responsible for maintainability and performance in Python systems.
Developers working with concurrency, async I/O, or high-throughput networked services who need robust async patterns and testing.
Data engineers and researchers who write production code and need deeper language and optimization knowledge.
Advanced students and learners aiming to level up to senior Python engineering roles.

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¶

Syntax:
- Exceptions (nested, custom)
- Assignment Expressions
- t-strings
Advanced Typing:
- TypedDict and NamedTuple
- LiteralString
- Iterator and Generator
- Override, Overload, Final
- Type aliases, TypeVar
- Variance: covariance, contravariance, and invariance
- Generic types
- Type narrowing: TypeGuard, TypeIs
- Annotated
- Static type checking with mypy
Object Oriented Programming:
- SOLID principles
- Access modifiers
- Object mutability
- Equality and identity
- Object formatting
- Slots
- Property
- Methods and Self
- Staticmethods
- Classmethod
Inheritance:
- Inheritance patterns
- Mixins
- Composition and aggregation
- Method and attribute overriding
- Super
- Method Resolution Order (MRO)
Polymorphism:
- Abstract Base Classes (ABC)
- Protocols and structural polymorphism
- Abstract collections
Encapsulation:
- Concept of encapsulation and accessors
- Property: setter, getter, deleter
- Reflection: setattr, getattr, hasattr, delattr
- Descriptors: set, get, delete, set_name
Metaprogramming:
- init_subclass
- init vs new
- Type
- Namespace
- Class-factory
- Metaclass
Operator Overloading:
- Left, in-place, right
- Arithmetic, comparison, binary
- Accessors: setitem, getitem, delitem, missing, call
- Overloading built-in functions
Serialization:
- Serialization algorithms and formats
- Deserialization algorithms and techniques
- Data normalization and type conversion
Functional Paradigm:
- Lambda expressions
- Pure functions
- Memoization, cache, lru_cache
- Recursion
- Immutable data structures and referential transparency
- Function namespaces and attributes, callable
- Function scopes
- Higher-order functions, closures
- Map, Filter, Reduce
- Patterns: pipe, callback, closure, maybe, some, map-reduce
- Functools builtin module
Decorators:
- Types of decorators and wrapper types
- Function, method, and class decorators
- Nested decorators
- Decorators with arguments
Generators:
- Generator expressions
- Generator functions
- Running, lazy processing, and introspection
- yield and yield from keywords
- Sending values to generators
Asynchronous Programming:
- Concurrency models
- Introduction to asynchronous programming
- Concepts: coroutines, awaitables, event loop
- async/await keywords
- Introduction to the asyncio library
- Run, gather, wait_for
- Future, Task, TaskGroup
- Async: iterator, generator, context manager, comprehension
- Asynchronous testing
- Asynchronous execution of tasks in the operating system
The Future of Python
- Planned changes in future Python versions
- Speculation
- Where to look for further information
(Optional) AI-driven TDD and CI/CD
- Types of tests
- Testing frameworks
- Linters, static analyzers, and supporting tools
- Developer tool ecosystem
- Building a CI/CD pipeline
- Test execution strategy
- Practical demonstration of TDD with AI support

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.

Prerequisites¶

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.)

Date¶

This training course is offered on demand. Dates are flexible and can be arranged to accommodate the schedules of participants. Please contact us to schedule your training session.

Contact¶

If you have any questions, please email us at: info@aatc.pl

Apply¶

To apply please contact us at: info@aatc.pl