*args vs **kwargs
*args captures extra positional arguments and **kwargs captures extra keyword arguments.
- args becomes tuple
- kwargs becomes dict
- Useful for flexible APIs
Quick recall
374 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
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
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
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
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 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
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
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
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
Dict comprehensions, set comprehensions, and generator expressions
Python has comprehension syntax for lists, dicts, and sets, plus generator expressions for lazy pipelines.
- Dict comprehensions build key-value mappings
- Set comprehensions deduplicate naturally
- Generator expressions avoid building full collections
Dictionary operations, iteration, and methods
Dictionaries map keys to values and are optimized for fast lookup, update, and membership by key.
- Iterate with keys, values, or items
- Lookups are usually average O(1)
- Methods like `get` make code safer