Python for Beginners

Your first step in Python. A beginner-friendly walkthrough of printing to the screen with print(), writing comments using # and """, and embedding values with f-strings.

A beginner-friendly guide to Python variables and data types — using int and str, dynamic typing and reassignment, naming rules and reserved words, the constants convention, and converting between int and str.

A beginner-friendly guide to Python's boolean type — the two values True and False, how comparison operators produce booleans, the and / or / not logical operators, and how to avoid the classic = vs == mix-up.

A deep dive into Python's numeric types — int vs float, the ** power operator and compound assignments like +=, the difference between / and //, float precision pitfalls, and converting with int() and float().

A thorough guide to Python's string type (str). Learn when to use single, double, and triple quotes; how indexing and slicing pull out characters; transformation methods like upper/lower/replace/strip; and inspection methods like count/find/startswith/isdigit — all with runnable practice exercises.

A clear guide to converting between numbers and strings in Python. From the basics of str() to turn numbers into strings, and int() / float() to turn strings into numbers, to avoiding TypeError / ValueError and how to cast a decimal string to an integer — all with runnable exercises.

A thorough guide to Python's list type. Learn declarations and indexing, slicing to pull out ranges, add/remove methods like append/extend/insert/remove/pop, and sort/reverse/count/index — all with runnable exercises.

A thorough guide to Python's dict type. Declaring key-value pairs, how [] differs from .get() when retrieving, adding/updating/deleting entries, listing data with keys / values / items, and checking key existence with in — all with runnable practice exercises.

A guide to Python's tuple type, focused on how it differs from a list. Covers parentheses-based declarations, what immutability really means, the count / index methods, unpacking several values in one line, and why tuples can be used as dict keys — all with runnable, browser-based exercises.

A guide to Python's set type. Covers the two defining rules (no duplicates, no order), element operations with add / remove / discard / pop / clear, set operations (union / intersection / difference / symmetric_difference), and the real-world patterns of deduplication and fast membership checks — with exercises you can run in the browser.

A careful walkthrough of mutable and immutable types in Python. The y = x trap that makes two variables share the same box, why it becomes a bug, and how copy() gives you an independent version — all with runnable browser exercises.

A roundup of the data types covered in Python Basics. Revisit what a "type" really is, review which type fits which job with a handy table, and take your first step into OOP — defining your own type with class — all with diagrams.

A deeper look at Python's conditional branching — multi-way logic with elif / else, truthiness covering empty strings and 0, the ternary operator, the difference between is and ==, type checks with isinstance, and element checks with in / not in — all with runnable practice exercises.

A from-the-ground-up guide to all() / any() for judging the elements of a list or tuple in bulk. Learn all() for "is everything True?", any() for "is at least one True?", their typical use cases, and how to combine them with for — all with runnable practice exercises.

A practical guide to Python comprehensions: list, dict, set, and generator expressions, plus filtering with if. Includes runnable exercises.

A systematic walkthrough of Python's for statement. Looping over lists and dicts one element at a time, using range() for fixed-count loops, indexed loops with enumerate(), parallel iteration over multiple lists with zip(), and loop control with break / continue — all with runnable practice exercises.

A from-the-ground-up guide to Python's while loop. Repeating while a condition holds, building termination conditions to avoid infinite loops, forced exits with break and skips with continue, and choosing between for and while — all with runnable practice exercises.

A from-the-ground-up guide to Python 3.8's walrus operator :=. Covers the basic syntax for assigning and testing in a single line, reusing the tested value inside if, combining the pop-and-test pattern in while, the paren-forgetting pitfall that assigns the comparison result, and when to use it or avoid it — all with runnable practice exercises.

A from-the-ground-up guide to Python's exception handling try / except. Covers syntax vs. runtime errors, the basic try / except shape, capturing the exception object with as e, catching multiple exceptions separately, the umbrella Exception catch, and cleanup with finally — all with runnable practice exercises.

A guide to throwing exceptions yourself in Python with raise. Covers the basics of raise ValueError("message"), the if + raise validation pattern, and defining a custom exception with class MyError(Exception): to catch it pinpoint-precise with try / except — all with runnable practice exercises.

A from-the-ground-up guide to Python's function definition def. Covers the basics of def and return, caller-side arguments and return values, default arguments, and keyword arguments — all with runnable practice exercises.

Learn Python's *args / **kwargs and multiple return values in your browser. Diagrams cover positional/keyword arguments, unpacking with *list / **dict, and tuple returns. Includes runnable exercises.

Learn how Python function arguments behave with mutable vs immutable types. Walk through why list/dict mutations leak to the caller, the .copy() pattern, and the mutable default argument trap — with runnable exercises.

Walk through Python scope, inner functions, and closures: how globals and locals split, when to reach for global and nonlocal, and how to return a function that remembers outer values. Includes runnable exercises.

Walk through Python generator functions: yield to return values one at a time, pulling them with next() and for, the memory gap between a list and a generator, and chaining with yield from. Includes runnable exercises.

Walk through Python higher-order functions in the browser: assigning functions to variables, passing them as callbacks to swap behavior, branching on multiple callbacks, and returning a closure that remembers its setting. Includes runnable exercises.

Learn Python's lambda expressions from the ground up while running code in your browser. Cover the basic lambda args: expression form, multiple arguments, conditional expressions, default arguments, pairing with higher-order functions like sorted's key, and when to fall back to def — all with runnable exercises.

Walk through Python decorators in your browser, from the basics. Covers the @decorator syntax, the standard def → return inner shape, passing any arguments through with *args / **kwargs, decorators with arguments like @repeat(3), and real-world uses in frameworks like Flask and pytest. Includes runnable exercises.

A runnable, browser-based walkthrough of Python's map() function from the ground up. Covers the map(function, iterable) basics, materializing results with list(), pairing with lambdas and built-ins like int, passing multiple iterables at once, and choosing between map() and list comprehensions — with hands-on exercises throughout.

A roundup of Python syntax (control flow and functions). Cross-cuts conditional branching, loops, exception handling, and function applications into one clear map.

An entry point into Python's OOP: define a class with class, create instances from it, and learn the role of self and how __init__ sets attributes. Includes runnable practice exercises.

A practical guide to Python's constructor __init__ and destructor __del__. Covers enforcing required attributes at instance creation, defining default values, and the cleanup method called on del and program exit. Includes runnable practice exercises.

A careful walkthrough of the two kinds of variables in Python classes — **class variables** shared by everyone, and **instance variables** owned by each instance. See exactly what self.x = ... does and verify references with id(). Includes runnable practice exercises.

A guide to the three kinds of methods you can define in a Python class — **instance methods** that take self, **class methods** with @classmethod and cls, and **static methods** that take no special first argument. Practical patterns like validation and factories, with runnable exercises.

A walkthrough of Python's special (dunder) methods. Define + with __add__, separate user-facing and developer-facing strings with __str__ / __repr__, redefine == meaningfully with __eq__, plus typical uses of __call__, __len__, and __bool__. Includes runnable practice exercises.

A walkthrough of Python class inheritance. Inherit attributes and methods with class Child(Parent):, override methods in subclasses, call the parent's logic with super().method(), and grow attributes by overriding __init__ — the standard pattern. Includes runnable practice exercises.

A walkthrough of Python multiple inheritance. Combine parents with class Child(A, B):, see how the **method resolution order (MRO)** picks among same-named methods, check the order with __mro__, walk through C3 linearization for diamond inheritance, and target a specific parent by class name. Includes runnable practice exercises.

A walkthrough of Python polymorphism. Override a parent's method per subclass so callers can use one name regardless of type, process mixed types in a single loop, replace if type(...) branches with cleaner OOP, and learn Python's signature **duck typing**. Includes runnable practice exercises.

A walkthrough of Python's private variables and encapsulation. The _x convention vs __x name mangling, safe access via get_xxx / set_xxx with validation in setters, and the Pythonic @property / @xxx.setter style with computed properties. Includes runnable practice exercises.

A walkthrough of Python file I/O. with open() auto-close, the difference between read / readlines / readline, the w / a modes, and the read-process-write pattern that saves results to a separate file. Includes runnable practice exercises.

A walkthrough of Python's with statement and context managers. The __enter__ / __exit__ pair that auto-opens and auto-closes resources, the value flow through the as clause, exception handling via exc_type / exc_val / traceback, and the comparison with try / finally. Includes runnable practice exercises.

A walkthrough of Python type hints (type hints). The def f(x: int) -> str: function signature, when to add a variable annotation like name: str = "Alice" and when not to, how IDEs and mypy use them for static checking, and the fact that types are not enforced at runtime. Includes runnable practice exercises.

A wrap-up of Python OOP. Covers class fundamentals, inheritance and polymorphism, special (dunder) methods, with statements, encapsulation, and type hints across the series, with cross-links to every article.

Learn the differences between Python modules, packages, and libraries plus how the import statement pulls functions in from other files. Covers standard vs. third-party libraries, importing your own modules, what runs at import time, the __name__ == "__main__" check, and combining several modules — with runnable practice exercises.

Learn the role of __init__.py for building Python packages and when to reach for absolute vs. relative imports. Covers bundling several modules under one folder, narrowing the public API with from-package imports, mixing absolute and relative imports correctly, and a real-project folder layout — with runnable practice exercises.

Get a bird's-eye view of Python's standard library across 7 categories. Date handling, numeric work, data I/O, concurrency — figure out what to import for each situation.

Learn the Python sys and argparse modules from the ground up. From reading runtime info with sys.path / sys.argv / sys.exit to building structured argument parsers with argparse — all hands-on.

Learn Python's os.path and pathlib modules from the basics. Build OS-agnostic paths, list and recursively walk directories, and break paths into pieces with Path objects — all hands-on.

Learn Python's shutil and tempfile from the ground up. Bulk file operations with shutil.copy / shutil.move / shutil.rmtree, plus how to safely use temporary files via tempfile.NamedTemporaryFile — all hands-on.

Learn Python's datetime / time / calendar modules from the ground up. Covers date arithmetic with date / datetime / timedelta, string conversion via strftime / strptime, and elapsed-time measurement with time.perf_counter — all hands-on.

Learn Python's math and statistics modules from the ground up. Covers single-value math with math.sqrt / pi / floor / ceil / log, data aggregation with statistics.mean / median / mode / stdev, and how the two modules split responsibilities — with runnable practice exercises.

Learn Python's decimal and fractions modules from the ground up. Covers the 0.1 + 0.2 != 0.3 problem with float, exact monetary calculation with Decimal (and why you build Decimals from strings), arithmetic with auto-reducing Fraction, and choosing among the three numeric types — with runnable practice exercises.

Learn Python's random and secrets modules from the ground up. Covers reproducible pseudorandom sequences with random.choice / randint / shuffle / sample plus seed, cryptographically safe tokens with secrets.token_hex / token_urlsafe, and when to use one vs. the other — with runnable practice exercises.

Learn Python's re module from the ground up. Covers when to reach for re.match / re.search / re.findall, combining metacharacters \d / \w / \s / * / + / ?, capturing groups with ( ), substitution with re.sub, and reusing patterns with re.compile — with runnable practice exercises.

Learn Python's string and textwrap modules from the ground up. Covers character constants like string.ascii_letters / digits, $name-style template substitution with string.Template, removing indentation from triple-quoted strings with textwrap.dedent, and width-wrapping with fill — with runnable practice exercises.

Learn Python's pprint module from the ground up. Covers how pprint.pp keeps nested dict / list structure readable where print fails, stringifying with pformat, the width / indent / sort_dicts options, and using it in everyday debugging — with runnable practice exercises.

Learn Python's json and csv modules from the ground up. Covers converting between Python objects and JSON strings with json.dumps / loads, formatting with indent and ensure_ascii, position-based reading and writing with csv.writer / reader, and column-name-based dict I/O with DictWriter / DictReader — with runnable practice exercises.

Learn Python's pickle and base64 modules from the ground up. Covers serializing Python objects with pickle.dumps / loads, converting binary data to and from text with base64.b64encode / b64decode, when to choose the urlsafe variant, and pickle's security caveats — with runnable practice exercises.

Learn Python's hashlib module from the ground up. Covers fixed-length "fingerprints" via SHA-256, the three properties (deterministic, avalanche, one-way), implementing tamper detection and integrity checks, and why password storage shouldn't rely on hashlib alone — with runnable practice exercises.

Learn Python's collections module from the ground up. Covers tallying with Counter and most_common, missing-key handling with defaultdict, O(1) operations on both ends and ring buffers via deque + maxlen, and attribute access plus dict conversion with namedtuple — with runnable practice exercises.

Learn Python's itertools and functools modules from the ground up. Covers iteration recipes via combinations / product / chain / accumulate, locking arguments with partial, folding with reduce, and speeding up calls with @lru_cache memoization — with runnable practice exercises.

Learn Python's enum and dataclasses modules from the ground up. Covers replacing magic strings with Enum, automatic numbering with IntEnum and auto, auto-generating __init__ / __eq__ / __repr__ via @dataclass, and avoiding mutable-default pitfalls with field(default_factory=list) — with runnable practice exercises.

Learn Python's contextlib and logging modules from the ground up. Covers writing your own context managers with @contextmanager, swallowing specific exceptions with suppress, dynamic resource management via ExitStack, and production-quality logs with level routing and Formatter — with runnable practice exercises.

Learn Python's async / await from the ground up. Covers why a synchronous version wastes wait time, defining coroutines with async def, waiting for completion with await, the difference between asyncio.sleep and time.sleep, and asyncio.run vs. Pyodide's top-level await — with runnable practice exercises.

Learn advanced asyncio in Python. Covers running multiple coroutines concurrently with asyncio.gather while preserving input order, creating Tasks with create_task, applying timeouts with wait_for, and the producer-consumer pattern via asyncio.Queue — with runnable practice exercises.

An illustrated walkthrough of Python's threading, multiprocessing, and subprocess modules. Covers threads vs. processes, the GIL constraint, using ThreadPoolExecutor and Pool, deciding among I/O-bound, CPU-bound, and external-command workloads, and the comparison with vectorized libraries like NumPy — with diagrams to organize the concepts.

A wrap-up of 17 Python standard library modules. Bird's-eye view across 7 categories, a 20-situation cheat sheet, when to switch to third-party libraries (requests / pandas / NumPy / pytest / FastAPI / SQLAlchemy, etc.), and a learning roadmap after the standard library — all illustrated.