# Python Cheat Sheet ## Introduction Python is a high-level, interpreted, and dynamically-typed programming language known for its clean syntax, extensive standard library, and versatility across domains including web development, data science, automation, and artificial intelligence. This comprehensive cheat sheet provides essential syntax, patterns, and techniques that every Python developer should know, from fundamental data structures and control flow to advanced features like decorators, async programming, and type hints. Whether you're a beginner learning the basics or an experienced developer needing a quick reference, this guide covers the most important Python concepts with practical examples, usage contexts, advantages, considerations, and authoritative references organized into logical categories for efficient learning and reference. --- ## 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/

On This Page

On This Page