*args vs **kwargs
*args captures extra positional arguments and **kwargs captures extra keyword arguments.
- args becomes tuple
- kwargs becomes dict
- Useful for flexible APIs
*args vs **kwargs
Python cards
64 cards
Built-in exceptions, try/except/else/finally, custom exceptions, and chaining
Python exception handling is strongest when you catch specific built-in errors, use `else` for the success path, `finally` for cleanup, and custom exceptions when domain meaning matters.
- Catch only expected failures
- `else` runs when no exception occurred
- `raise ... from ...` preserves causal context
Built-in exceptions, try/except/else/finally, custom exceptions, and chaining
Bytes, bytearray, and range in Python
`bytes` is immutable binary data, `bytearray` is mutable binary data, and `range` is a memory-efficient arithmetic sequence object.
- Binary data is not text
- bytearray supports in-place updates
- range does not build a full list
Bytes, bytearray, and range in Python
Classes, objects, `self`, `__init__`, and class vs instance variables
A class defines shared behavior, each object holds instance state, `self` refers to the current instance, and `__init__` initializes it.
- Instance variables belong to each object
- Class variables are shared on the class
- `self` is just a normal first parameter by convention
Classes, objects, `self`, `__init__`, and class vs instance variables
collections and functools helpers: `defaultdict`, `Counter`, `deque`, `namedtuple`, `partial`, `reduce`, and `lru_cache`
These helpers reduce boilerplate for grouping, counting, queue behavior, lightweight record types, partial application, reduction, and memoization.
- `Counter` counts fast
- `deque` is strong for queues
- `lru_cache` adds memoization with little code
collections and functools helpers: `defaultdict`, `Counter`, `deque`, `namedtuple`, `partial`, `reduce`, and `lru_cache`
Common Python comparison topics: set vs list, append vs extend, remove vs pop vs del, sort() vs sorted(), @staticmethod vs @classmethod, and generator vs iterator
Interview prep often comes down to comparing similar tools and explaining when each one is the better fit.
- Lists preserve order, sets optimize membership
- append adds one item while extend adds many
- sorted returns a new list while sort mutates in place
Common Python comparison topics: set vs list, append vs extend, remove vs pop vs del, sort() vs sorted(), @staticmethod vs @classmethod, and generator vs iterator
Common special methods like `__str__`, `__repr__`, `__len__`, `__getitem__`, and `__contains__`
Special methods let your objects behave like built-in types in printing, indexing, length checks, and membership operations.
- `__str__` is user-friendly output
- `__repr__` should be unambiguous
- Container protocols come from dunder methods
Common special methods like `__str__`, `__repr__`, `__len__`, `__getitem__`, and `__contains__`
Conditional statements, ternary expressions, and match-case basics
Python uses `if`/`elif`/`else` for general branching, a ternary expression for concise value selection, and `match-case` for structural pattern matching in newer versions.
- Use ternary for small expressions only
- match-case compares shapes and patterns
- Readable branching beats clever branching
Conditional statements, ternary expressions, and match-case basics
Core data types in Python
Core Python data types include numbers, strings, lists, tuples, sets, dictionaries, booleans, and `None`.
- Mutable and immutable types differ
- Some are ordered, some are hash-based
- Choose types based on access and update patterns
Core data types in Python
Default arguments and mutable default values
Default argument values are evaluated once at function definition time, which makes mutable defaults a common bug source.
- Immutable defaults are safer
- Use `None` as a sentinel
- Mutable defaults persist across calls
Default arguments and mutable default values