Python

The favorite language of beginners… and pros

Readable, versatile and everywhere - scripts, data, web, automation. From variables to tests, through OOP, generators and async: a complete track from your first print() to professional practices.

Foundations

Beginner - the basics, step by step

• Install Python and write your first programYou install Python, discover the REPL, and print your first message with print.
• Variables and basic typesYou store values in variables and work with the int, float, str, and bool types.
• Conditions: if, elif, elseYou learn to make your programs take decisions with if, elif, else, and logical operators.
• Loops: for, while, break, and continueYou repeat instructions with for and while, and control your loops with range, break, and continue.
• Lists and dictionariesYou create, read, modify, and iterate over lists and dictionaries to organize your data.

Progression

Intermediate - build real things

• Functions: def, parameters, return and scopeStructure your code into reusable functions, master default values and understand variable scope.
• Strings in depth: slicing, f-strings, methodsExtract, format and clean text like in a real project thanks to slicing, f-strings and string methods.
• List and dictionary comprehensionsReplace your building loops with expressive comprehensions, to transform, filter and reindex your data.
• Files and modules: with, import, organizationRead and write files cleanly with with, exchange JSON and organize your code into importable modules.
• Errors and exceptions: try, except, raiseCatch predictable failures with try/except/else/finally and raise your own exceptions to signal invalid data.

Advanced

Proficient - advanced patterns and performance

• OOP: classes, __init__, methods and inheritanceStructure your code with well-designed classes: initialization, instance or class attributes, inheritance and its trade-offs.
• Advanced structures: tuples, sets and collectionsPick the structure that fits each need: immutable tuples, sets for O(1) membership tests, Counter and defaultdict for recurring patterns.
• Iterators and generators: yield and pipelinesMaster the iteration protocol and generators to process data streams lazily, at constant memory.
• Decorators and higher-order functionsLeverage functions as first-class objects to write robust, parameterizable and transparent decorators.
• Virtual environments, pip and a clean projectIsolate each project in its own venv, pin the dependencies and adopt a reproducible project structure.

Mastery

Expert - architecture, internals and edge cases

• Type hints and dataclasses: typing modern Python seriouslyUnderstand what annotations actually do at runtime, and get the most out of dataclasses with frozen, slots and default_factory.
• Protocols and special methods: __repr__, __eq__, context managersMaster Python's object model: the __eq__/__hash__ contract, the NotImplemented value, context managers and structural typing with Protocol.
• Async with asyncio: coroutines, await, gatherUnderstand asyncio's cooperative concurrency: lazy coroutines, suspension points, gather, TaskGroup and the pitfalls of blocking calls.
• Performance: profiling, GIL, generators vs lists, memory pitfallsMeasure before you optimize: timeit and cProfile, what the GIL really blocks, the frugality of generators and the memory pitfalls of strings and slices.
• Testing with pytest: fixtures, parametrization, best practicesStructure robust tests with pytest: fixture injection, yield-based teardown, table-driven parametrization and the pitfalls of broad scopes.