--- ## Table 1: Basic Data Types and Operations | Type/Operation | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | Integer (int) | **Whole numbers** without decimal points, **arbitrary precision** | Mathematical calculations, counters, indices, bitwise operations | **Arbitrary precision (no overflow)**, supports standard arithmetic operators | Can be slower than fixed-size integers in other languages for large calculations | `x = 42`
`y = -10`
`z = 0b1010 # binary` | 1, 2 | | Float (float) | **Floating-point numbers** (64-bit double precision) | Decimal calculations, **scientific computing**, measurements | **Standard IEEE 754 representation**, supports scientific notation | Limited precision (**~15-17 significant digits**), rounding errors possible | `pi = 3.14159`
`sci = 1.5e-3`
`inf = float('inf')` | 1, 2 | | Boolean (bool) | **Logical values True or False** (subclass of int) | Conditional logic, flags, control flow | Readable syntax, any value can be tested for **truthiness** | **Empty containers and zero evaluate to False** (can be confusing) | `is_valid = True`
`result = (5 > 3)`
`empty = bool([]) # False` | 1, 2 | | String (str) | **Immutable sequence** of Unicode characters | Text processing, data representation, output formatting | Rich methods for manipulation, **Unicode support**, multiple ways to create | **Immutable (concatenation creates new strings)**, can be memory-intensive | `name = "Python"`
`multi = '''line1\nline2'''`
`raw = r'\n'` | 1, 2, 3 | | None Type | Represents **absence of value** (singleton object) | Default return value, initialization, null checks | **Single instance in memory**, falsy value, explicit intent | Can cause **AttributeError** if methods called on None | `result = None`
`def func():`
` return None` | 1, 2 | | Complex (complex) | **Complex numbers** with real and imaginary parts | Scientific computing, signal processing, electrical engineering | **Native support for complex arithmetic**, **j notation** | Less commonly used outside scientific applications | `c = 3 + 4j`
`c.real # 3.0`
`c.imag # 4.0` | 1, 2 | | Bytes (bytes) | **Immutable sequence of bytes** (0-255) | Binary data, file I/O, network protocols, encoding | **Efficient for binary operations**, clear distinction from strings | Immutable, different from **bytearray** | `b = b'hello'`
`b = bytes([65, 66, 67])`
`b.hex()` | 1, 2 | | Bytearray | **Mutable sequence of bytes** | Buffer operations, binary data modification | **Mutable alternative to bytes**, efficient in-place modification | Less type safety, can be modified accidentally | `ba = bytearray(b'hello')`
`ba[0] = 72`
`ba.extend(b'!')` | 1, 2 | --- ## Table 2: Data Structures | Structure | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | List | **Ordered, mutable sequence** of elements | General-purpose collections, stacks, queues | Dynamic size, supports **heterogeneous types**, rich methods | **O(n) for search**, insertion in middle | `lst = [1, 2, 3]`
`lst.append(4)`
`lst[0] = 10` | 4, 5 | | Tuple | **Ordered, immutable sequence** of elements | Fixed collections, function returns, dictionary keys | **Immutable (hashable)**, memory efficient, faster than lists | **Cannot modify after creation**, less flexible | `tup = (1, 2, 3)`
`x, y = (5, 10)`
`single = (1,)` | 4, 5, 6 | | Dictionary (dict) | **Unordered collection of key-value pairs (hash table)** | Mappings, caching, configuration, JSON-like data | **O(1) average lookup/insert/delete**, dynamic, preserves **insertion order (3.7+)** | **Keys must be hashable**, memory overhead compared to arrays | `d = {'a': 1, 'b': 2}`
`d['c'] = 3`
`d.get('d', 0)` | 4, 5, 7 | | Set | **Unordered collection of unique elements** | Removing duplicates, membership testing, set operations | **O(1) membership testing**, **automatic deduplication**, set algebra | Unordered, **elements must be hashable**, no indexing | `s = {1, 2, 3}`
`s.add(4)`
`s1 & s2 # intersection` | 4, 5 | | Frozenset | **Immutable version of set** | Dictionary keys, set elements, read-only collections | **Immutable (hashable)**, can be dictionary key or set element | **Cannot modify after creation**, less commonly used | `fs = frozenset([1, 2, 3])`
`d = {fs: 'value'}` | 4, 5 | | Deque (collections) | **Double-ended queue** with **O(1) appends/pops on both ends** | Queues, sliding windows, recent history tracking | Efficient **O(1) operations on both ends**, **thread-safe** | Slower **O(n) random access** than lists | `from collections import deque`
`dq = deque([1, 2])`
`dq.appendleft(0)` | 8, 9 | | Counter (collections) | Dictionary subclass for **counting hashable objects** | Frequency counting, histogram, word counts | Convenient counting API, **most_common() method** | Memory overhead, specific use case | `from collections import Counter`
`c = Counter('hello')`
`c.most_common(2)` | 8, 9 | | DefaultDict (collections) | Dictionary with **default value for missing keys** | Grouping, accumulation, avoiding KeyError | **No KeyError for missing keys**, cleaner code | Can hide bugs by creating unexpected keys | `from collections import defaultdict`
`dd = defaultdict(list)`
`dd['key'].append(1)` | 8, 9 | | OrderedDict (collections) | Dictionary that **remembers insertion order** (less relevant in 3.7+) | Order-sensitive mappings, LRU cache implementation | Guaranteed **order preservation**, **move_to_end() method** | Regular dict preserves order in 3.7+, more memory | `from collections import OrderedDict`
`od = OrderedDict()`
`od.move_to_end('key')` | 8, 9 | | NamedTuple (collections) | **Tuple subclass with named fields** | Lightweight data containers, function returns, immutable records | **Named access**, less boilerplate than classes, memory efficient | **Immutable**, no default values (use **typing.NamedTuple** instead) | `from collections import namedtuple`
`Point = namedtuple('Point', 'x y')`
`p = Point(1, 2)` | 8, 9, 10 | | ChainMap (collections) | **View of multiple dictionaries** as single mapping | Configuration overlays, nested scopes, priority lookups | **No copying dictionaries**, preserves references | Updates only affect **first mapping** | `from collections import ChainMap`
`cm = ChainMap(dict1, dict2)` | 8, 9 | --- ## Table 3: Control Flow and Loops | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | if-elif-else | **Conditional branching** based on boolean expressions | Decision making, validation, conditional execution | Simple syntax, **no switch fallthrough issues** | Can become nested and hard to read | `if x > 0:`
` print("positive")`
`elif x < 0:`
` print("negative")` | 11, 12 | | Ternary Operator | **Inline conditional expression** (value if condition else value) | Compact conditionals, assignment, inline logic | **Concise one-liner**, improves readability for simple cases | Can be hard to read when nested | `result = "yes" if x > 0 else "no"`
`max_val = a if a > b else b` | 11, 12 | | for Loop | **Iterate over sequences or iterables** | Processing collections, counting, batch operations | Pythonic, works with **any iterable**, **enumerate() support** | Less flexible than **while** for complex conditions | `for item in [1, 2, 3]:`
` print(item)`
`for i, v in enumerate(lst):` | 11, 12 | | while Loop | **Execute block while condition is True** | Indefinite iteration, state-based loops, waiting | Flexible conditions, useful when **count unknown** | **Risk of infinite loops** if condition never becomes False | `while x < 10:`
` x += 1`
`while True:`
` if done: break` | 11, 12 | | break Statement | **Exit loop immediately** | Early termination, search patterns, error conditions | Clear intent, **avoids unnecessary iterations** | Can make control flow harder to follow | `for i in range(100):`
` if found: break` | 11, 12 | | continue Statement | **Skip rest of current iteration**, continue with next | Filtering during iteration, skip invalid data | **Cleaner than nested conditions** | Can make logic harder to follow | `for i in range(10):`
` if i % 2 == 0: continue`
` print(i)` | 11, 12 | | else with Loops | **Execute block if loop completes without break** | Search patterns, validation, not-found handling | **Explicit "not found" logic**, reduces flags | Uncommon pattern, can be confusing to some | `for i in items:`
` if i == target: break`
`else:`
` print("not found")` | 11, 12 | | pass Statement | **Null operation placeholder** | Empty functions/classes, future implementation | Valid syntax for **incomplete code** | Should be replaced with actual implementation | `def todo():`
` pass`
`class Empty:`
` pass` | 11, 12 | | match-case (3.10+) | **Structural pattern matching** (switch-like statement) | Complex conditionals, parsing, data validation | **Pattern matching, destructuring**, exhaustiveness | Only **Python 3.10+**, can be verbose | `match value:`
` case 0: print("zero")`
` case [x, y]: print(f"{x}, {y}")` | 13, 14 | --- ## Table 4: Functions and Parameters | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | Basic Function | **Define reusable code blocks** with def keyword | Code organization, reusability, abstraction | Clear syntax, **docstring support**, return values | **Mutable default arguments** can cause bugs | `def greet(name):`
` return f"Hello {name}"`
`result = greet("Alice")` | 15, 16 | | Default Arguments | **Function parameters with default values** | Optional parameters, backward compatibility | Reduces function overloading need, cleaner API | **Mutable defaults (lists, dicts) are shared across calls** | `def func(x, y=10):`
` return x + y`
`func(5) # y defaults to 10` | 15, 16 | | *args (Variable Positional) | **Accept arbitrary number of positional arguments as tuple** | Variadic functions, wrappers, flexible APIs | **Flexible argument count**, maintains order | Type hints less specific, requires unpacking | `def sum_all(*args):`
` return sum(args)`
`sum_all(1, 2, 3, 4)` | 17, 18 | | **kwargs (Variable Keyword) | **Accept arbitrary number of keyword arguments as dictionary** | Configuration, flexible APIs, decorators | **Named arguments**, flexible, self-documenting | More memory overhead, key errors possible | `def config(**kwargs):`
` print(kwargs)`
`config(debug=True, port=8080)` | 17, 18 | | Keyword-Only Arguments | **Parameters that must be passed by name (after *)** | Explicit APIs, prevent positional confusion | Forces named arguments, improves clarity | Slightly more verbose to call | `def func(x, *, y, z):`
` pass`
`func(1, y=2, z=3) # must name y, z` | 15, 16, 18 | | Positional-Only Arguments (3.8+) | **Parameters that must be passed positionally (before /)** | API stability, prevent keyword name conflicts | Protects parameter names from being part of API | Only **Python 3.8+**, less commonly used | `def func(x, y, /):`
` pass`
`func(1, 2) # cannot use keywords` | 15, 16, 18 | | Lambda Functions | **Anonymous one-line functions** | Inline functions, callbacks, sorting keys | Concise, no name pollution, **functional style** | **Limited to single expression**, no statements | `square = lambda x: x**2`
`sorted(lst, key=lambda x: x[1])` | 19, 20 | | Return Multiple Values | **Return tuple that can be unpacked** | Multiple outputs, coordinate pairs, status+data | Pythonic, **auto tuple packing/unpacking** | Can be confusing if too many values returned | `def minmax(lst):`
` return min(lst), max(lst)`
`lo, hi = minmax([1,5,3])` | 15, 16 | | Docstrings | **Documentation strings** for functions/classes/modules | Documentation, **help() system**, API docs | Built-in documentation, accessible via **__doc__** | Not enforced, can become outdated | `def func(x):`
` """Calculate square."""`
` return x**2` | 15, 16 | | Type Hints | **Annotate parameter and return types** | Documentation, static analysis, IDE support | **Better tooling**, catches type errors, self-documenting | Not enforced at runtime, requires **mypy** for checking | `def add(x: int, y: int) -> int:`
` return x + y` | 21, 22, 23 | --- ## Table 5: Comprehensions and Generators | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | List Comprehension | **Create lists using inline for loop** and optional condition | List transformation, filtering, mapping | Concise, **faster than loops**, readable for simple cases | Can be hard to read when nested or complex | `squares = [x**2 for x in range(10)]`
`evens = [x for x in lst if x % 2 == 0]` | 24, 25 | | Dict Comprehension | **Create dictionaries using inline for loop** | Dictionary transformation, filtering, inversion | **Concise dictionary creation**, readable | Can be complex with nested structures | `sq_dict = {x: x**2 for x in range(5)}`
`inv = {v: k for k, v in d.items()}` | 24, 26 | | Set Comprehension | **Create sets using inline for loop** | Set creation with transformation/filtering | **Automatic deduplication**, concise | Similar syntax to dict can be confusing | `unique_sq = {x**2 for x in [1,2,2,3]}`
`vowels = {c for c in text if c in 'aeiou'}` | 24, 25 | | Generator Expression | **Create iterators using parentheses** instead of brackets | Memory-efficient iteration, large datasets, pipelines | **Lazy evaluation**, low memory footprint | **Can only iterate once**, slower than lists for multiple access | `gen = (x**2 for x in range(1000000))`
`sum(x for x in range(100))` | 27, 28 | | Generator Function | **Function that yields values one at a time using yield** | Infinite sequences, streaming data, stateful iteration | Memory efficient, **maintains state between calls** | Must iterate to get values, **cannot index** | `def fibonacci():`
` a, b = 0, 1`
` while True:`
` yield a`
` a, b = b, a+b` | 27, 28, 29 | | yield from | **Delegate to another generator** (flatten nested generators) | Composing generators, recursive generators, reducing boilerplate | Cleaner than manual iteration, preserves **send/throw** | Only in generator functions, Python 3.3+ | `def all_items():`
` yield from list1`
` yield from list2` | 27, 29 | | Nested Comprehension | **Comprehension with multiple for clauses** | Flatten nested structures, matrix operations | Concise, functional style | Can be very hard to read, consider regular loops | `flat = [item for sublist in nested for item in sublist]`
`matrix = [[i*j for j in range(3)] for i in range(3)]` | 24, 25 | --- ## Table 6: String Operations and Formatting | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | String Concatenation | Join strings with **+ or join() method** | Building strings, combining text | Simple syntax, **+= works** | **Inefficient for many operations**, creates many objects | `s = "Hello" + " " + "World"`
`words = " ".join(["a", "b", "c"])` | 30, 31 | | f-strings (3.6+) | **Formatted string literals with embedded expressions** | String interpolation, formatting, logging | **Fast, readable, inline expressions** | Python 3.6+, cannot be used in some contexts | `name = "Alice"`
`msg = f"Hello {name}"`
`f"{value:.2f}"` | 32, 33, 34 | | str.format() | **Format strings using placeholder syntax** | Template strings, positional/keyword arguments | Flexible, works with older Python versions | More verbose than **f-strings**, slower | `"Hello {}".format(name)`
`"{0} {1}".format(first, last)`
`"{x:.2f}".format(x=3.14)` | 30, 31, 33 | | % Formatting | **Old-style printf-like formatting** | Legacy code, simple formatting | Compatible with Python 2, familiar to C programmers | **Less readable, error-prone, deprecated style** | `"Hello %s" % name`
`"Value: %.2f" % 3.14159` | 30, 31 | | str.split() | **Split string into list by delimiter** | Parsing, tokenization, CSV processing | Simple, common operation, **maxsplit parameter** | Default splits on any whitespace, can produce empty strings | `words = "a,b,c".split(",")`
`parts = text.split(maxsplit=1)` | 30, 31 | | str.strip() | **Remove leading/trailing characters** (default whitespace) | Cleaning input, removing whitespace | Common operation, **lstrip/rstrip variants** | Only removes from ends, not middle | `cleaned = " hello ".strip()`
`s.strip(".,")` | 30, 31 | | str.replace() | **Replace occurrences of substring** | Text transformation, sanitization | Simple, **count parameter for limiting** | Replaces all by default, **not regex** | `s = "hello".replace("l", "L")`
`s.replace("old", "new", 1)` | 30, 31 | | str.upper/lower/title() | **Case conversion methods** | Normalization, display formatting, comparison | Simple, clear intent | Locale-dependent for some characters | `s.upper()`
`s.lower()`
`s.title()`
`s.capitalize()` | 30, 31 | | str.startswith/endswith() | Check string prefix/suffix | Validation, filtering, parsing | Cleaner than slicing, accepts tuples | Case sensitive unless you handle it | `filename.endswith('.txt')`
`url.startswith(('http://', 'https://'))` | 30, 31 | | String Slicing | Extract substring using [start:stop:step] notation | Substring extraction, reversal, sampling | Flexible, powerful, Pythonic | Can be confusing with negative indices | `s[0:5]`
`s[::2] # every 2nd char`
`s[::-1] # reverse` | 35, 36, 37 | | raw strings (r'...') | String literals that ignore escape sequences | Regex patterns, file paths, LaTeX | Backslashes treated literally | Cannot end with odd number of backslashes | `pattern = r'\d+'`
`path = r'C:\Users\name'` | 30, 31 | --- ## Table 7: File I/O and Context Managers | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | with Statement | **Context manager for automatic resource cleanup** | File operations, connections, locks | **Automatic cleanup, exception-safe**, readable | Requires context manager protocol | `with open('file.txt') as f:`
` data = f.read()` | 38, 39, 40 | | open() Function | **Open file and return file object** | Reading/writing files, text/binary I/O | Built-in, mode parameter (**'r', 'w', 'a', 'b'**) | Must **close file manually** without **with** | `f = open('file.txt', 'r')`
`content = f.read()`
`f.close()` | 38, 39 | | read() / readline() / readlines() | **Read file content in different ways** | File processing, line-by-line reading | Flexible reading options | **read() loads entire file into memory** | `f.read() # all`
`f.readline() # one line`
`f.readlines() # list of lines` | 38, 39 | | write() / writelines() | **Write string(s) to file** | Creating files, logging, data export | Simple API, buffered writes | **Does not add newlines automatically** | `f.write("Hello\n")`
`f.writelines(["line1\n", "line2\n"])` | 38, 39 | | File Iteration | **Iterate over file object line by line** | Processing large files, streaming | **Memory efficient**, Pythonic | Each line includes **\n character** | `with open('file.txt') as f:`
` for line in f:`
` print(line.strip())` | 38, 39 | | pathlib.Path | **Object-oriented filesystem path operations** | Modern path handling, cross-platform code | **Cleaner API than os.path**, chainable methods | **Python 3.4+**, different API from **os.path** | `from pathlib import Path`
`p = Path('file.txt')`
`p.read_text()` | 41, 42, 43 | | os.path | **Traditional path manipulation module** | Path operations, compatibility | Works with older Python, familiar | **String-based**, less intuitive than **pathlib** | `import os.path`
`os.path.join('dir', 'file.txt')`
`os.path.exists(path)` | 41, 44 | | Custom Context Manager (class) | **Create custom resource manager** with __enter__ and __exit__ | Custom cleanup, resource management, state management | **Full control over setup/cleanup**, reusable | More boilerplate than **contextlib.contextmanager** | `class Manager:`
` def __enter__(self):`
` return self`
` def __exit__(self, *args):`
` pass` | 38, 39, 40 | | @contextmanager Decorator | **Create context manager from generator function** | Quick context managers, less boilerplate | Less code than class-based, cleaner | Requires **contextlib** import, **yield only once** | `from contextlib import contextmanager`
`@contextmanager`
`def manager():`
` yield obj` | 38, 39, 40 | --- ## Table 8: Exception Handling | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | try-except | **Catch and handle exceptions** | Error handling, validation, robustness | **Prevents crashes**, graceful error handling | Can hide bugs if too broad | `try:`
` result = 10 / 0`
`except ZeroDivisionError:`
` print("Cannot divide by zero")` | 45, 46 | | Multiple except Clauses | **Handle different exception types differently** | Specific error handling, logging | Different handling per exception type | **Order matters (most specific first)** | `try:`
` code()`
`except ValueError:`
` handle_value_error()`
`except TypeError:`
` handle_type_error()` | 45, 46 | | except Exception as e | **Capture exception object for inspection** | Logging errors, debugging, re-raising | Access exception details, message, traceback | **Catching Exception catches almost everything** | `try:`
` risky()`
`except ValueError as e:`
` print(f"Error: {e}")` | 45, 46 | | try-except-else | **Execute block only if no exception occurred** | Success handling, separation of concerns | Clearer than putting code in try block | Less commonly known, can be confusing | `try:`
` result = func()`
`except Error:`
` handle()`
`else:`
` success()` | 45, 46 | | try-except-finally | **Execute cleanup code regardless of exceptions** | Resource cleanup, closing connections/files | **Guaranteed execution**, cleanup safety | **Always runs, even with return in try/except** | `try:`
` f = open('file')`
`except IOError:`
` handle()`
`finally:`
` f.close()` | 45, 46 | | raise Statement | **Raise exceptions manually** | Validation, error signaling, re-raising | Explicit error signaling, custom messages | Should use appropriate exception types | `if x < 0:`
` raise ValueError("x must be positive")`
`raise # re-raise caught exception` | 45, 46 | | Custom Exceptions | **Define application-specific exception classes** | Domain errors, library APIs, specific errors | **Semantic meaning**, can catch specifically | Additional code, must inherit from **Exception** | `class ValidationError(Exception):`
` pass`
`raise ValidationError("Invalid input")` | 45, 46 | | Exception Chaining (from) | **Link exceptions to show causation** | Debugging, context preservation | Preserves **original error context** | **Python 3+**, more verbose | `try:`
` process()`
`except ValueError as e:`
` raise CustomError("Failed") from e` | 45, 46 | | assert Statement | **Check conditions during development** | Testing, invariants, debugging | **Removed with -O flag**, clear intent | Not for production validation, **can be disabled** | `assert x > 0, "x must be positive"`
`assert isinstance(x, int)` | 45, 46 | --- ## Table 9: Object-Oriented Programming | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | Class Definition | **Define custom types with class keyword** | Custom data types, encapsulation, modeling | Code organization, reusability, **state management** | Overhead for simple data, can be over-engineered | `class Person:`
` def __init__(self, name):`
` self.name = name` | 47, 48 | | Instance Methods | **Methods that operate on instance (self)** | Object behavior, state modification | Access to instance data, **encapsulation** | Require instance to call | `class Dog:`
` def bark(self):`
` print("Woof!")` | 47, 48 | | Class Methods (@classmethod) | **Methods that operate on class (cls)**, not instance | Alternative constructors, **factory methods** | Access to class variables, can instantiate class | **Cannot access instance variables** | `class Date:`
` @classmethod`
` def from_string(cls, s):`
` return cls(...)` | 47, 48 | | Static Methods (@staticmethod) | **Methods that don't access instance or class** | Utility functions, namespace organization | No implicit first argument, clearer intent | Could be module function instead | `class Math:`
` @staticmethod`
` def add(x, y):`
` return x + y` | 47, 48 | | Inheritance | **Create subclass that extends parent class** | Code reuse, specialization, polymorphism | **Reuse parent code**, override methods | Can create **tight coupling**, deep hierarchies complex | `class Dog(Animal):`
` def bark(self):`
` print("Woof!")` | 47, 48, 49 | | Multiple Inheritance | **Inherit from multiple parent classes** | Mixins, composition, **diamond problem** | Flexible composition, **mixin patterns** | **Method Resolution Order (MRO)** complexity | `class Child(Parent1, Parent2):`
` pass`
`Child.mro() # check order` | 47, 48, 49 | | super() | **Call parent class methods** | Cooperative inheritance, initialization | Proper method resolution, supports multiple inheritance | Must understand **MRO** for multiple inheritance | `class Child(Parent):`
` def __init__(self):`
` super().__init__()` | 47, 48, 49 | | Property Decorator (@property) | **Create managed attributes with getter/setter** | Encapsulation, validation, computed attributes | **Attribute-like access to methods**, validation hooks | Can hide expensive computation | `class Circle:`
` @property`
` def area(self):`
` return pi * r**2` | 47, 48, 50 | | __init__ Constructor | **Initialize new instances** | Object setup, attribute initialization | **Standard initialization hook**, called automatically | Not same as **__new__**, which creates the instance | `def __init__(self, x, y):`
` self.x = x`
` self.y = y` | 47, 48 | | __str__ and __repr__ | **String representations of object** | Printing, debugging, logging | **User-friendly (__str__) and developer-friendly (__repr__)** | **__repr__ should be unambiguous**, ideally eval-able | `def __str__(self):`
` return f"Point({self.x}, {self.y})"`
`def __repr__(self):`
` return f"Point(x={self.x}, y={self.y})"` | 47, 48, 51 | | __eq__ and other comparisons | **Implement equality and comparison operators** | Sorting, equality checks, comparisons | **Custom equality logic**, enables sorting | Must also implement **__hash__** if immutable | `def __eq__(self, other):`
` return self.id == other.id`
`def __lt__(self, other):`
` return self.value < other.value` | 47, 48, 51 | | __len__, __getitem__, __setitem__ | **Make object behave like sequence/container** | Custom containers, collections | **Enables indexing, len(), iteration** | Must follow protocol consistently | `def __len__(self):`
` return len(self.data)`
`def __getitem__(self, key):`
` return self.data[key]` | 47, 48, 51 | | __call__ | **Make object callable like a function** | Functors, callbacks, decorators | **Stateful functions**, clearer than closures for complex state | Can be confusing, less obvious than methods | `class Adder:`
` def __init__(self, n):`
` self.n = n`
` def __call__(self, x):`
` return x + self.n` | 47, 48, 51 | | __enter__ and __exit__ | **Implement context manager protocol** | Resource management, setup/teardown | Use with **'with' statement, automatic cleanup** | Requires both methods, error handling in **__exit__** | `def __enter__(self):`
` return self`
`def __exit__(self, *args):`
` self.close()` | 38, 39, 40 | --- ## Table 10: Decorators and Functional Programming | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | Function Decorators | **Functions that wrap other functions** to modify behavior | Logging, timing, validation, caching | Clean syntax, reusable, **separation of concerns** | Can make debugging harder, adds call overhead | `def log(func):`
` def wrapper(*args):`
` print(f"Calling {func.__name__}")`
` return func(*args)`
` return wrapper` | 52, 53, 54 | | @wraps Decorator | **Preserve original function metadata in wrapper** | All decorators, introspection | **Preserves __name__, __doc__, etc.** | Must import from **functools** | `from functools import wraps`
`def decorator(f):`
` @wraps(f)`
` def wrapper(*args):`
` return f(*args)`
` return wrapper` | 52, 53, 55 | | Class Decorators | **Decorators that modify classes** | Adding methods, validation, registration | Modify class behavior, **cleaner than metaclasses** | Less common, can be harder to understand | `def add_method(cls):`
` cls.new_method = lambda self: "hi"`
` return cls`
`@add_method`
`class MyClass: pass` | 52, 53 | | map() Function | **Apply function to all items in iterable** | Transformation, functional style, **lazy evaluation** | Functional style, lazy, works with any iterable | **Returns iterator (not list)**, can be less readable than comprehension | `squares = map(lambda x: x**2, [1,2,3])`
`result = list(map(str, [1,2,3]))` | 56, 57, 58 | | filter() Function | **Select items from iterable where function returns True** | Filtering, selection, data cleaning | Functional style, lazy, clear intent | **Returns iterator**, can be less readable than comprehension | `evens = filter(lambda x: x%2==0, range(10))`
`adults = filter(lambda p: p.age>=18, people)` | 56, 57, 58 | | reduce() Function | **Apply function cumulatively** to reduce iterable to single value | Aggregation, accumulation, folding | Functional style, **powerful for aggregations** | Less readable than loops for complex logic, **requires import** | `from functools import reduce`
`product = reduce(lambda x,y: x*y, [1,2,3,4])`
`total = reduce(operator.add, nums)` | 56, 57, 58, 59 | | partial() Function | **Create new function with some arguments pre-filled** | Callback customization, function specialization | Flexible, **cleaner than lambdas** for complex cases | Less obvious than full function definition | `from functools import partial`
`double = partial(multiply, 2)`
`double(5) # 10` | 55, 59 | | lru_cache Decorator | **Memoize function results with LRU cache** | Expensive computations, recursion, optimization | **Automatic caching**, performance boost | Memory usage, **not for functions with mutable args** | `from functools import lru_cache`
`@lru_cache(maxsize=128)`
`def fibonacci(n):`
` if n < 2: return n`
` return fibonacci(n-1) + fibonacci(n-2)` | 55, 59, 60 | | cache Decorator (3.9+) | **Unlimited memoization** (like lru_cache without size limit) | Pure functions, recursive computations | Simpler than **lru_cache**, no size management | **Can use unlimited memory**, Python 3.9+ | `from functools import cache`
`@cache`
`def expensive_func(x):`
` return complex_computation(x)` | 55, 59 | | Closure | **Function that captures variables** from enclosing scope | Factory functions, data hiding, callbacks | **Encapsulation without classes**, stateful functions | Can be confusing, debugging harder | `def make_multiplier(n):`
` def multiply(x):`
` return x * n`
` return multiply`
`double = make_multiplier(2)` | 61, 62 | --- ## Table 11: Iterators and Iteration Tools | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | Iterator Protocol | **Objects implementing __iter__ and __next__** | Custom iteration, lazy sequences | **Memory efficient**, standard protocol | More code than generators | `class Counter:`
` def __iter__(self): return self`
` def __next__(self):`
` self.n += 1; return self.n` | 63, 64 | | iter() Function | **Create iterator from iterable or callable** | Iteration, **sentinel values** | Works with callables (**sentinel pattern**) | Two-argument form less known | `it = iter([1, 2, 3])`
`it = iter(callable, sentinel)` | 63, 64 | | next() Function | **Get next item from iterator** | Manual iteration, peeking, default values | **Default value on StopIteration** | Raises **StopIteration** when exhausted | `it = iter([1, 2])`
`next(it) # 1`
`next(it, None) # default if exhausted` | 63, 64 | | enumerate() | **Add counter to iterable** (returns index, value pairs) | Indexed iteration, numbering | Cleaner than manual counter, **start parameter** | Creates tuples (slight overhead) | `for i, val in enumerate(['a','b','c']):`
` print(f"{i}: {val}")`
`enumerate(lst, start=1)` | 63, 65 | | zip() | **Combine multiple iterables element-wise** | Parallel iteration, pairing, transposing | **Stops at shortest iterable**, clean syntax | **Truncates to shortest**, use zip_longest for different behavior | `for x, y in zip([1,2,3], ['a','b','c']):`
` print(x, y)`
`dict(zip(keys, values))` | 63, 65 | | zip_longest (itertools) | **Zip iterables, filling shorter ones** with fillvalue | Parallel iteration with different lengths | **Doesn't truncate**, explicit fill value | Requires **itertools** import | `from itertools import zip_longest`
`for x, y in zip_longest([1,2], ['a','b','c'], fillvalue=0):`
` print(x, y)` | 66, 67 | | chain (itertools) | **Chain multiple iterables** into single iterable | Flattening, concatenation, sequential processing | **Lazy, memory efficient** | Doesn't work with nested iterables (use **chain.from_iterable**) | `from itertools import chain`
`for x in chain([1,2], [3,4], [5,6]):`
` print(x)` | 66, 67 | | count (itertools) | **Infinite counter** starting from value with step | Numbering, infinite sequences, testing | **Infinite, customizable start/step** | Infinite (must break or limit) | `from itertools import count`
`for i in count(10, 2):`
` if i > 20: break`
` print(i)` | 66, 67 | | cycle (itertools) | **Repeat iterable infinitely** | Circular iteration, round-robin | **Infinite cycling** | **Infinite (must break)**, stores all values | `from itertools import cycle`
`for item in cycle(['A','B','C']):`
` print(item)`
` if done: break` | 66, 67 | | repeat (itertools) | **Repeat value n times or infinitely** | Padding, default values, testing | Simple repetition, optional limit | Infinite without **times** parameter | `from itertools import repeat`
`list(repeat(10, 3)) # [10,10,10]`
`for x in repeat('x', 5): print(x)` | 66, 67 | | islice (itertools) | **Slice iterator without loading all data** | Large datasets, pagination, sampling | **Memory efficient**, works on any iterator | **Cannot use negative indices** | `from itertools import islice`
`first_10 = list(islice(iterator, 10))`
`every_3rd = islice(iter, 0, None, 3)` | 66, 67 | | product (itertools) | **Cartesian product of iterables** | Combinations, grids, nested loops | **Cleaner than nested loops** | Memory usage grows **multiplicatively** | `from itertools import product`
`for x, y in product([1,2], ['a','b']):`
` print(x, y)` | 66, 67 | | combinations (itertools) | **All k-length combinations** (order doesn't matter) | Subset generation, analysis | Standard algorithm, **no duplicates** | Can be memory intensive for large inputs | `from itertools import combinations`
`list(combinations([1,2,3], 2))`
`# [(1,2), (1,3), (2,3)]` | 66, 67 | | permutations (itertools) | **All k-length permutations** (order matters) | Arrangements, ordering problems | Standard algorithm | **Factorial growth**, memory intensive | `from itertools import permutations`
`list(permutations([1,2,3], 2))`
`# [(1,2), (1,3), (2,1), (2,3), ...]` | 66, 67 | | groupby (itertools) | **Group consecutive elements by key function** | Grouping, aggregation, run-length encoding | **Efficient for sorted data** | **Only groups consecutive elements** | `from itertools import groupby`
`for key, group in groupby([1,1,2,2,3]):`
` print(key, list(group))` | 66, 67 | --- ## Table 12: Advanced Techniques and Modern Features | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | Type Hints (typing) | **Static type annotations for variables, functions, and classes** | Documentation, static analysis, IDE support, mypy | **Better tooling, catches errors early**, self-documenting | Not enforced at runtime, additional syntax | `from typing import List, Dict`
`def process(items: List[int]) -> Dict[str, int]:`
` return {"count": len(items)}` | 21, 22, 23 | | dataclass Decorator | **Auto-generate special methods for data classes** | Data containers, DTOs, configuration | **Less boilerplate**, __init__/__repr__/__eq__ auto-generated | **Python 3.7+**, less flexible than regular classes | `from dataclasses import dataclass`
`@dataclass`
`class Point:`
` x: int`
` y: int` | 68, 69, 70 | | NamedTuple (typing) | **Typed version of collections.namedtuple** | Immutable records, type-safe tuples | **Type hints, default values, immutable** | Immutable, slightly more overhead than tuple | `from typing import NamedTuple`
`class Point(NamedTuple):`
` x: int`
` y: int = 0` | 68, 69, 70 | | Enum Class | **Define enumerations with named constants** | Constants, state machines, options | **Type-safe**, clear intent, IDE support | More verbose than simple strings/ints | `from enum import Enum`
`class Color(Enum):`
` RED = 1`
` GREEN = 2` | 71, 72 | | Walrus Operator := (3.8+) | **Assignment expressions (assign and use in expression)** | Inline assignment, reduce duplication in conditionals | **More concise, avoid repeated evaluation** | **Python 3.8+**, can reduce readability if overused | `if (n := len(data)) > 10:`
` print(f"{n} items")`
`while (line := f.readline()):`
` process(line)` | 73, 74, 75 | | match-case Statement (3.10+) | **Structural pattern matching (advanced switch)** | Complex conditionals, parsing, destructuring | **Pattern matching, destructuring**, more powerful than if-elif | **Python 3.10+**, new syntax to learn | `match point:`
` case (0, 0): print("origin")`
` case (x, 0): print(f"x-axis {x}")`
` case (x, y): print(f"point {x},{y}")` | 13, 14, 76 | | async/await | **Asynchronous programming with coroutines** | Concurrent I/O, web servers, API calls | **Non-blocking I/O, efficient concurrency** | More complex, requires async ecosystem | `async def fetch(url):`
` async with aiohttp.get(url) as resp:`
` return await resp.text()`
`await fetch('http://...')` | 77, 78, 79 | | asyncio.gather() | **Run multiple coroutines concurrently** | Parallel async operations, batch processing | Efficient concurrency, simple API | Only for async functions, error handling needs care | `import asyncio`
`results = await asyncio.gather(`
` fetch(url1), fetch(url2), fetch(url3)`
`)` | 77, 78, 79 | | asyncio.create_task() | **Schedule coroutine to run concurrently** | Background tasks, fire-and-forget | **Non-blocking**, returns Task object | Must await or manage task lifetime | `task = asyncio.create_task(long_operation())`
`# do other work`
`result = await task` | 77, 78, 79 | | Virtual Environments (venv) | **Isolated Python environments for projects** | Dependency management, project isolation | **No package conflicts**, reproducible environments | Need to activate, manage per-project | `python -m venv myenv`
`source myenv/bin/activate # Unix`
`myenv\Scripts\activate # Windows` | 80, 81, 82 | | requirements.txt | **List project dependencies with versions** | Dependency management, deployment, reproducibility | Simple format, **pip install -r** | Manual management, no dependency resolution | `# requirements.txt`
`requests==2.28.0`
`numpy>=1.20`
`pip install -r requirements.txt` | 80, 81, 82 | | Slice Objects | **Named slice notation for readability** | Array/sequence slicing, data processing | **Reusable slice definitions**, clearer intent | Less commonly known | `HEADER = slice(0, 10)`
`BODY = slice(10, -10)`
`data[HEADER]`
`items[2:10:2] == items[slice(2,10,2)]` | 35, 36, 37 | | collections.ChainMap | **View multiple dicts as single mapping** | Configuration, scoped lookups, priority | **No dict copying, preserves original dicts** | Updates only affect first dict | `from collections import ChainMap`
`combined = ChainMap(overrides, defaults)`
`combined['key'] # searches in order` | 8, 9 | --- ## Table 13: Working with Modules and Imports | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | import Statement | **Import entire module** | Access module functions/classes via module name | Clear namespace, no conflicts | More verbose to use | `import math`
`result = math.sqrt(16)` | 83, 84 | | from...import | **Import specific names from module** | Direct access to imported names | Less verbose, cleaner code | Can cause naming conflicts | `from math import sqrt, pi`
`result = sqrt(16)` | 83, 84 | | import...as | **Import with alias** | Shorten long names, avoid conflicts | Concise, **conventional aliases (np, pd)** | Can be unclear without context | `import numpy as np`
`import pandas as pd`
`arr = np.array([1, 2, 3])` | 83, 84 | | from...import * | **Import all names from module** | Interactive use, convenience | Quick access to everything | **Pollutes namespace**, unclear origins, **avoid in production** | `from math import *`
`result = sqrt(16) # where's sqrt from?` | 83, 84 | | Relative Imports | **Import from package-relative location** | Package-internal imports, refactoring | **Clearer package structure**, easier refactoring | Only works within packages, confusing for beginners | `from . import module # same level`
`from .. import module # parent`
`from .subpkg import module` | 83, 84 | | __init__.py | **Package initialization file** | Package definition, namespace management | **Defines package**, can expose API, run initialization | Not required in 3.3+ (namespace packages) | `# mypackage/__init__.py`
`from .module import MyClass`
`__all__ = ['MyClass']` | 83, 84 | | __all__ Variable | **Define public API for module/package** | Control import * behavior, documentation | **Explicit API, controls what's exported** | Only affects from module import *, not regular imports | `# module.py`
`__all__ = ['public_func', 'PublicClass']`
`def public_func(): pass`
`def _private_func(): pass` | 83, 84 | | if __name__ == "__main__" | **Execute code only when script is run directly** | Script vs module distinction, testing | **Module can be imported or run**, clear entry point | Boilerplate, not needed for pure libraries | `def main():`
` print("Running script")`
`if __name__ == "__main__":`
` main()` | 83, 84 | | importlib | **Programmatic import control** | Dynamic imports, plugin systems | Import by string name, reload modules | More complex, rarely needed | `import importlib`
`mod = importlib.import_module('mymodule')`
`importlib.reload(module)` | 83, 85 | --- ## Table 14: Data Serialization and Formats | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | json Module | **Encode/decode JSON data** | API communication, configuration, data exchange | **Human-readable, language-agnostic**, built-in | Only basic types, no date/datetime support | `import json`
`data = json.loads('{"key": "value"}')`
`json_str = json.dumps(data, indent=2)` | 86, 87, 88 | | json.dump/load | **Write/read JSON to/from file** | File storage, configuration files | **Simple file I/O integration** | Same limitations as dumps/loads | `with open('data.json', 'w') as f:`
` json.dump(data, f)`
`with open('data.json') as f:`
` data = json.load(f)` | 86, 87, 88 | | pickle Module | **Serialize Python objects to bytes** | Caching, IPC, object persistence | **Preserves Python objects exactly**, including custom classes | **Security risk (untrusted data)**, Python-specific | `import pickle`
`bytes_data = pickle.dumps(obj)`
`obj = pickle.loads(bytes_data)` | 89, 90 | | csv Module | **Read/write CSV files** | Data import/export, spreadsheets, tabular data | Standard format, **DictReader/Writer** for headers | No standard for complex types, encoding issues | `import csv`
`with open('data.csv') as f:`
` reader = csv.DictReader(f)`
` for row in reader: print(row)` | 91, 92 | | configparser Module | **Parse INI-style configuration files** | Application settings, configuration | Simple format, sections and options, type conversion | Limited nesting, not for complex structures | `import configparser`
`config = configparser.ConfigParser()`
`config.read('config.ini')`
`value = config['section']['key']` | 93, 94 | | base64 Module | **Encode/decode binary data as ASCII text** | Email attachments, embedding binary in text, data URLs | **Safe for text protocols**, standard encoding | 33% size increase, not encryption | `import base64`
`encoded = base64.b64encode(b'data')`
`decoded = base64.b64decode(encoded)` | 95, 96 | --- ## Table 15: Time, Date, and Regular Expressions | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | datetime.datetime | **Date and time representation** | Timestamps, scheduling, logging | **Rich API, arithmetic operations**, formatting | Naive vs aware (timezone) distinction | `from datetime import datetime`
`now = datetime.now()`
`dt = datetime(2024, 1, 15, 10, 30)` | 97, 98, 99 | | datetime.timedelta | **Time duration/difference** | Date arithmetic, intervals, delays | Simple arithmetic, readable | Limited to days, seconds, microseconds (no months) | `from datetime import timedelta`
`delta = timedelta(days=7, hours=3)`
`future = now + delta` | 97, 98, 99 | | strftime/strptime | **Format/parse datetime to/from strings** | Display formatting, parsing user input | Standard format codes, flexible | Format codes can be cryptic, locale-dependent | `dt.strftime('%Y-%m-%d %H:%M')`
`dt = datetime.strptime('2024-01-15', '%Y-%m-%d')` | 97, 98, 99 | | datetime.timezone | **Timezone-aware datetime** | UTC, timezone conversions, scheduling | **Avoid timezone bugs**, proper comparison | More complex, use zoneinfo for named timezones | `from datetime import timezone, timedelta`
`utc_now = datetime.now(timezone.utc)`
`tz = timezone(timedelta(hours=5))` | 97, 98, 99 | | time Module | **Time-related functions (Unix timestamps, sleep)** | Timestamps, delays, performance measurement | Simple API, **Unix timestamp** | **Lower level than datetime**, less intuitive | `import time`
`timestamp = time.time()`
`time.sleep(1) # wait 1 sec` | 97, 100 | | re.compile() | **Compile regex pattern for reuse** | Pattern reuse, performance optimization | **Faster repeated use**, pre-validation | Extra step, only beneficial for reuse | `import re`
`pattern = re.compile(r'\d+')`
`matches = pattern.findall(text)` | 101, 102, 103 | | re.search() | **Find first match of pattern in string** | Checking if pattern exists, extracting first match | **Returns match object with details**, simple | Only first match, use **findall** for all | `match = re.search(r'\d+', 'abc 123 def')`
`if match:`
` print(match.group()) # '123'` | 101, 102, 103 | | re.findall() | **Find all matches as list of strings** | Extracting all occurrences, data extraction | **Returns all matches**, simple return type | Returns strings not match objects | `numbers = re.findall(r'\d+', 'a1b2c3')`
`# ['1', '2', '3']` | 101, 102, 103 | | re.sub() | **Replace pattern matches in string** | Text transformation, sanitization, masking | **Powerful replacements**, callback support | Can be complex with groups and references | `result = re.sub(r'\d+', 'X', 'a1b2c3')`
`# 'aXbXcX'`
`re.sub(r'(\w+)', r'\1_', text)` | 101, 102, 103 | | re.match() vs re.fullmatch() | **Match at start vs entire string** | Validation, format checking | **Clear intent (start vs full)**, validation | match() only checks start (use search for anywhere) | `re.match(r'\d+', '123abc') # matches`
`re.fullmatch(r'\d+', '123abc') # None`
`re.fullmatch(r'\d+', '123') # matches` | 101, 102, 103 | | Regex Groups | **Capture parts of match with parentheses** | Extraction, transformation, parsing | **Named/numbered groups**, backreferences | Can be complex, careful with nesting | `m = re.search(r'(\d+)-(\d+)', '10-20')`
`m.group(1) # '10'`
`m.group(2) # '20'`
`m.groups() # ('10', '20')` | 101, 102, 103 | | Named Groups (?P) | **Name regex groups for clarity** | Complex patterns, readability, extraction | **More readable, access by name** | Slightly more verbose | `m = re.search(r'(?P\d{4})-(?P\d{2})', '2024-01')`
`m.group('year') # '2024'`
`m.groupdict()` | 101, 102, 103 | --- ## Table 16: Testing and Debugging | Technique | Description | Main Usages | Advantages | Considerations | Example | Reference | |---|---|---|---|---|---|---| | unittest Framework | **Built-in unit testing framework** | Unit tests, test suites, test automation | Included with Python, **structured, test discovery** | More verbose than pytest, requires classes | `import unittest`
`class TestMath(unittest.TestCase):`
` def test_add(self):`
` self.assertEqual(1+1, 2)` | 104, 105 | | pytest Framework | **Popular third-party testing framework** | Unit/integration tests, fixtures, plugins | **Simple assert syntax, powerful fixtures**, plugins | External dependency, learning curve | `def test_add():`
` assert 1 + 1 == 2`
`@pytest.fixture`
`def data(): return [1, 2, 3]` | 106, 107, 108 | | unittest.mock | **Mock objects for testing** | Isolate tests, replace dependencies, test interactions | **Powerful, flexible, patch decorator** | Complex API, can make tests brittle | `from unittest.mock import Mock, patch`
`mock_obj = Mock()`
`mock_obj.method.return_value = 42`
`with patch('module.func') as mock:` | 104, 105, 109 | | pytest Fixtures | **Reusable test setup code** | Setup/teardown, dependency injection | **Reusable, composable, clear dependencies** | Pytest-specific, magic-looking | `@pytest.fixture`
`def client():`
` return TestClient()`
`def test_api(client):`
` response = client.get('/')` | 106, 107, 108 | | Assertions (assert) | **Test conditions during execution** | Testing, validation, debugging | **Simple syntax**, automatic in pytest | **Disabled with -O flag**, limited message in unittest | `assert x > 0`
`assert len(items) == 3, "Wrong count"`
`self.assertEqual(a, b) # unittest` | 104, 105, 106 | | pytest.raises | **Assert exception is raised** | Testing error handling, validation | Clear syntax, **message matching** | Pytest-specific | `import pytest`
`with pytest.raises(ValueError):`
` int('abc')`
`with pytest.raises(ValueError, match='invalid'):` | 106, 107, 108 | | pdb Debugger | **Python debugger for interactive debugging** | Debugging, step execution, inspection | **Built-in, powerful**, post-mortem debugging | Command-line interface, learning curve | `import pdb`
`pdb.set_trace() # breakpoint`
`breakpoint() # Python 3.7+` | 110, 111 | | logging Module | **Record events during execution** | Logging, monitoring, debugging | **Levels, handlers, formatters**, hierarchical | Configuration can be complex | `import logging`
`logging.basicConfig(level=logging.INFO)`
`logging.info('Message')`
`logger = logging.getLogger(__name__)` | 112, 113 | | print() Debugging | **Simple output-based debugging** | Quick debugging, tracing | Immediate, no setup, simple | Not for production, **clutters code**, not structured | `print(f"Debug: {variable}")`
`print(f"{x=}") # Python 3.8+` | 2, 114 | | traceback Module | **Extract and format exception tracebacks** | Error reporting, logging, debugging | **Detailed error info**, format control | Technical output, may leak sensitive info | `import traceback`
`try: risky()`
`except Exception:`
` traceback.print_exc()`
` tb = traceback.format_exc()` | 115, 116 | | pytest Parametrize | **Run test with multiple inputs** | Test multiple cases, DRY tests | **Concise, clear test cases**, good reporting | Pytest-specific, can be complex | `@pytest.mark.parametrize('input,expected', [`
` (1, 2),`
` (2, 4),`
`])`
`def test_double(input, expected):`
` assert input*2 == expected` | 106, 107, 108 | --- ## References ### Official Python Documentation 1. Python Built-in Types - https://docs.python.org/3/library/stdtypes.html 2. Python Tutorial - https://docs.python.org/3/tutorial/ 3. Python String Methods - https://docs.python.org/3/library/stdtypes.html#string-methods 4. Python Data Structures - https://docs.python.org/3/tutorial/datastructures.html 5. Python Lists, Tuples, Sets, Dictionaries - https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range 6. Python Tuple Unpacking - https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences 7. Python Dictionary Methods - https://docs.python.org/3/library/stdtypes.html#mapping-types-dict ### Standard Library Modules 8. collections Module - https://docs.python.org/3/library/collections.html 9. itertools Module - https://docs.python.org/3/library/itertools.html 10. collections.namedtuple - https://docs.python.org/3/library/collections.html#collections.namedtuple 11. Python Control Flow - https://docs.python.org/3/tutorial/controlflow.html 12. Python if-elif-else - https://docs.python.org/3/tutorial/controlflow.html#if-statements 13. PEP 634 – Structural Pattern Matching - https://peps.python.org/pep-0634/ 14. Python match statement - https://docs.python.org/3/reference/compound_stmts.html#the-match-statement 15. Python Functions - https://docs.python.org/3/tutorial/controlflow.html#defining-functions 16. Python Function Definitions - https://docs.python.org/3/reference/compound_stmts.html#function-definitions 17. *args and **kwargs Documentation - https://docs.python.org/3/tutorial/controlflow.html#arbitrary-argument-lists 18. Python Unpacking Arguments - https://docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists 19. Python Lambda - https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions 20. Lambda Functions Guide - https://python-course.eu/advanced-python/lambda-filter-reduce-map.php ### Type Hints and Modern Features 21. typing Module - https://docs.python.org/3/library/typing.html 22. PEP 484 – Type Hints - https://peps.python.org/pep-0484/ 23. mypy Documentation - https://mypy.readthedocs.io/en/stable/ 24. List Comprehensions - https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions 25. Python Comprehensions Tutorial - https://realpython.com/list-comprehension-python/ 26. PEP 274 – Dict Comprehensions - https://peps.python.org/pep-0274/ 27. Python Generators - https://docs.python.org/3/tutorial/classes.html#generators 28. Generator Expressions - https://docs.python.org/3/reference/expressions.html#generator-expressions 29. yield and Generators - https://docs.python.org/3/reference/expressions.html#yield-expressions ### String and Formatting 30. Python String Documentation - https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str 31. Python String Methods - https://docs.python.org/3/library/stdtypes.html#string-methods 32. PEP 498 – f-strings - https://peps.python.org/pep-0498/ 33. Python String Formatting - https://realpython.com/python-f-strings/ 34. f-string Cheat Sheet - https://fstring.help/cheat/ 35. Python Slicing - https://docs.python.org/3/reference/expressions.html#slicings 36. Slice Notation Tutorial - https://www.pythonmorsels.com/slicing/ 37. Python Indexing and Slicing - https://railsware.com/blog/indexing-and-slicing-for-lists-tuples-strings-sequential-types/ ### File I/O and Context Managers 38. Python with Statement - https://docs.python.org/3/reference/compound_stmts.html#the-with-statement 39. Context Managers - https://realpython.com/python-with-statement/ 40. contextlib Module - https://docs.python.org/3/library/contextlib.html 41. pathlib Module - https://docs.python.org/3/library/pathlib.html 42. pathlib Tutorial - https://realpython.com/python-pathlib/ 43. Using pathlib - https://treyhunner.com/2018/12/why-you-should-be-using-pathlib/ 44. os.path Module - https://docs.python.org/3/library/os.path.html ### Exception Handling 45. Python Exceptions - https://docs.python.org/3/tutorial/errors.html 46. Exception Handling - https://docs.python.org/3/reference/compound_stmts.html#try ### Object-Oriented Programming 47. Python Classes - https://docs.python.org/3/tutorial/classes.html 48. Python OOP - https://realpython.com/python3-object-oriented-programming/ 49. Inheritance in Python - https://docs.python.org/3/tutorial/classes.html#inheritance 50. Property Decorator - https://docs.python.org/3/library/functions.html#property 51. Python Magic Methods - https://realpython.com/python-magic-methods/ 52. Python Decorators - https://realpython.com/primer-on-python-decorators/ 53. Decorators Tutorial - https://www.python-engineer.com/courses/advancedpython/21-contextmanagers/ 54. Decorator Pattern - https://python-patterns.guide/gang-of-four/decorator-pattern/ ### Functional Programming 55. functools Module - https://docs.python.org/3/library/functools.html 56. map() Function - https://docs.python.org/3/library/functions.html#map 57. filter() Function - https://docs.python.org/3/library/functions.html#filter 58. reduce() Function - https://docs.python.org/3/library/functools.html#functools.reduce 59. functools Tutorial - https://realpython.com/python-functools/ 60. lru_cache Decorator - https://docs.python.org/3/library/functools.html#functools.lru_cache 61. Python Closures - https://www.programiz.com/python-programming/closure 62. Closures Tutorial - https://realpython.com/inner-functions-what-are-they-good-for/ ### Iterators and Iteration 63. Iterator Protocol - https://docs.python.org/3/library/stdtypes.html#iterator-types 64. Iterators - https://docs.python.org/3/tutorial/classes.html#iterators 65. enumerate() and zip() - https://docs.python.org/3/library/functions.html#enumerate 66. itertools Module - https://docs.python.org/3/library/itertools.html 67. itertools Tutorial - https://realpython.com/python-itertools/ ### Advanced Features 68. dataclasses Module - https://docs.python.org/3/library/dataclasses.html 69. PEP 557 – Data Classes - https://peps.python.org/pep-0557/ 70. Data Classes Tutorial - https://realpython.com/python-data-classes/ 71. enum Module - https://docs.python.org/3/library/enum.html 72. Enum Tutorial - https://docs.python.org/3/howto/enum.html 73. PEP 572 – Walrus Operator - https://peps.python.org/pep-0572/ 74. Walrus Operator Guide - https://realpython.com/python-walrus-operator/ 75. Assignment Expressions - https://martinheinz.dev/blog/79 76. Pattern Matching Tutorial - https://peps.python.org/pep-0636/ ### Asynchronous Programming 77. asyncio Documentation - https://docs.python.org/3/library/asyncio.html 78. PEP 492 – async/await - https://peps.python.org/pep-0492/ 79. Async IO Tutorial - https://realpython.com/async-io-python/ ### Package Management 80. venv Module - https://docs.python.org/3/library/venv.html 81. Virtual Environments Tutorial - https://docs.python.org/3/tutorial/venv.html 82. pip and Virtual Environments - https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/ ### Modules and Imports 83. Python Modules - https://docs.python.org/3/tutorial/modules.html 84. Import System - https://docs.python.org/3/reference/import.html 85. importlib Module - https://docs.python.org/3/library/importlib.html ### Data Serialization 86. json Module - https://docs.python.org/3/library/json.html 87. Working with JSON - https://realpython.com/python-json/ 88. JSON Tutorial - https://www.w3schools.com/python/python_json.asp 89. pickle Module - https://docs.python.org/3/library/pickle.html 90. pickle Documentation - https://docs.python.org/3/library/pickle.html 91. csv Module - https://docs.python.org/3/library/csv.html 92. CSV Tutorial - https://realpython.com/python-csv/ 93. configparser Module - https://docs.python.org/3/library/configparser.html 94. ConfigParser Guide - https://docs.python.org/3/library/configparser.html 95. base64 Module - https://docs.python.org/3/library/base64.html 96. base64 Encoding - https://docs.python.org/3/library/base64.html ### Time and Date 97. datetime Module - https://docs.python.org/3/library/datetime.html 98. Working with Datetime - https://realpython.com/python-datetime/ 99. Datetime Tutorial - https://www.geeksforgeeks.org/python/working-with-datetime-objects-and-timezones-in-python/ 100. time Module - https://docs.python.org/3/library/time.html ### Regular Expressions 101. re Module - https://docs.python.org/3/library/re.html 102. Regular Expression HOWTO - https://docs.python.org/3/howto/regex.html 103. Regex Tutorial - https://realpython.com/regex-python/ ### Testing and Debugging 104. unittest Module - https://docs.python.org/3/library/unittest.html 105. unittest.mock - https://docs.python.org/3/library/unittest.mock.html 106. pytest Documentation - https://docs.pytest.org/ 107. pytest Tutorial - https://realpython.com/pytest-python-testing/ 108. pytest Fixtures - https://docs.pytest.org/en/stable/fixture.html 109. pytest-mock - https://pypi.org/project/pytest-mock/ 110. pdb Debugger - https://docs.python.org/3/library/pdb.html 111. Python Debugging - https://realpython.com/python-debugging-pdb/ 112. logging Module - https://docs.python.org/3/library/logging.html 113. Logging Tutorial - https://realpython.com/python-logging/ 114. print() Function - https://docs.python.org/3/library/functions.html#print 115. traceback Module - https://docs.python.org/3/library/traceback.html 116. Traceback Guide - https://docs.python.org/3/library/traceback.html ### Comprehensive Resources 117. Python Cheat Sheet by GitHub gto76 - https://github.com/gto76/python-cheatsheet 118. Real Python Cheat Sheet - https://realpython.com/cheatsheets/python/ 119. Python Cheat Sheet - https://pythoncheatsheet.org/ 120. DataCamp Python Cheat Sheet - https://www.datacamp.com/cheat-sheet/getting-started-with-python-cheat-sheet 121. QuickRef Python - https://quickref.me/python.html 122. Python Sheets - https://www.pythonsheets.com/ 123. Zero To Mastery Python Cheat Sheet - https://zerotomastery.io/cheatsheets/python-cheat-sheet/ 124. Google Python Style Guide - https://developers.google.com/edu/python/