Python from scratch: what to learn and in what order

Month one: language fundamentals

Variables and data types. Numbers, strings, booleans. What mutable and immutable mean — that question comes up at almost every interview.

Lists, dictionaries, sets, tuples. Your main working tools. Dictionaries especially: half of all problems are solved by realising the data belongs in one.

Conditions and loops. Plus comprehensions — the compact form you'll meet in anyone's code.

Functions. Arguments, defaults, return values, scope.

Working with files. Reading, writing, context managers.

Error handling. How to catch exceptions and why silently swallowing all of them is wrong.

Goal for the month: write a hundred- to two-hundred-line program without constant reference to a textbook.

Month two: how it's written in practice

Modules and packages. How to split code across files and import it.

Classes. At a basic level: why they exist, how to create one, what methods are. Deep inheritance study isn't needed at the start.

The standard library. Dates, the file system, JSON, command-line arguments. A huge share of problems are solved by what ships with the language.

Virtual environments and installing packages. Essential, or within a month you'll have a mess of libraries.

Network requests. Fetching data from someone's server and parsing the response.

Month three: application

Pick one direction and build a project in it:

• A service. A web framework, a database, deployment.
• Automation. Scripts, parsing files, spreadsheets, mailing.
• Data. Analysis libraries, reading large selections, simple charts.

Don't take all three: one direction taken to a working result beats three skimmed.

What can wait

• Asynchrony. You'll need it, but not in the first months.
• Decorators and metaprogramming. Knowing they exist is enough.
• Multiple inheritance and the finer points of the object model.
• Type hints. Useful, not critical at entry.

Where people get stuck

Classes. Many can't see why they'd need them when functions work. What helps isn't theory but a problem where their absence becomes awkward.

Imports. Path errors and circular imports are a classic. Cured by understanding how packages work, not by memorisation.

Virtual environments. They feel like needless complexity until you install two versions of one library and everything breaks.

Checking the month wasn't wasted

Write a program that reads a file, processes the data, writes the result to another file and prints a summary. Unaided, with error handling.

If it works, move on. If it doesn't, you're short on practice, not theory.