Course Info

Main advantage: better Python usage in your company, so that developers work faster and write better code, that is easier, faster and cheaper to maintain

Duration: 3 days x 7 hours brutto (i.e. including breaks) + consultations after every course day
Format: workshop (70% workshop / 30% lecture)
Venue: client’s office or other place chosen by the client, in Europe
Enrollment: in-house on-site course for a group of people within one company
Group size: max 10 delegates
Course language: English or Polish or both during the same training
Audience: Python developers, team leaders, architects, analysts, DevOps, R&D, testers
Audience requirements: basic Python knowledge and experience

This course is for people who already work in Python. Client very often decide for this course after observing effects of Express Introduction to Python 3 course.

This course can be extended up to 5 days.

Course Syllabus

I. Advanced Tooling

  1. Multiple Python Installations
  2. Common Caveats with Python Installation on Windows (i.e. Python not on %PATH%)
  3. IDEs (Integrated Development Environments)
  4. Overview of Most Important IDEs (PyCharm, Visual Studio Code with Python Plugin and Jupyter Notebook)
  5. Using Visual Studio Code: Program Layout, Installing Python Plugin, Accessing Terminal, Changing Default Terminal, Turning On Auto-Save etc.
  6. IPython
  7. Jupyter Notebook: Installation, Use Cases, Auto-Completion, Displaying Inline Documentation, Restarting Underlying IPython Session, Integration with Matplotlib, Support for Different Kernels, nbextensions, Table of Contents, Exporting Notebooks to HTML and Python Code etc.
  8. Version Pinning
  9. pip Package Manager and PyPi Repository
  10. Isolated Python Installations with virtualenv
  11. Anaconda Distribution
  12. conda Package Manager and Anaconda Repository
  13. Isolated Python Environments with conda
  14. Anaconda vs “Pure” Python Installation
  15. conda vs pip
  16. Python Releases
  17. Python 2 vs Python 3
  18. Main Differences between Python 2 and 3
  19. Porting Python 2 to 3
  20. Python Documentation
  21. PEP8 for Formatting Rules

II. Functions

  1. Positional and Named Arguments
  2. Returning Multiple Values
  3. Default Values
  4. Default Value Trap
  5. Lambdas
  6. Sorting by Key
  7. Global and Local Scope
  8. Global Keyword
  9. *args in Function Signature, Function Call and Other Places
  10. **kwargs in Function Signature, Function Call and Other Places
  11. Positional Only Arguments
  12. Function Annotations
  13. Introduction to Static Typing with mypy
  14. Nonlocal Scope and nonlocal Keyword
  15. callable Function
  16. Introduction to Nested Functions and Closures

III. Decorators

  1. Decorator Syntax, Definition and Usage
  2. Simple Decorators for Registering Functions
  3. Nested Functions
  4. Closures
  5. Non-parametrised Decorators Delegating to the Decorated Function
  6. Class-based Implementation of the Above
  7. Proper Argument Passing
  8. Parametrised Decorators with Three Nested Functions
  9. Class-based Implementation of the Above
  10. Decorating Methods
  11. Decorating Classes
  12. Template Method Design Pattern as one of the Use Cases
  13. Decorator Use Cases

IV. Intermediate Object Oriented Programming

We skip easier topics if the group is advanced enough.

  1. __str__ vs __repr__
  2. __str__ Method vs str() Function
  3. Classes Imitating Functions with __call__ Special Method
  4. Encapsulation – Interface vs Implementation
  5. Protected Attributes
  6. Private Attributes
  7. Read-Only @property
  8. Read-and-Write @property
  9. Introducing Encapsulation to an Existing Class without Breaking the Interface with @property
  10. Variable Annotations
  11. Dataclasses: Usage, Default Values, Default Values Trap, Default Value Factory, Fields Customisation, __post_init__
  12. Introduction to Single Inheritance
  13. Attribute Lookup Mechanism
  14. Code Reusage with Inheritance
  15. Method Overloading
  16. super()

V. Advanced Object Oriented Programming

  1. Special Methods Recap
  2. object Class
  3. defaultdict Data Structure
  4. Inheriting from Builtin Classes, i.e. Data Structures
  5. @classmethod
  6. Alternative Constructors with @classmethod
  7. @staticmethod
  8. Descriptors
  9. Bound vs Unbound Method
  10. Slots
  11. Including __dict__ in Slots
  12. Abstract Base Classes
  13. Multiple Inheritance: Fundamentals, MRO (Method Resolution Order), Diamond Problem, super() Behaviour
  14. Mixin Classes
  15. Metaclasses: type Metaclass, Writing Your Own Function-based and Class-based Metaclasses, Use Cases, Simpler Approaches

VI. Iterators

  1. Iteration Protocol
  2. Iterable vs Iterator
  3. Class-based Implementation of One-Time Iterable
  4. Class-based Implementation of Reusable Iterable

VII. Generators (only in 5 days-long version)

  1. Generators and yield Instruction
  2. Iteration over Generators
  3. Generators vs Iterators
  4. Generator-based Implementation of One-Time Iterable
  5. Generator-based Implementation of Reusable Iterable
  6. Passing Data to a Generator
  7. Introduction to Coroutines

VIII. Advanced Code Organisation

  1. Modules
  2. Three Import Styles
  3. Renaming in Imports
  4. Import vs Execution and __name__ Variable
  5. Module Search Order
  6. sys.path List
  7. PYTHONPATH Environment Variable
  8. Packages
  9. Packages Initialisation
  10. __init__ Files
  11. Relative Imports

IX. Packaging and Publishing Python Code (only in 5 days long version)

  1. requirements.txt
  3. PyPI
  4. Wheel Format
  5. Packaging Python Projects with setuptools and Generating Distribution Archives
  6. Semantic Versioning
  7. twine for Automating Publishing Python Packages

X. Testing with pytest

  1. What Testing is for?
  2. Overview of Available Frameworks (unittest vs pytest vs doctest)
  3. pytest Fundamentals
  4. Launching Tests
  5. Fail Fast Mode (-x Switch)
  6. Printing Local Variables (-l Switch)
  7. Quiet Output (-q Switch)
  8. Testing both Happy and Sad Paths
  9. Testing Edge and Corner Cases
  10. Fixtures
  11. Unique Temporary Directory for Test Run
  12. Fixtures Scopes – Sharing Fixture Instances between Tests
  13. Fixture Dependencies
  14. Fixture Finalisation
  15. Grouping Tests into Classes
  16. Skipping Tests

XI. Parallel Programming (only in 5 days long version)

  1. threading Module
  2. Creating, Starting and Joining Threads
  3. Producent and Consument Pattern
  4. Communication via Queues
  5. Daemon Threads
  6. Proper Threads Starting and Joining
  7. concurrent.futures Module
  9. pool.submit
  10. Global Interpreter Lock
  11. Parallelisation of IO Operations vs Computations
  12. ThreadPoolExecutor vs ProcessPoolExecutor
  13. Measuring Time Execution
  14. Debugging Multithreaded Programs in PyCharm

XII. Regular Expressions (only in 5 days long version)

  1. Idea of Regular Expressions
  2. Limitations
  3. re Module
  4. vs re.match()
  5. re.findall()
  6. Pattern Compilation
  7. Making Long Patterns more Readable with re.VERBOSE
  8. Extracting Data with Unnamed Groups and Named Groups
  9. Matching to the Beginning and End of String (^ and $)
  10. Optional Elements (?), One-or-More Repetition (*) and Zero-One-or-More Repetition (*)
  11. Advanced Repetition with {}, {n,}, {,n} and {n,m} Syntax
  12. Alternative with [] and (a|b) Syntaxes
  13. Character Groups with [a-z]
  14. Negation with [^]
  15. Character Classes: \d, \D, \s, \S etc.
  16. Escaping
  17. Syntax Cheat Sheet
  18. Processing Files with Regular Expressions

XIII. Using and Creating REST APIs (only in 5 days long version)

  1. Recap of JSON, JSON Data Types, Loading and Dumping JSON in Python
  2. Using Postman for Accessing Web APIs
  3. YAML Format
  4. Loading and Dumping YAML Format
  5. JSON Schema
  6. Validation with jsonschema
  7. Loading JSON to Your Own Classes with dataclasses-jsonschema
  8. Flask Web Application Structure
  9. Starting and Stopping Flask Development Server
  10. flask_restful Library

XIV. Miscellaneous (only in 5 days long version)

  1. Persistence with Pickle
  2. Working with Files and Directories
  3. Launching and Controlling Subprocesses in a Blocking Way
  4. Launching and Controlling Subprocesses in a non-blocking Way
  5. Reading and Writing CSV Files with builtin csv Module
  6. Reading and Writing CSV and Excel Files with pandas

Benefits for the Sponsor

As the course sponsor or HR you get:

  1. Analysis of the needs and my help to choose or design a great course during a phone call with the sponsor, HR, team leader or/and course delegates. On top of that, we ask delegates on the very first day what their needs are, to make even better usage of the course time.
  2. Course customisation to your needs.
  3. Guarantee that the course is conducted by an expert that worked for Google.
  4. Course evaluation as an electronic form at the end of the last course day. The evaluation results are sent to interested people (most of often they’re course sponsor and HR).
  5. Simple communication – you can contact the trainer directly by phone or email.
  6. Easy buying procedure – one call or email is enough to get offer and to book a date. I don’t do overbooking. The course is confirmed once you send the Purchase Order.
  7. Friendly business partner – as a rule, I treat all my clients like friends. I don’t build walls, I’m not pretending to be a huge training company and I write in first person.

Clients very often decide to order other training (including dedicated courses) after observing positive results of this course.

Benefits for Delegates

Delegates will benefit because of:

  1. Seven hours course every day (including breaks)
  2. Consultations after every course day.
  3. Support after the course, via email and phone.
  4. Setup instruction before the course to save time at the beginning of the course. I’m happy to help you via email, phone or Skype, etc. in case of any questions or issues.
  5. Course materials consisting of code snippets, comments, exercises and solutions. The entire courseware is a single web page which make it very easy to lookup something there. Courseware is available online during and after the training. Delegates can download it to use it offline. Courseware can be updated during the course in real time, so that we can include comments or entire new sections suggested by delegates.
  6. Environment ready to use after the course – we don’t use virtual machines. Instead, we install everything on delegates machines, so that they can reuse the same setup after the course.


Below you can find some references.

Very inspiring training. I really appreciate the way Chris managed to walk us through the complex world of machine learning using Python. Good course materials updated real time. Highly recommend.

Krzysztof Gębal
Finance Director at DNB Bank Polska S.A.

Well prepared training and reasonably passed knowledge, thanks to which we develop better services.

Arkadiusz Baraniecki
Infrastructure Team Manager at

Chris recently taught a four day class on Machine Learning with Python four our team. The class was very good with the right balance of theory and practice. I cannot think of a better way to give a four day class about such an extensive topic.

Nicolas Leveroni
Head of Krakow Product Control Analytics at HSBC

You can read more references here.