3-Level Ladder

Everything in Python is a value with a type. The main starter types are int for whole numbers (42), float for decimals (3.5), str for text ("hello"), and bool for True and False. A variable is just a name you attach to a value with =, as in price = 9.99. The name goes on the left, the value on the right; nothing is copied or reserved in advance.

You can always ask Python what it is holding. type(price) reports <class 'float'>, and print(price) shows the value. Types matter because they decide what operations mean: 3 * 2 is 6, but "ab" * 2 is "abab". When you mix incompatible types, like "Total: " + 9.99, Python raises a TypeError instead of guessing, which is a feature, not an annoyance.

input() always hands you a string, even when the user types digits. So age = input("Age: ") followed by age + 1 fails. Convert first: age = int(input("Age: ")). Use int() for whole numbers, float() for decimals, and str() to turn a number back into text.

To build readable output, use an f-string: put an f before the quotes and drop expressions in braces. name = "Ana"; total = 12.5; print(f"{name} owes ${total:.2f}") prints Ana owes $12.50. The :.2f part rounds the display to two decimal places, which is exactly what you want for money on screen.

An if statement runs a block only when a condition is True. Conditions come from comparisons (==, !=, <, >=) and can be combined with and, or, and not. Note the difference between = (assign) and == (compare); mixing them up is the classic first-week bug.

Indentation is the syntax. The lines under an if must be indented consistently, four spaces by convention, and Python uses that indentation to decide what belongs to the block. A chain runs top to bottom and stops at the first match: if score >= 90: grade = "A" then elif score >= 80: grade = "B" then else: grade = "C". Because it stops at the first true branch, order your conditions from strictest to loosest.

A list holds an ordered, changeable sequence: temps = [18, 22, 19, 25]. You append to grow it, index to read one item, and slice to take a chunk (temps[1:3] gives [22, 19]). The natural way to visit every item is for t in temps, which hands you the values directly. Reach for range only when you truly need positions, and use enumerate(temps) when you need both index and value at once.

One rule saves a lot of pain: do not add to or delete from a list while you are looping over it, because the loop's internal position gets out of sync and items get skipped. Build a new list instead, or loop over a copy with for t in temps[:]. Handy helpers you should know by name are len, sum, min, max, sorted, and the in operator for membership tests like if 22 in temps.

A dictionary maps keys to values: stock = {"apples": 12, "pears": 3}. Lookup by key is direct and fast no matter how big the dictionary gets, which is why dictionaries beat lists whenever your question is "what is the value for this name?" Assigning to a missing key creates it, so stock["plums"] = 7 adds an entry.

Reading a missing key raises a KeyError, so use stock.get("plums", 0) when absence is normal and you want a default. Loop with for name, count in stock.items() to get pairs, or for name in stock to get keys. Keys must be immutable, which means strings, numbers, and tuples work but lists do not. A counting loop looks like counts[word] = counts.get(word, 0) + 1, and that one line is the backbone of most tallying code you will write.

A function turns a block of code into a named tool: def average(numbers): return sum(numbers) / len(numbers). Parameters are the names in the definition, arguments are the values you pass in, and return hands a result back to the caller. Prefer returning values over printing inside the function, because a returned value can be tested, stored, and reused, while a print can only be watched.

Names created inside a function are local and vanish when the function ends, so a function cannot accidentally clobber your outer variables unless you go out of your way with global. Default values make functions flexible, as in def greet(name, greeting="Hello"). One caution: never use a mutable default like def add(item, bag=[]), because that list is created once and shared across every call. Use bag=None and create a fresh list inside instead.

Open files with a with block: with open("sales.csv", encoding="utf-8") as f: for line in f: ... The with statement closes the file automatically even if an error is raised mid-loop, and looping over the file object reads one line at a time instead of loading a huge file into memory. Each line keeps its trailing newline, so call line.rstrip("\n") before splitting. To write, open with mode "w" to replace or "a" to append.

Handle errors where you can actually do something about them. Wrap the risky call in try and catch specific exceptions: except FileNotFoundError to report a missing path, except ValueError to skip a row where int(field) fails. A bare except swallows typos and interrupts along with real problems, so name the exception you expect. Use raise to re-throw when the caller is the one who should decide, and else or finally when you need cleanup that always runs.

A comprehension builds a collection in one expression: squares = [n * n for n in range(10) if n % 2 == 0] gives the even squares. The same shape works for dictionaries, {name: len(name) for name in names}, and sets. Comprehensions are clearer than a loop plus append when the body is a single transformation, and harder to read when you start nesting three levels, at which point a plain loop wins.

Swap the brackets for parentheses and you get a generator expression, which produces values one at a time instead of building the whole list. sum(len(line) for line in f) never holds the file in memory. Writing your own generator means using yield inside a function: each yield hands back a value and pauses until the caller asks for the next one. This is how you process a million-row log on a laptop, and why for loops, sum, any, and max can all consume the same lazy stream.

Every .py file is a module. import statistics pulls in the standard library, from pathlib import Path pulls in one name, and your own file called tools.py becomes import tools for a script sitting beside it. Guard the script part of a file with if __name__ == "__main__": so that importing it does not run your demo code. Install third-party packages with pip inside a virtual environment created by python -m venv .venv, so each project keeps its own dependency versions.

A class bundles data with the functions that operate on it. def __init__(self, name, balance) sets up each instance's attributes, other methods take self as their first parameter, and __repr__ controls how the object shows up when you print it in a debug session. Reach for a class when several functions keep passing the same cluster of values around; a plain function or a dataclass is enough when you only need to hold fields. Finally, write assertions or small test functions as you go, because code you can rerun in one command is code you can change without fear.