Python

29 courses, 508 lessons. A real Kali Linux lab in the browser.

Python fundamentals (Level 101, 23 lessons): Variables, types, conditions and loops.
Data structures and functions (Level 101, 17 lessons): Lists, dictionaries, sets and functions.
Python first exercises (Level 101, 16 lessons): You reinforce each basic topic with short, real problems and solve an unguided task on your own at the end of every section.
Files, modules and errors (Level 201, 19 lessons): Reading and writing files, modules, packages and error handling.
Python libraries: pip, requests, argparse (Level 201, 16 lessons): pip, virtual environments and the useful parts of the standard library.
Python practice (Level 201, 16 lessons): Practice with small, real problems.
Object-oriented programming with Python (Level 201, 16 lessons): You write organised, reusable Python code using classes, inheritance, special methods and decorators.
Python iterators, generators and functional tools (Level 201, 17 lessons): You process large data without filling memory, in short readable code, using the iteration protocol, generators, itertools and functools.
Text processing and regular expressions with Python (Level 201, 17 lessons): You reliably parse, transform and validate logs, reports and free text with string methods, regular expressions and Unicode.
File formats with Python: CSV, JSON, YAML, XML, SQLite (Level 201, 17 lessons): You read, write and convert the data formats you meet at work and handle archives and binary files safely.
Testing in Python: pytest, mocks and coverage (Level 201, 18 lessons): You write fast, readable tests with pytest, isolate external dependencies with mocks, measure coverage and catch bugs with tests first.
Debugging and logging in Python (Level 201, 17 lessons): You read tracebacks, step through code with pdb, produce structured, leak-free logs with the logging module and diagnose problems in production.
Command-line tools with Python (Level 201, 17 lessons): You write installable command-line tools with subcommands, configuration, coloured output and correct exit codes.
Concurrency in Python: threads, processes and asyncio (Level 301, 19 lessons): You speed up waiting work with threads and asyncio and heavy computation with processes, and find and prevent bugs such as races and deadlocks.
Network programming with Python: sockets, HTTP, TLS (Level 301, 20 lessons): You write clients and servers with sockets, understand HTTP and TLS from the ground up and build network code that handles timeouts and errors; you only work against your own lab targets.
Building web APIs with Python: Flask and FastAPI (Level 301, 18 lessons): You write validated, authenticated and tested JSON APIs with Flask and FastAPI and avoid common web security mistakes from the start.
Database programming with Python: sqlite3 and SQLAlchemy (Level 301, 18 lessons): You connect to databases safely from Python and build solid data layers with parameterised queries, transactions, an ORM and schema migrations.
System automation with Python (Level 301, 18 lessons): You hand server chores to Python and write repeatable, safe scripts that manage processes, files, SSH connections and scheduled jobs.
Python code quality: type checking, formatting and project tooling (Level 301, 19 lessons): You check type hints with mypy, keep code consistent with ruff and black, and set up maintainable projects with pre-commit and modern project tooling.
Python intermediate challenges (Level 301, 16 lessons): You solve realistic workplace challenges without guidance, combining files, networking, concurrency and testing.
Secure Python coding: common mistakes (Level 401, 21 lessons): You find the most common security mistakes of Python projects in your own lab application, understand why they happen, fix them and prevent them coming back with tests.
Advanced Python: the depths of the language (Level 401, 17 lessons): By understanding advanced features such as descriptors, metaclasses, context managers and the import system, you see how frameworks work and write your own tools.
Advanced asyncio: highly concurrent services (Level 401, 17 lessons): You understand asyncio from the inside and write services that handle thousands of connections with structured concurrency, backpressure and graceful shutdown.
Python performance: measure, speed up, extend with C (Level 401, 18 lessons): You find slow code by measuring, not guessing, and speed up Python programs with algorithms, data structures, caching and C extensions.
Design and architecture in Python (Level 401, 17 lessons): You organise growing Python projects with patterns, layers and dependency management and build code bases that are easy to test and change.
Python advanced challenges (Level 401, 15 lessons): You solve demanding challenges without guidance that test your performance, concurrency, parsing and secure coding skills.
Inside CPython: bytecode, memory and the interpreter (Level 501, 17 lessons): Through your own experiments you see how Python code turns into bytecode, how objects live in memory and how the interpreter runs.
Binary data and protocol parsing with Python (Level 501, 16 lessons): You think at the byte level, parse binary file formats and network protocols safely and harden your own parser with fuzzing.
Python project workshop (Level 501, 16 lessons): You build four large projects that come from real needs, end to end, with design, tests and documentation.

Projects

A small command-line tool that validates input: You write a small Python command-line tool that checks what the user types and gives a clear message when it is wrong, then test it with sample inputs.
Build a stock summary from a warehouse count list: You write a Python program that processes Karaçam Mobilya's warehouse count list with lists and dictionaries, and produce a summary showing totals per product and items running low.
Generate report cards from student marks: You write functions for Gelincik Okulları that take student marks and work out the average and pass status, and produce a readable report card summary for each student.
Collect data from an API and build a catalogue: You write a Python program that pulls data from an API, builds a tidy catalogue file from it, and handles bad responses along the way.
Generate personalised text from a template: You generate a personalised message for each person from a text template and separately report the records that have missing information.
A security awareness quiz (replayable): You build a Python quiz that asks employees security awareness questions, scores them, and can be played again.
A daily digest from delivery logs with regular expressions: You write a Python tool that parses Kuzeyyıldızı Kargo's mixed-format delivery logs with regular expressions, and produce a daily digest file showing late and failed deliveries.
Merge CSV, JSON and YAML inventories into one SQLite database: You write a command-line tool that reads the inventory files Mercanköşk Otelcilik's branches send in different formats, merge them into a single SQLite database, and report the broken rows.
A class-based discount engine with pytest tests: You write a discount module that models Turnalı Perakende's campaign rules with classes, test it with pytest, and deliver the coverage report.
Debug a broken invoice script and make it log properly: You examine Ayçiçeği Gıda's invoice script, which produces wrong totals, with the debugger, fix the bugs, make it process large files with generators, and add levelled logging.
Background jobs that finish after a failure: You build a Python setup where background jobs are retried after errors and eventually finish, without any job being done twice.
Collect server health over SSH and build an HTML report: You write a Python tool that connects to Demirsu Enerji's lab servers over SSH and gathers disk, memory and service status concurrently, turn the results into an HTML report with a template, and schedule it with cron.
An appointment API with FastAPI and SQLAlchemy: You write a FastAPI service for Lavinya Klinikleri that creates, lists and cancels appointments, store the data with SQLAlchemy, validate the input, and test the endpoints.
A TLS certificate expiry checker: You write a type-checked Python tool that connects to Yakamoz Telekom's own services in the lab and checks their TLS certificates' expiry dates and basic settings, and report the ones expiring soon.
Secure code review and fix of a permit application: You review Selvikent Belediyesi's permit application written in Python with bandit, semgrep and pip-audit, fix the insecure coding mistakes you find, and report the before and after state.
An asyncio telemetry ingest service that holds under load: You build an asyncio service that accepts Mavikaya Lojistik's vehicle telemetry, add backpressure, timeouts and graceful shutdown, and show with measurements that it loses no data under load.
Profile and speed up a slow report generator: You profile Ilgıntepe Tekstil's production report script, which takes minutes to run, remove the bottlenecks, and prove with measurements that it produces the same output in far less time.
A binary telemetry protocol parser with fuzz testing: You write a Python parser for the binary protocol spoken by Lodoskaya Denizcilik's ship telemetry devices, show with fuzz testing that it withstands malformed packets, and prepare a protocol note.