Skip to content
Development PY—01

Python from scratch

A course for people starting from zero: exactly as much theory as you need to write the next line of code. Across twelve modules we go from installing Python to a program that fetches data from the internet on its own, parses JSON and puts the result in a file.

12 modules32 lessons
24 hoursof video and practice
From scratchrequirements
Foreveraccess and updates
Format
€42 one-off payment
Place the order Open the programme
Payment by card or through PayPal
Access opens immediately after payment
14-day refund, if you have not started watching
Outcome

What you will be able to do

Write and run programs on your own computer
Break a task down into conditions, loops and functions
Store data in lists, dictionaries and files
Find the cause of an error from the text in the terminal
Fetch data from someone else's API and parse JSON
Set a project up with a virtual environment and a list of dependencies
Programme

12 modules, one project

Press a module to open its lessons

01 Installation, running code and your first program3 lessons · 1 h 45 minOpen

We install Python and an editor, work out how a script file differs from the interactive console, and run the first program from the terminal. By the end of the module the code already works.

Installing Python and a code editor: Windows, macOS, Linux
The terminal, the interactive console and running a .py file
Your first program: print, comments and reading an error message
02 Variables, types and input3 lessons · 2 h 05 min

Numbers, strings, booleans and None: what you can do with them and why Python sometimes refuses to add different types together. We learn to read user input and convert it to the type we need.

Variables and names: what happens on assignment
Numbers, strings, bool and None: operations and type conversion
input, printing the result and your first calculator
03 Strings2 lessons · 1 h 44 min

Text is the most common data type early on. We cover indexes and slices, search and replace methods, f-strings, and then take a line from a real file apart.

Indexes, slices and the immutability of strings
String methods, f-strings and splitting text into parts
04 Conditions and loops3 lessons · 2 h 16 min

The program starts making decisions and repeating actions. Comparisons, if, elif and else, while and for, break and continue — on examples where you can see the behaviour change.

Comparisons, logical operators and the if/elif/else construct
The while loop: repeating until a condition and guarding against infinity
The for loop, range and iteration: practice on an order list
05 Lists, dictionaries and sets3 lessons · 2 h 18 min

The core data structures and the main question: which one fits the task. Lists and tuples keep order, dictionaries give lookup by key, sets take care of uniqueness and comparing collections.

Lists and tuples: appending, slices, sorting, iteration
Dictionaries: keys, values and finding data without a loop
Sets, nested structures and choosing a structure for the task
06 Functions3 lessons · 2 h 12 min

How to stop copying the same piece of code. Arguments, default values, returning a result and scope — plus the rule that tells you when code should move into a function.

Your own function: parameters, arguments and return
Default values, keyword arguments and scope
Practice: splitting a finished script into functions
07 Errors and debugging2 lessons · 1 h 38 min

An error is not a failure but a message with the address of the problem. We learn to read a traceback, catch exceptions with try and except, and check data that comes from outside.

Reading a traceback: the error type, the line and the cause
try, except, finally, your own checks and printing for debugging
08 Working with files3 lessons · 2 h 08 min

Data has to survive the program closing. We open files with with, read and write text, walk through folders and parse a CSV table from a real export.

Opening a file with with, reading and writing text
Paths, encodings and walking folders with pathlib
CSV: reading an export, totalling it and saving a report
09 Modules, packages and the virtual environment3 lessons · 2 h 02 min

The code outgrows one file. We split it into modules, use the standard library, create a virtual environment and pin the dependencies so the project runs on another computer too.

Imports, your own modules and the standard library
Packages and the structure of a multi-file project
venv, pip and requirements.txt: the project's dependencies
10 Classes: when you need them2 lessons · 1 h 34 min

The minimum of OOP without the academia. We show the tasks where a dictionary and functions stop being enough, rewrite that code as a class with methods, and separately look at the cases where a class is not needed.

Class, object, __init__ and methods on a clear example
Rewriting functions as a class — and when not to
11 Third-party libraries, HTTP and JSON3 lessons · 2 h 20 min

We install a third-party library and talk to someone else's service: the request, parameters, response codes, parsing JSON into dictionaries and lists. This is where automation and work with any API begins.

Installing a library and reading its documentation
An HTTP request: GET, parameters, headers and response codes
JSON: parsing the response, nested data and saving to a file
12 The final project2 lessons · 1 h 58 min

We put it all together: the program fetches data from an open API, processes it and saves a report to a file. We go through the project structure and what to learn next — Telegram bots and automation, for example.

The project: from stating the task to a working script
Error handling, the README, running it on another computer and what comes next
Materials

What you get

32 lessons with transcripts

Videos with timecodes and a written version: the code from a lesson can be copied instead of retyped off the screen.

Exercises after every lesson

Small tasks with a finished solution: you write the code yourself and then compare your version with the one explained.

Files and data for practice

Exports, text files and sample service responses — the same data as in the lessons, so your result matches.

An installation and environment cheat sheet

A step-by-step guide for Windows, macOS and Linux: installing Python, the virtual environment, pip and running the project from the terminal.

Alina Mihai
Course author

Alina Mihai

Teaches the «Python and backend» direction at Forma. The full list of their courses is on their page.

All courses by this author

The whole first module is open

Watch the lessons of the first module and the first task. If the format does not suit you, you have lost nothing.