Python

What Python is, why it reads the way it does, and where it's actually used.

Installing Python, confirming it works, and understanding what pip and virtual environments are for.

Writing a .py file, running it from the terminal, and reading Python's error messages.

How Python variables work under the hood, naming rules, and multiple assignment.

Python's core built-in types -- int, float, str, bool, and None -- and how to check them.

Converting between int, float, str, and bool explicitly, and where implicit conversion sneaks in.

Formatting strings with f-strings -- Python's modern, readable way to embed expressions in text.

Conditional branching in Python -- indentation-based blocks, elif chains, and comparison operators.

Iterating with for loops over sequences and range(), and repeating with while.

Exiting loops early, skipping an iteration, and the surprising else clause loops can have.

Writing reusable functions with def, return values, parameters, and docstrings.

Giving parameters default values, calling functions with keyword arguments, and the *args/**kwargs pattern.

Writing small anonymous functions with lambda, and how Python resolves variable scope.

Python's two core sequence types -- mutable lists and immutable tuples -- and when to use each.

Key-value storage with dict, and unique unordered collections with set.

Building lists in a single readable expression instead of a manual loop with .append().

Defining classes, creating instances, and understanding __init__ and self.

Sharing behavior between classes with inheritance, overriding methods, and using super().

How __init__, __str__, __eq__, and other double-underscore methods hook your classes into Python's built-in syntax.

Catching exceptions gracefully with try/except/else/finally instead of letting a program crash.

Organizing code across files with import, structuring packages, and managing dependencies with pip and requirements.txt.

Django, FastAPI, and Flask -- what each is built for and a minimal hello-world route in each.

A closing checklist of habits -- style, structure, and tooling -- that separate working Python from good Python.

Two readable, dynamically typed languages with very different philosophies — Python's explicitness against Ruby's flexibility.