Lists vs tuples — when to use which
Mutability, use cases, and simple rules to choose correctly.
Core Concepts
One concept per article: data structures, syntax, built-ins, and common patterns. No long tutorials—just clear, focused explanations.
Once you know how to write basic Python—variables, data types, functions, and loops—you will keep running into the same ideas: when to use a list vs a tuple, what *args and **kwargs mean, how list comprehensions and decorators work, and why == and is behave differently. This section is a reference for those concepts: one article per topic, with short explanations and runnable examples.
We group topics roughly by theme. Data structures and types: lists vs tuples, mutable vs immutable, dictionaries, sets, slicing, and shallow vs deep copy. Functions and control flow: lambda, default arguments, return values, map and filter, decorators, and closures. Iteration and built-ins: enumerate, zip, range, generators, iterators and iterables. Strings and formatting: string methods, f-strings, and string formatting. Errors and context: exception handling and context managers.
Use the sidebar or the list below to jump to a concept. If you hit an error you do not recognise, check the Errors & Exceptions section; many messages become clear once you understand the underlying concept (for example NoneType has no len() after reading about return values and None)
What are *args and **kwargs?
Variable-length arguments in plain English, with examples.
Mutable vs immutable in Python
What it means, why it matters, and how it affects your code.
List comprehensions
A concise way to create lists from existing sequences.
Dictionaries — storing key-value pairs
How dictionaries work and when to use them.
Sets — unique unordered collections
What sets are, how they work, and when to use them.
enumerate() — loop with index and value
Get both the index and value when looping over a sequence.
zip() — combine multiple sequences
Loop over multiple lists at the same time.
Lambda functions — anonymous functions
Small, one-line functions without a name.
map() and filter() — transform and filter sequences
Apply functions to sequences and select items that meet conditions.
Generators — memory-efficient iteration
Create iterators that produce values one at a time, saving memory.
Decorators — modify functions without changing them
Add behavior to functions using the @ syntax.
Closures — functions that remember their environment
Inner functions that access variables from outer scope.
String methods — common string operations
Essential methods for working with strings.
f-strings — modern string formatting
The easiest and most readable way to format strings in Python.
range() — generate sequences of numbers
Create sequences of integers for loops and list creation.
Scope and namespace — where variables live
Understanding where variables are accessible in your code.
Shallow copy vs deep copy
Understanding the difference when copying nested structures.
Exception handling — try, except, finally
Handle errors gracefully without crashing your program.
Context managers — the with statement
Automatically manage resources like files and connections.
List methods — common list operations
Essential methods for working with lists.
Slicing — extract parts of sequences
Get substrings, sublists, or parts of any sequence.
Default arguments — optional function parameters
Make function parameters optional with default values.
Return values — what functions give back
Understanding how functions return data to the caller.
Imports and modules — organizing your code
How to use code from other files and built-in modules.
if, elif, else — conditional execution
Make decisions in your code based on conditions.
for loops — iterate over sequences
Loop through lists, strings, and other iterables.
while loops — repeat while condition is true
Loop until a condition becomes false.
Boolean operators — and, or, not
Combine and negate conditions in your code.
Comparison operators — ==, !=, <, >, <=, >=
Compare values and get True or False.
Variables and assignment — storing values
How to create and use variables in Python.
Data types — numbers, strings, booleans
Understanding Python's basic data types.
Functions — reusable blocks of code
Define and call functions to organize your code.
Dictionary comprehensions — create dicts concisely
Create dictionaries in one line, similar to list comprehensions.
Set comprehensions — create sets concisely
Create sets in one line, similar to list comprehensions.
any() and all() — check conditions on sequences
Check if any or all items in a sequence meet a condition.
sorted() — sort any iterable
Sort lists, tuples, strings, and other iterables.
len(), sum(), min(), max() — useful built-in functions
Common functions for working with sequences and numbers.
isinstance() and type() — check data types
Determine what type an object is.
The 'in' operator — check membership
Check if an item exists in a sequence or collection.
String formatting methods — % vs .format() vs f-strings
Three ways to format strings in Python.
Iterators and iterables — how loops work
Understanding what can be looped over in Python.
__init__ method — initialize objects
The __init__ method initializes new objects when you create them from a class.
__str__ and __repr__ — object string representation
Control how your objects appear as strings using __str__ for users and __repr__ for developers.
__len__ method — custom length
Define custom length behavior for your objects using the __len__ method.
__getitem__ and __setitem__ — index access
Make your objects support indexing with square brackets using __getitem__ and __setitem__.
__call__ method — callable objects
Make your objects callable like functions using the __call__ method.
__iter__ and __next__ — custom iterators
Create custom iterators using __iter__ and __next__ methods to control iteration behavior.
__eq__ and __hash__ — equality and hashing
Control object equality and make objects hashable using __eq__ and __hash__ methods.
__bool__ method — truthiness
Control how your objects evaluate to True or False in boolean contexts using __bool__.
__contains__ method — in operator
Control how the 'in' operator works with your objects using the __contains__ method.
__add__ method — operator overloading
Override the + operator for your objects using the __add__ method.
__getattr__ and __setattr__ — attribute access
Control attribute access and assignment using __getattr__ and __setattr__ methods.
__del__ method — destructor
Define cleanup behavior when objects are deleted using the __del__ method.
__new__ method — object creation
Control object creation before __init__ using the __new__ method.
__slots__ attribute — memory optimization
Optimize memory usage by restricting object attributes with __slots__.
__dict__ attribute — object dictionary
Access and manipulate the dictionary that stores object attributes using __dict__.
__class__ and __bases__ — class information
Access class and inheritance information using __class__ and __bases__ attributes.
__name__ and __module__ — object identity
Access object and module names using __name__ and __module__ attributes.
__doc__ attribute — docstrings
Access documentation strings using the __doc__ attribute.
__file__ attribute — file path
Get the file path of a module using the __file__ attribute.
__main__ module — script execution
Understand how __main__ works when running Python scripts directly.
__all__ attribute — import control
Control what gets imported with 'from module import *' using __all__.
__init__.py files — package initialization
Understand how __init__.py files turn directories into Python packages.
__pycache__ directory — bytecode cache
Understand how Python stores compiled bytecode in __pycache__ directories.
__version__ attribute — version information
Store and access version information using the __version__ attribute.
__future__ imports — future features
Enable future Python features in current versions using __future__ imports.
__import__ function — dynamic imports
Import modules dynamically at runtime using the __import__ function.
__builtins__ module — built-in functions
Access Python's built-in functions and objects through the __builtins__ module.
__annotations__ attribute — type hints
Access type annotations using the __annotations__ attribute.
__globals__ and __locals__ — namespace access
Access global and local namespaces using __globals__ and __locals__ attributes.
__enter__ and __exit__ — context managers
Create custom context managers using __enter__ and __exit__ methods for the 'with' statement.
__missing__ method — default dict values
Define default values for missing dictionary keys using the __missing__ method.