Python Programming Tutorials

How Python code is laid out, and why indentation is not optional.

Python uses indentation where most languages use curly braces, so the shape of your code is the code. That feels strict for about a day and then becomes the reason Python is readable. This module is short, but getting it wrong produces the IndentationError that stops most first programs.

• Indentation instead of curly braces
• Statements, expressions and blocks
• Single-line and block comments
• Naming things the way Python expects

The handful of types almost every program is built from.

Python works out the type for you, which is convenient right up to the moment you try to add a number to a string and get a TypeError. Knowing which type you are holding, and how to convert between them deliberately, prevents most beginner bugs. There are only a few types to learn and you will use all of them constantly.

• Integers, floats, strings and booleans
• Checking a type with type()
• Converting between types on purpose
• Where None fits in

Text handling, which is most of what real programs do.

Almost everything arriving from a file, a form or an API is text, so string handling is not a side topic. Slicing, splitting, joining and formatting come up in every project, and f-strings in particular will appear in nearly every line you write that produces output.

• Slicing, indexing and looping over text
• f-strings and formatting numbers
• Splitting, joining and replacing
• Searching for substrings

Arithmetic, comparison and logic, including the ones that surprise people.

Most operators do exactly what school maths taught you, with two exceptions worth meeting early: / always produces a float even when both sides are whole numbers, and == compares values while is compares identity. Getting those two straight now saves a confusing hour later.

• Arithmetic, and why / always gives a float
• Comparison operators and chaining them
• and, or, not
• Membership with in

Making decisions and repeating work, the two halves of control flow.

This is the module where you stop writing scripts that run top to bottom and start writing programs that react. Conditionals choose a path, loops repeat work, and between them they cover most of what any program does. Give this one a full week even if it looks short, because everything afterwards assumes it.

• if, elif and else
• for loops and range()
• while loops and when they hang
• break, continue and pass

Packaging work so you write it once and call it everywhere.

A function turns a block of code into something with a name you can call from anywhere, which is where programs stop being long and start being organised. Parameters, return values and default arguments are the core, and understanding what a function can and cannot see from outside itself is the concept that takes longest to settle.

• Defining, calling and returning
• Default arguments and keyword arguments
• *args and **kwargs
• Lambda functions and where they belong

The workhorse container, and the one you will reach for most.

Lists hold an ordered, changeable collection of anything, and they are the container you will use more than all the others combined. Slicing and comprehensions are the two features worth real practice, because a comprehension replaces four lines of loop with one readable line once it clicks.

• Adding, removing and slicing
• Sorting and reversing
• List comprehensions
• Copying without sharing the same list

Key-value data, which is how most real information is shaped.

A dictionary stores values against keys rather than positions, which matches how real data is actually organised: a user has a name and an email, not a first and second thing. Every JSON response you ever parse becomes a dictionary, so this module pays for itself the first time you call an API.

• Adding, updating and removing keys
• Looping over keys, values and items
• Nested dictionaries
• Handling a missing key safely

The two containers people skip, and then need.

A tuple is a list that cannot change, which makes it safe to pass around and usable as a dictionary key. A set holds unique items and answers is this in here? almost instantly, however large it gets. Neither is exotic, and knowing when to use one instead of a list is a genuine mark of progress.

• Tuples: fixed, hashable, unpackable
• Sets: uniqueness and fast membership
• Set maths: union, intersection, difference
• Choosing between list, tuple, set and dict

Python’s array types, and the moment you should switch to NumPy.

Python has an array module, but in practice a list covers most needs until the data gets large or numeric, at which point NumPy takes over entirely. The useful outcome of this module is knowing which of the three you are looking at in someone else’s code and why they chose it.

• Lists versus the array module
• When a list stops being fast enough
• Two-dimensional data
• Where NumPy takes over

Reading and writing real files instead of hard-coded values.

This is the module where your programs start working on real data rather than values you typed in yourself. Always open files with with, which closes them even if something fails halfway, and expect encoding to cause at least one confusing error the first time you read a file somebody else produced.

• Opening files with with
• Reading whole files and line by line
• Writing and appending
• CSV and text, and why encoding matters

Programs that fail usefully instead of crashing.

Real input is missing, malformed or absent, and a program that stops dead on the first surprise is not finished. Catching the specific exception you expected is the skill here; a bare except that swallows everything hides the bug you needed to see. Learning to read a traceback from the bottom up is worth the module on its own.

• try, except, else, finally
• Catching the right exception, not all of them
• Raising your own
• Reading a traceback properly

Classes and objects, which is where Python code starts to scale.

A class bundles data and the functions that work on it into one thing you can create many of. It is the concept beginners find hardest and the one that makes larger programs possible, so take two weeks rather than one. Once classes click, a great deal of other people’s code stops looking mysterious.

• Classes, objects, attributes and self
• __init__ and constructors
• Inheritance and super()
• Encapsulation and the four pillars