Open appSythra Python
A beginner-friendly Python path from first print statement to functions and data structures. No paywall to read.
Featured
File handling in Python uses open(filename, mode) to read ('r'), write ('w', which erases existing content), or append ('a') to a file — always wrapped in a with statement so the file closes automatically, even if an error occurs.
Read lesson
Recent
File handling in Python uses open(filename, mode) to read ('r'), write ('w', which erases existing content), or append ('a') to a file — always wrapped in a with statement so the file closes automatically, even if an error occurs.
Polymorphism means the same method name or operator can behave differently depending on the object it's used with. Python achieves this through duck typing (any object with the right method works, regardless of type) and dunder methods like __add__ and __eq__, which let your own classes plug into built-in operators and functions.
Abstraction means hiding a class's complicated internal logic behind a small, simple set of methods. Python's abc module lets you define abstract classes with @abstractmethod, creating a contract that subclasses must fulfill before they can be instantiated.
Inheritance lets a child class (like Hand) automatically reuse all the methods of a parent class (like Deck) by writing class Child(Parent):, overriding only what's different — use it for genuine IS-A relationships, not just to avoid retyping code.
Encapsulation means bundling an object's data and the methods that operate on it together, and protecting that data from invalid changes — in Python, typically using an underscore-prefixed attribute plus @property getters and setters that validate every read and write.
The four pillars of Object-Oriented Programming are encapsulation (bundling data and behavior together), abstraction (hiding complexity behind a simple interface), inheritance (building new classes on top of existing ones), and polymorphism (the same action behaving differently depending on the object).
A method is a function defined inside a class, called with dot notation, whose first parameter (self) refers to the instance it was called on. __init__ sets up attributes at creation, __str__ controls how an object prints, and methods like __add__ let you overload operators for your own classes.
A pure function returns a new object without touching its inputs, while a modifier changes the object it receives directly. Planned development — reframing a Time object as a base-60 number — replaces messy overflow-checking code with a few clean lines using divmod().
A class in Python is a blueprint for a new type; an object (instance) is what you get when you call the class. Objects store named attributes via dot notation, are passed by reference to functions, and require copy.deepcopy (not copy.copy) to fully duplicate when they contain embedded objects.
Beyond while and for, Python's iteration toolkit includes continue (skip a round), pass (do-nothing placeholder), a loop else clause (runs only without break), enumerate() and zip() for pairing data, list comprehensions for compact loops, and generators for producing values on demand.
Python has no built-in do-while loop, but while True: combined with a break inside the body simulates the same run-at-least-once behavior — commonly used for input validation.
A for loop in Python pulls values one at a time from a sequence — like range(), a string, or a list — and runs its body once per value, stopping automatically when the sequence is exhausted.
A while loop in Python repeats its body as long as a condition stays True, checking the condition before every pass — use break to exit early, and always make sure the body eventually makes the condition False.
Before writing loops, you need to understand that Python variables can be reassigned freely, and an update like x = x + 1 uses a variable's current value to compute its next one — shorthand as x += 1.
try/except in Python lets a program catch errors like ZeroDivisionError or ValueError instead of crashing — wrap risky code in try, handle specific errors in except, use else for success-only code, and finally for cleanup that always runs.
Python 3.10 introduced match/case as a cleaner alternative to long if/elif chains for checking one value against many possibilities, with case _: as the required default case for anything unmatched.
Recursion in Python is a function calling itself to solve smaller versions of the same problem, always stopping at a base case. Classic examples are factorial (n! = n × (n-1)!) and Fibonacci (fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)).
Conditionals in Python let a program run different code depending on a condition, using if to run code when true, elif to check additional possibilities in order, and else as a catch-all default.
Comparison operators in Python (==, !=, <, >, <=, >=) compare two values and produce a boolean True or False, which you then combine with and, or, and not to build the conditions used in if statements.
Beyond basic def and return, Python functions support default arguments, keyword arguments, *args and **kwargs for unlimited inputs, one-line lambda functions, and strict local/global variable scope rules — and functions themselves can be passed around like any other value.
Built-in functions in Python are functions always available without any import, like type(), len(), range(), round(), max(), min(), and sum() — they cover type checking, numbers, and generating sequences.
A module in Python is a file of pre-built functions you bring into your program with import, so you don't have to write everything yourself. The math and random modules are two of the most commonly used.
A fruitful function in Python is one that uses return to hand back a value the caller can store or use, unlike a void function which returns None. Build them incrementally, one small tested step at a time.
A function in Python is a named, reusable block of code you define once with def and call by name. It can accept input (arguments), do work, and optionally return a value — write the logic once, use it everywhere.
Type casting in Python means converting a value from one data type to another, either implicitly (Python does it automatically, like int + float) or explicitly (you call int(), float(), str(), or bool() yourself).
A Python set is an unordered collection of unique, hashable values created with set() or curly braces, e.g. {1, 2, 3}. Sets remove duplicates automatically and support fast membership checks and math operations like union (|) and intersection (&).
A Python tuple is an immutable, ordered sequence created with commas, e.g. (1, 2, 3). Tuples are used to return multiple values from a function, unpack values with a, b = b, a, and as dictionary keys since they're hashable — unlike lists.
A Python dictionary stores key-value pairs and looks up values by key almost instantly using a hashtable. Keys must be immutable (strings, numbers, tuples) — lists can never be keys, though they can be values.
A Python list is a mutable, ordered sequence that can hold values of any type. Unlike strings, you can change elements in place, and methods like .append(), .sort(), and .pop() modify the list directly — but assigning one list to another creates an alias, not a copy.
A Python string is an immutable sequence of characters. You access characters with zero-based indexing (fruit[0]), extract ranges with slicing (fruit[1:4]), and use built-in methods like .upper(), .find(), and .replace() to work with text.
Python's input() function pauses a program, waits for the user to type something, and returns it as a string — even if it looks like a number. Convert it with int() or float() before doing math.
Interactive mode (the Python REPL) runs code line by line and automatically shows the value of any expression you type. Script mode runs a whole .py file at once and stays silent unless you explicitly print() something.
Python's built-in data types include int, float, str, and bool (primitive — single values) and list, tuple, set, and dict (non-primitive — collections). Some are mutable (list, dict, set); others are immutable (int, float, str, tuple, bool).
Python evaluates expressions using operator precedence — the same PEMDAS idea as math: parentheses first, then **, then * / // %, then + -. When operators tie, Python usually goes left to right.
In Python, an expression produces a value; a statement performs an action. The REPL auto-displays expression results, but a script stays silent unless you print() — which is why the same lines can “work” interactively and do nothing in a file.
In Python, operators are symbols (and some keywords) that perform computations; operands are the values they act on. Families include arithmetic, comparison, logical, assignment, membership, and identity.
Comments in Python are notes for humans, written with #. Python ignores them, so you can explain why code exists — prefer context and intent over restating what the line already does.
A variable in Python is a name that refers to a value. You create one with assignment (=), reuse it in expressions, and update it with patterns like score = score + 5 or score += 5.
Every piece of data in Python has a value and a type. Use type() to see int, float, or str — and learn why some bugs crash loudly while semantic errors run quietly with the wrong answer.
A program is a sequence of instructions for a computer. High-level languages like Python need translation — interpreters run as they go; compilers translate the whole program first. Here’s the full mental model.
Logical operators in Python — and, or, not — explained with clear examples, truth tables, short-circuiting, and common mistakes.
Newsletter
Free Python explainers and learning tips — no account required. We’ll only email when there’s something worth reading.
