Python Cheat Sheet

'single' "double" """triple multiline""" r'\n is literal backslash-n' # raw b'bytes' # bytes

name = 'Alice' age = 30 print(f'{name} is {age}') print(f'Pi = {3.14159:.2f}') # Pi = 3.14 print(f'{1000000:,}') # 1,000,000 print(f'{name!r}') # repr print(f'{name:>10}') # right-align

'Hello' + ' World' # 'Hello World' '-' * 20 # '--------------------'

s.upper() # 'HELLO' s.lower() # 'hello' s.title() # 'Hello World' s.capitalize() # 'Hello world' s.swapcase() # invert case

s.find('sub') # index or -1 s.index('sub') # index or ValueError s.count('l') # occurrences s.startswith('H') # True/False s.endswith('.py') # True/False 'x' in s # True/False

s.strip() # remove leading/trailing whitespace s.lstrip('/') # strip left only s.replace('a', 'b') # replace all occurrences s.split(',') # list of parts s.split(',', 2) # max 2 splits ', '.join(['a','b']) # 'a, b'

s.isdigit() # all digits s.isalpha() # all letters s.isalnum() # letters or digits s.isspace() # all whitespace s.isupper() # all uppercase

'{} is {}'.format('Alice', 30) '{name} is {age}'.format(name='Alice', age=30) '{0:.2f}'.format(3.14159) # '3.14' '{:>10}'.format('hi') # ' hi' '{:0>5d}'.format(42) # '00042'

s = 'Hello, World!' s[0] # 'H' s[-1] # '!' s[0:5] # 'Hello' s[7:] # 'World!' s[:5] # 'Hello' s[::-1] # '!dlroW ,olleH' (reverse) s[::2] # every other char

s.ljust(10) # 'hello ' s.rjust(10) # ' hello' s.center(10) # ' hello ' s.zfill(8) # '000hello' '42'.zfill(5) # '00042'

nums = [1, 2, 3, 4, 5] nums[0] # 1 (first) nums[-1] # 5 (last) nums[1:3] # [2, 3] len(nums) # 5

lst.append(x) # add to end lst.insert(0, x) # insert at index lst.extend([4, 5]) # add multiple lst.remove(x) # remove first x lst.pop() # remove & return last lst.pop(0) # remove & return index 0 lst.clear() # empty the list del lst[2] # delete by index

lst.sort() # in-place ascending lst.sort(reverse=True) # in-place descending sorted(lst) # returns new list sorted(lst, key=len) # sort by length sorted(lst, key=lambda x: x[1]) # sort by index 1

x in lst # membership test lst.index(x) # first index of x lst.count(x) # count occurrences lst.reverse() # in-place reverse lst[:] # shallow copy lst.copy() # shallow copy

a, b, *rest = [1, 2, 3, 4, 5] # a=1, b=2, rest=[3,4,5] combined = [*lst1, *lst2] # merge lst + lst2 # concatenate lst * 3 # repeat

from operator import itemgetter, attrgetter rows = [{'name':'Bob','age':30},{'name':'Alice','age':25}] sorted(rows, key=itemgetter('age')) # Multi-key: age ASC, then name ASC sorted(rows, key=lambda r: (r['age'], r['name'])) # Sort objects by attribute sorted(people, key=attrgetter('last_name', 'age'))

t = (1, 2, 3) t = 1, 2, 3 # parens optional t = (42,) # single-element tuple (comma!) x, y, z = t # unpack t[0] # access (immutable) t.count(1) # count occurrences t.index(2) # find index

from collections import namedtuple Point = namedtuple('Point', ['x', 'y']) p = Point(1, 2) p.x # 1 p.y # 2

d = {'name': 'Alice', 'age': 30} d['name'] # 'Alice' d.get('age') # 30 d.get('x', 0) # 0 (default, no KeyError) 'name' in d # True

d['city'] = 'NYC' # add/update d.update({'x': 1}) # merge in d.pop('age') # remove & return d.pop('x', None) # safe remove del d['city'] # delete key d.clear() # empty dict

for key in d: # keys print(key) for k, v in d.items(): # key-value pairs print(k, v) d.keys() # dict_keys view d.values() # dict_values view

# Python 3.9+ merged = d1 | d2 # All versions merged = {**d1, **d2} # Update in place (3.9+) d1 |= d2

from collections import defaultdict, Counter dd = defaultdict(list) dd['k'].append(1) # no KeyError c = Counter(['a', 'b', 'a', 'c', 'a']) c.most_common(2) # [('a', 3), ('b', 1)] c['a'] # 3 c + Counter('abc') # add counts

from collections import deque q = deque([1, 2, 3], maxlen=5) q.append(4) # add right q.appendleft(0) # add left q.pop() # remove right q.popleft() # remove left - O(1) q.rotate(1) # rotate elements

from collections import ChainMap defaults = {'color': 'red', 'size': 10} overrides = {'color': 'blue'} config = ChainMap(overrides, defaults) config['color'] # 'blue' (overrides first) config['size'] # 10 (falls back to defaults)

s = {1, 2, 3} s = set([1, 2, 2, 3]) # {1, 2, 3} s.add(4) s.discard(10) # no error if missing s.remove(3) # KeyError if missing 2 in s # O(1) lookup

a | b # union a & b # intersection a - b # difference (in a, not b) a ^ b # symmetric difference a <= b # a is subset of b a >= b # a is superset of b

unique = list(set(my_list)) # preserves order (Python 3.7+): unique = list(dict.fromkeys(my_list))

if x > 0: print('positive') elif x == 0: print('zero') else: print('negative')

label = 'even' if n % 2 == 0 else 'odd' score = max(0, min(100, raw)) # clamp

match command: case 'quit': quit() case 'go' | 'run': move() case _: print('unknown')

for item in iterable: print(item) for i in range(5): # 0 to 4 print(i) for i, v in enumerate(lst): # index + value print(i, v) for a, b in zip(l1, l2): # parallel print(a, b)

while condition: do_something() while True: data = get_input() if data == 'quit': break

for n in nums: if n == 0: continue # skip if n < 0: break # exit loop else: print('no break') # runs if no break

range(5) # 0, 1, 2, 3, 4 range(1, 6) # 1, 2, 3, 4, 5 range(0, 10, 2) # 0, 2, 4, 6, 8 range(10, 0, -1) # 10, 9, … 1 list(range(5)) # [0, 1, 2, 3, 4]

def greet(name): """Docstring describes the function.""" return f'Hello, {name}!'

def connect(host, port=8080, secure=False): return host, port, secure connect('example.com') connect('example.com', secure=True) connect('example.com', 443, True)

def func(*args, **kwargs): print(args) # tuple of positional print(kwargs) # dict of keyword func(1, 2, x=3, y=4) # args=(1, 2), kwargs={'x': 3, 'y': 4} # Spread on call side: func(*[1, 2], **{'x': 3})

def add(a: int, b: int) -> int: return a + b def process(items: list[str]) -> dict[str, int]: return {s: len(s) for s in items}

square = lambda x: x ** 2 square(5) # 25 pairs = [(1, 'b'), (3, 'a'), (2, 'c')] sorted(pairs, key=lambda p: p[1]) # [(3, 'a'), (1, 'b'), (2, 'c')]

nums = [1, 2, 3, 4, 5] list(map(str, nums)) # ['1','2','3','4','5'] list(map(lambda x: x*2, nums)) # [2,4,6,8,10] list(filter(lambda x: x>2, nums))# [3,4,5]

from functools import reduce, partial, lru_cache reduce(lambda a, b: a+b, [1,2,3]) # 6 add5 = partial(add, b=5) add5(3) # 8 @lru_cache(maxsize=None) def fib(n): if n < 2: return n return fib(n-1) + fib(n-2)

def count_up(n): i = 0 while i < n: yield i i += 1 for x in count_up(3): print(x) # 0, 1, 2

squares = (x**2 for x in range(10)) next(squares) # 0 (lazy evaluation) sum(x**2 for x in range(100)) # memory efficient

class Dog(Animal): def __init__(self, name, breed): super().__init__(name, 'woof') self.breed = breed def speak(self): # override base = super().speak() return f'{base}!' isinstance(d, Dog) # True isinstance(d, Animal) # True

class Circle: def __init__(self, radius): self.radius = radius @property def area(self): import math return math.pi * self.radius ** 2 @classmethod def from_diameter(cls, d): return cls(d / 2) @staticmethod def is_valid(r): return r > 0

from dataclasses import dataclass, field @dataclass class Product: name: str price: float tags: list[str] = field(default_factory=list) p = Product('Book', 9.99) # __init__, __repr__, __eq__ auto-generated

__init__ # constructor __repr__ # repr(obj) __str__ # str(obj) / print __len__ # len(obj) __eq__ # obj == other __lt__ # obj < other (enables sort) __add__ # obj + other __getitem__ # obj[key] __iter__ # for x in obj __next__ # next(obj) __enter__ # with obj as … __exit__ # end of with block

class Point: __slots__ = ('x', 'y') # no __dict__ def __init__(self, x, y): self.x = x self.y = y # p.z = 1 → AttributeError # Useful when creating millions of instances

from abc import ABC, abstractmethod class Shape(ABC): @abstractmethod def area(self) -> float: ... @abstractmethod def perimeter(self) -> float: ... class Circle(Shape): def __init__(self, r): self.r = r def area(self): import math; return math.pi * self.r**2 def perimeter(self): import math; return 2 * math.pi * self.r # Shape() → TypeError: Can't instantiate abstract class

evens = [x for x in range(20) if x % 2 == 0] squares = [x**2 for x in range(10)] words = [w.lower() for w in text.split()]

lengths = {w: len(w) for w in words} inverted = {v: k for k, v in d.items()} filtered = {k: v for k, v in d.items() if v > 0}

unique_lengths = {len(w) for w in words} vowels = {c for c in text.lower() if c in 'aeiou'}

matrix = [[1,2],[3,4],[5,6]] flat = [n for row in matrix for n in row] # [1, 2, 3, 4, 5, 6]

labels = ['even' if x%2==0 else 'odd' for x in range(6)] # ['even','odd','even','odd','even','odd']

import itertools as it it.chain([1,2], [3,4]) # flatten iterables it.chain.from_iterable(matrix) # flatten nested it.product([1,2], ['a','b']) # cartesian product it.permutations([1,2,3], 2) # ordered combos it.combinations([1,2,3], 2) # unordered combos it.groupby(data, key=lambda x: x['dept']) it.islice(range(100), 10) # first 10 items it.accumulate([1,2,3,4]) # [1,3,6,10]

with open('file.txt') as f: text = f.read() # whole file as str lines = f.readlines() # list of lines line = f.readline() # one line with open('file.txt') as f: for line in f: # memory-efficient print(line.strip())

with open('out.txt', 'w') as f: f.write('Hello\n') f.writelines(['a\n', 'b\n']) with open('out.txt', 'a') as f: f.write('appended line\n')

'r' # read text (default) 'w' # write text (truncates) 'a' # append text 'rb' # read binary 'wb' # write binary 'r+' # read + write 'x' # exclusive create (fails if exists)

import json # Parse JSON string data = json.loads('{"name": "Alice"}') # Serialize to JSON string text = json.dumps(data, indent=2) # Read from file with open('data.json') as f: data = json.load(f) # Write to file with open('data.json', 'w') as f: json.dump(data, f, indent=2)

import csv with open('data.csv') as f: reader = csv.DictReader(f) for row in reader: print(row['name']) with open('out.csv', 'w', newline='') as f: w = csv.DictWriter(f, fieldnames=['name', 'age']) w.writeheader() w.writerow({'name': 'Alice', 'age': 30})

from pathlib import Path p = Path('data') / 'report.txt' p.exists() # True/False p.read_text() # read whole file p.write_text('hello') # write string p.mkdir(parents=True, exist_ok=True) p.suffix # '.txt' p.stem # 'report' p.parent # Path('data') list(p.parent.glob('*.txt')) # glob

try: result = risky_operation() except ValueError as e: print(f'Value error: {e}') except (TypeError, KeyError): print('Type or Key error') except Exception as e: print(f'Unexpected: {e}') else: print('No exception raised') finally: print('Always runs')

raise ValueError('bad input') raise # re-raise current exception raise RuntimeError('context') from e # chained

class AppError(Exception): pass class NotFoundError(AppError): def __init__(self, resource): self.resource = resource super().__init__(f'{resource} not found') raise NotFoundError('user')

with open('file.txt') as f: data = f.read() # file auto-closed even on exception with A() as a, B() as b: # multiple do(a, b)

from contextlib import contextmanager @contextmanager def timer(): import time start = time.time() try: yield finally: elapsed = time.time() - start print(f'Elapsed: {elapsed:.3f}s') with timer(): do_work()

ValueError # wrong value type/format TypeError # wrong argument type KeyError # missing dict key IndexError # list index out of range AttributeError # object has no attribute FileNotFoundError # file missing ZeroDivisionError # division by zero StopIteration # iterator exhausted RuntimeError # generic runtime error

import math import numpy as np # alias from os import path from os.path import join, exists from typing import Optional, List

def main(): print('Running as script') if __name__ == '__main__': main()

os, sys, pathlib # filesystem, env re # regular expressions json, csv # data formats datetime, time # dates & timing collections # Counter, defaultdict, deque itertools, functools # functional tools math, random # math & randomness threading, asyncio # concurrency subprocess # run shell commands logging # structured logging unittest, pytest # testing

import functools def log_calls(func): @functools.wraps(func) def wrapper(*args, **kwargs): print(f'Calling {func.__name__}') result = func(*args, **kwargs) print(f'Done') return result return wrapper @log_calls def greet(name): print(f'Hello {name}')

def retry(times=3): def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): for i in range(times): try: return func(*args, **kwargs) except Exception: if i == times - 1: raise return wrapper return decorator @retry(times=5) def flaky_request(): ...

len(x) # length range(n) # integer sequence enumerate(lst) # (index, value) pairs zip(a, b) # pair elements reversed(lst) # reverse iterator sorted(lst) # new sorted list list(iterable) # convert to list tuple(iterable) # convert to tuple set(iterable) # convert to set dict(pairs) # convert to dict

abs(x) # absolute value round(x, n) # round to n decimals min(a, b, ...) # minimum max(a, b, ...) # maximum sum(iterable) # sum pow(x, y) # x**y any(iterable) # True if any truthy all(iterable) # True if all truthy

type(x) # type of x isinstance(x, T) # is x an instance of T? issubclass(A, B) # is A a subclass of B? dir(x) # list attributes/methods vars(x) # __dict__ of x hasattr(x, 'n') # does x have attribute n? getattr(x, 'n') # get attribute by name setattr(x, 'n', v) # set attribute callable(x) # is x callable? id(x) # memory address

print(*args, sep=' ', end='\n') input(prompt) # read from stdin open(file, mode) # open file repr(x) # developer string str(x) # user string format(x, spec) # format with spec chr(65) # 'A' ord('A') # 65 hex(255) # '0xff' bin(8) # '0b1000'

names = ['a', 'b', 'c'] scores = [90, 85, 92] for name, score in zip(names, scores): print(name, score) dict(zip(names, scores)) # {'a': 90, 'b': 85, 'c': 92} list(map(str, scores)) # ['90', '85', '92']

async def main(): task = asyncio.create_task(fetch('url')) # do other things here... result = await task # wait when ready

import asyncio async def main(): try: async with asyncio.timeout(5.0): result = await slow_operation() except TimeoutError: print('Timed out')

async def main(): async for item in async_generator(): print(item)

async with aiohttp.ClientSession() as session: async with session.get(url) as resp: data = await resp.json()

async def paginate(url): page = 1 while True: data = await fetch(url, page=page) if not data: break yield data page += 1 async for page in paginate('https://api.example.com'): process(page)

import aiofiles async def read_file(path): async with aiofiles.open(path) as f: return await f.read() async def write_file(path, data): async with aiofiles.open(path, 'w') as f: await f.write(data)

import re m = re.search(r'\d+', 'abc 42 def') if m: m.group() # '42' m.start() # 4 m.end() # 6 m.span() # (4, 6)

m = re.match(r'\d+', '42 abc') # matches m = re.match(r'\d+', 'abc 42') # None

re.findall(r'\d+', 'a1 b22 c333') # ['1', '22', '333'] re.findall(r'(\w+)=(\w+)', 'a=1 b=2') # [('a', '1'), ('b', '2')]

for m in re.finditer(r'\d+', 'a1 b22 c333'): print(m.group(), m.start())

re.sub(r'\s+', ' ', 'hello world') # 'hello world' re.sub(r'(\w+)', r'[\1]', 'a b') # '[a] [b]' re.sub(r'\d+', lambda m: str(int(m.group())*2), '3 cats') # '6 cats'

re.split(r'[\s,;]+', 'a b,c;;d') # ['a', 'b', 'c', 'd']

pat = re.compile(r'\b[A-Z]\w+', re.IGNORECASE) pat.search(text) pat.findall(text) pat.sub('WORD', text)

m = re.search(r'(\d{4})-(\d{2})-(\d{2})', '2024-03-15') m.group(0) # '2024-03-15' (full match) m.group(1) # '2024' m.group(2) # '03' m.groups() # ('2024', '03', '15')

m = re.search( r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})', '2024-03-15' ) m.group('year') # '2024' m.groupdict() # {'year': '2024', 'month': '03', 'day': '15'}

re.IGNORECASE # re.I - case-insensitive re.MULTILINE # re.M - ^ and $ match line start/end re.DOTALL # re.S - . matches newline too re.VERBOSE # re.X - allow whitespace and comments # Combine flags: re.compile(r'\w+', re.I | re.M) # Inline flag in pattern: re.search(r'(?i)hello', text)

# Positive lookahead: followed by re.findall(r'\d+(?= dollars)', '100 dollars 50 euros') # ['100'] # Negative lookahead: not followed by re.findall(r'\d+(?! dollars)', '100 dollars 50 euros') # ['50'] # Positive lookbehind: preceded by re.findall(r'(?<=\$)\d+', '$100 €50') # ['100']

# Email (simplified) r'[\w.+-]+@[\w-]+\.[a-z]{2,}' # URL r'https?://[\w/:%#@$&?()~.=+-]+' # US phone r'\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}' # IPv4 r'\b(?:\d{1,3}\.){3}\d{1,3}\b'

date_pat = re.compile(r""" (?P<year> \d{4}) - # four-digit year (?P<month> \d{2}) - # two-digit month (?P<day> \d{2}) # two-digit day """, re.VERBOSE)

x: int = 42 name: str = 'Alice' items: list[int] = [] mapping: dict[str, int] = {} def process(data: list[str]) -> dict[str, int]: return {s: len(s) for s in data}

from typing import Optional, Union # Old style (all versions) def find(key: str) -> Optional[str]: ... # New style (Python 3.10+) def find(key: str) -> str | None: ... # Union of types def parse(val: str | int | float) -> str: ...

from typing import Sequence, Mapping, Callable, Iterator, Generator def total(nums: Sequence[int]) -> int: ... def apply(fn: Callable[[int], str], x: int) -> str: return fn(x) def count() -> Iterator[int]: i = 0 while True: yield i i += 1

from typing import Literal, Final # Only these specific values are allowed Mode = Literal['r', 'w', 'a'] def open_file(path: str, mode: Mode) -> None: ... # Constant that must not be reassigned MAX_RETRIES: Final = 3

from typing import TypedDict, NotRequired class User(TypedDict): name: str age: int email: NotRequired[str] # optional key user: User = {'name': 'Alice', 'age': 30}

from typing import Protocol class Drawable(Protocol): def draw(self) -> None: ... # Any class with draw() satisfies Drawable # without explicitly inheriting from it def render(shape: Drawable) -> None: shape.draw()

from typing import TypeVar T = TypeVar('T') def first(items: list[T]) -> T: return items[0] # Bounded TypeVar N = TypeVar('N', int, float) def double(x: N) -> N: return x * 2

from typing import overload @overload def process(x: int) -> int: ... @overload def process(x: str) -> str: ... def process(x): # actual implementation if isinstance(x, int): return x * 2 return x.upper()

from __future__ import annotations # Allows forward references without quotes class Node: def __init__(self, next: Node | None = None): self.next = next # Node not yet defined above