Python

The language everything else is built on. Variables to clean, tested, well-structured code. 42 modules of 10 minutes each, with questions that check your answers in the browser.

Start the track

Foundations

• 1. Your first program: print, comments, and running codeFree
  What a program is, how Python runs it line by line, and your first tools: print() and comments.
• 2. Variables and basic data typesFree
  Give values names with variables, and meet Python's four everyday types: str, int, float and bool.
• 3. Working with strings and f-stringsFree
  Build, combine, index and slice text, and use f-strings to drop values neatly into sentences.
• 4. String methods: split, join, strip, replaceFree
  Clean and reshape messy text with Python's built-in string methods, the everyday tools of data cleaning.
• 5. Numbers, math operators, and type conversionFree
  Do arithmetic with ints and floats, understand the three kinds of division, and convert between text and numbers safely.
• 6. Booleans and comparison operatorsFree
  Ask yes/no questions in code with comparisons, combine them with and, or and not, and learn what Python treats as true.
• 7. Lists, indexing, and slicingFree
  Store many values in one ordered list, read items by position, take slices, and change lists with their methods.
• 8. Tuples and when to use themFree
  Fixed, unchangeable groups of values: how tuples differ from lists, unpacking, and why immutability is a feature.
• 9. DictionariesPro
  Look values up by name instead of position with key-value pairs, the data structure behind JSON, APIs and most real data.
• 10. SetsPro
  Collections of unique values: remove duplicates instantly, test membership fast, and compare groups with union, intersection and difference.
• 11. if / elif / elsePro
  Make your code choose what to do: run blocks only when a condition is true, handle several cases in order, and keep decisions readable.
• 12. for loops and rangePro
  Repeat work for every item in a collection, count with range(), and learn the accumulate, count and filter patterns behind most data code.
• 13. while loops, break, continuePro
  Loop until a condition changes, stop early with break, skip items with continue, and avoid the infinite loop.
• 14. Writing functions (def, parameters, return)Pro
  Package logic into named, reusable functions with parameters and return values, the single most important tool for clean code.

Intermediate

• 15. Default, keyword, *args and **kwargsPro
  Make functions flexible with default values, clear with keyword arguments, and open-ended with *args and **kwargs.
• 16. Variable scope (local vs global)Pro
  Where a variable lives and who can see it: local and global scope, the LEGB rule, and why functions should talk through parameters and return values.
• 17. List comprehensionsPro
  Build lists in one readable line by transforming and filtering another collection, and know when a plain loop is clearer.
• 18. Dict and set comprehensionsPro
  Build dictionaries and sets in one expression: lookups, inversions, filters and quick summaries of your data.
• 19. Handling errors with try / except / finallyPro
  Catch the errors you expect, let the ones you don't surface, and clean up reliably, so one bad row doesn't crash a whole report.
• 20. Raising and creating custom exceptionsPro
  Stop bad data at the door with raise, write clear error messages, and define your own exception types for your domain.
• 21. Modules, imports, and the standard libraryPro
  Split code across files, import exactly what you need, and use Python's built-in "batteries" before reaching for anything else.
• 22. Reading and writing files (with open)Pro
  Read text files line by line, write and append safely with the with statement, and handle paths and encodings properly.
• 23. Working with JSON and CSV filesPro
  Read and write the two formats every analyst lives in: CSV with csv.DictReader/DictWriter, and JSON with json.load/dump.
• 24. Dates and times with datetimePro
  Create, parse, format and do arithmetic with dates and times, the backbone of every time-based report.

Advanced

• 25. Iterators and the iteration protocolPro
  What really happens inside a for loop: iterables, iterators, iter() and next(), and why some things can only be looped over once.
• 26. Generators and yieldPro
  Write your own lazy iterators with yield, build memory-friendly data pipelines, and process files far bigger than your RAM.
• 27. lambda, map, filter, and sorted with keysPro
  Treat functions as values, write tiny inline functions with lambda, and sort or pick the best item by any rule you like.
• 28. DecoratorsPro
  Wrap functions with extra behaviour like timing, logging, caching and validation, without touching their code, using the @ syntax.
• 29. Classes and objects (OOP intro)Pro
  Bundle data and the functions that work on it into your own types, and understand classes, objects and why OOP exists.
• 30. __init__, attributes, instance vs classPro
  Set objects up correctly with __init__, validate at creation, and understand the difference between instance attributes and class attributes.
• 31. Methods, self, and propertiesPro
  Instance, class and static methods, what self really is, and properties that look like attributes but run code.
• 32. Inheritance and compositionPro
  Reuse code by building specialised classes on general ones, call the parent with super(), and know when to compose objects instead.
• 33. Dunder methods (__str__, __repr__, __eq__)Pro
  Make your classes behave like built-in types: readable printing, equality, sorting, len(), and arithmetic, all through special "dunder" methods.
• 34. Type hints and basic typingPro
  Annotate what your functions expect and return, so editors and tools catch mistakes before you run the code.

Expert

• 35. Regular expressionsPro
  Find, extract, validate and clean text by pattern: phone numbers, prices, order IDs and dates hiding in messy strings.
• 36. Custom context managers (with)Pro
  Guarantee setup and cleanup with the with statement, and write your own context managers with classes or contextlib.
• 37. DataclassesPro
  Define data-holding classes in a few lines, with __init__, __repr__ and __eq__ written for you, plus defaults, validation, immutability and ordering.
• 38. Logging and debuggingPro
  Replace stray print statements with proper logging levels, and find bugs systematically with tracebacks, assertions and a debugger.
• 39. Virtual environments and dependency managementPro
  Give every project its own isolated set of packages, record exact versions in requirements files, and make your code run the same on every machine.
• 40. Structuring a project into packages and modulesPro
  Organise a growing codebase into packages with __init__.py, choose between absolute and relative imports, and lay out a professional project folder.
• 41. Unit testing with pytestPro
  Write small automated tests that prove your functions work, catch regressions instantly, and let you change code without fear.
• 42. Clean code: naming, small functions, DRY, refactoringPro
  Turn working code into code that's easy to read, change and trust, with the habits that separate a script from professional software.

Track project

• Python Project: Toko Kita's order toolsPro
  Four graded tasks that use the whole Python track on one shop's data. Clean messy form input, turn a CSV export into a JSON report, model the stockroom with a class, and write tests that catch real bugs.

Pro modules unlock with one payment of Rp 149.000, yours to keep.