Python Cheatsheet

• Windows: python.org/downloads → check "Add to PATH"
• macOS: brew install python3
• Linux: sudo apt install python3

# Check version
$ python --version
$ python3 --version

# Start interactive REPL
$ python3
>>> exit()  # or Ctrl+D

$ python script.py          # run file
$ python3 -i script.py     # run, drop to REPL
$ python -c 'print(42)'    # one-liner
$ python -m module_name    # run as module
$ python -m http.server    # common example
$ python -m pytest         # run pytest

# REPL special vars
>>> _           # last result
>>> help(str)   # built-in help
>>> dir(list)   # attributes/methods

#!/usr/bin/env python3  # shebang (Unix)
# -*- coding: utf-8 -*-  # encoding

def main():
    print("Hello, World!")

if __name__ == '__main__':
    main()  # only when executed directly
            # NOT when imported

# Single-line comment
x = 5  # Inline comment

"""Module-level docstring."""

def greet(name: str) -> str:
    """
    Return greeting for name.

    Args:
        name (str): Person's name.
    Returns:
        str: Greeting string.
    Examples:
        >>> greet('Alice')
        'Hello, Alice!'
    """
    return f'Hello, {name}!'

print(greet.__doc__)   # access docstring

# --- Context Setup ---
undef_var = None
x = 0
# ---------------------

# 1. Shadowing built-ins
list = [1, 2]     # BAD! overwrites built-in list()
del list          # Fix: unbind the name

# 2. Indentation errors
if True:
    print("bad")      # IndentationError

# 3. NameError (used before assigned)
print(undef_var)  # NameError

# 4. = vs ==
# if x = 5:       # SyntaxError (assignment in if)
if x == 5: pass   # Correct (comparison)

name='Alice'; score=95.678; n=1234567

f'Hello {name}'         # Hello Alice
f'{score:.2f}'           # 95.68
f'{score:8.2f}'          # '   95.68'
f'{n:,}'                 # 1,234,567
f'{n:#010x}'             # 0x0012d687
f'{name!r}'              # "'Alice'"  (repr)
f'{name!s}'              # 'Alice'    (str)
f'{name!a}'              # 'Alice'    (ascii)
f'{score=}'              # score=95.678 (3.8+)
f'{2+2}'                 # any expression!

# Alignment
f'{name:<10}'  # 'Alice     ' (left)
f'{name:>10}'  # '     Alice' (right)
f'{name:^10}'  # '  Alice   ' (center)
f'{name:*^10}' # '**Alice***' (fill char)
f'{n:010}'     # '0001234567' (zero-pad)

# Format types
f'{0.5:%}'     # '50.000000%'
f'{65:c}'      # 'A'  (unicode char)
f'{255:b}'     # '11111111' (binary)
f'{255:o}'     # '377' (octal)
f'{255:x}'     # 'ff'  (hex lower)
f'{255:X}'     # 'FF'  (hex upper)
f'{3.14:e}'    # '3.140000e+00'
f'{3.14:g}'    # '3.14' (general)

# --- Context Setup ---
d = {"a": 1, "b": 2}
obj = {"key": "value"}
# ---------------------

# .format() method
'{} {}'.format('a', 'b')         # 'a b'
'{0} {1} {0}'.format('a', 'b')   # 'a b a'
'{name}'.format(name='Alice')   # 'Alice'
'{:.2f}'.format(3.14159)        # '3.14'
'{:>10}'.format('hi')           # '        hi'
'{0.name}'.format(obj)          # attr access
'{0[key]}'.format(d)            # item access

# % operator (legacy)
'%s is %d' % ('Alice', 30)     # 'Alice is 30'
'%.2f' % 3.14159                # '3.14'
'%10s' % 'hi'                   # '        hi'
'%r' % 'hello'                  # "'hello'"
'%x' % 255                      # 'ff'
'%o' % 8                        # '10'
'%e' % 12345.6                  # '1.234560e+04'

# string.Template
from string import Template
t = Template('Hello $name!')
t.substitute(name='Alice')     # 'Hello Alice!'
t.safe_substitute()             # no KeyError

import string
string.ascii_letters   # 'abcdef...ABCDEF...'
string.ascii_lowercase # 'abcdefghijklmnopqrstuvwxyz'
string.ascii_uppercase # 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.digits          # '0123456789'
string.hexdigits       # '0123456789abcdefABCDEF'
string.octdigits       # '01234567'
string.punctuation     # all punctuation chars
string.whitespace      # space, tab, newline...
string.printable       # all printable chars

lst = []
lst = [1, 2, 3]
lst = list(range(5))       # [0,1,2,3,4]
lst = list('abc')          # ['a','b','c']
nested = [[1,2],[3,4]]

lst[0]       # first element
lst[-1]      # last element
lst[1:3]     # slice [1, 2]
lst[::2]     # every 2nd
lst[::-1]    # reversed copy
lst[1:4] = [10, 20]  # slice assignment

# --- Context Setup ---
lst = [1, 2, 3]
x = 0
# ---------------------

lst.append(4)         # add to end
lst.extend([5,6])     # add multiple
lst.insert(0, 99)     # insert at index
lst.remove(99)        # remove first match
lst.pop()             # remove & return last
lst.pop(0)            # remove & return idx 0
lst.clear()           # remove all elements
lst.copy()            # shallow copy
lst.index(3)          # first index of 3
lst.count(3)          # count occurrences
lst.sort()            # in-place sort
lst.sort(reverse=True) # descending
lst.sort(key=lambda x: x[1])
lst.reverse()         # in-place reverse

# Built-ins with lists
sorted(lst)           # new sorted list
sorted(lst, key=len)  # sort by length
reversed(lst)         # iterator (lazy)
min(lst) / max(lst)
sum(lst)
len(lst)
3 in lst              # membership test

# --- Context Setup ---
lst = [1, 2, 3]
lst1 = [1, 2]
lst2 = [3, 4]
nested = []
objs = []
x = 0
# ---------------------

from operator import attrgetter, itemgetter

people = [{'name':'Bob','age':30},
          {'name':'Ann','age':25}]

# Sort by dict key
sorted(people, key=itemgetter('age'))
# Sort by multiple keys
sorted(people, key=itemgetter('age','name'))
# Sort objects by attribute
sorted(objs, key=attrgetter('name'))
# Reverse sort
sorted(lst, reverse=True)
# Stable sort (preserves equal order)
lst.sort(key=lambda x: x.lower())

# Copy strategies
import copy
shallow = lst.copy()        # or lst[:]
deep    = copy.deepcopy(lst)# fully independent

# Useful tricks
flat  = [x for sub in nested for x in sub]
unique = list(dict.fromkeys(lst))  # preserve order
lst1 + lst2    # concatenate
lst * 3        # repeat

# --- Context Setup ---
lst = [1, 2, 3]
matrix = [[1,2], [3,4]]
val = 0
x = 0
# ---------------------

# Advanced Slicing [start:stop:step]
lst[::-1]             # Reverse list
lst[-4:-1]           # Negative slicing
lst[::2] = [1, 2]    # Strided slice assignment

# List Comprehensions [expr for item in iter if cond]
[x**2 for x in lst]           # Basic
[x for x in lst if x%2==0]    # Filtered
[x if x>0 else 0 for x in lst] # Ternary (if/else)

# Nested List Comprehension (Matrix flattening)
[val for row in matrix for val in row]

s = {1, 2, 3}             # set literal
s = set([1, 1, 2, 3])     # from iterable
s = set()                 # empty (NOT {} ← that's dict)
fs = frozenset({1,2,3})  # immutable set

s.add(4)              # add element
s.remove(4)           # raises KeyError if missing
s.discard(4)          # no error if missing
s.pop()               # remove arbitrary element
s.clear()             # remove all
s.copy()              # shallow copy

a = {1,2,3};  b = {2,3,4}

# Operators
a | b   # {1,2,3,4}  union
a & b   # {2,3}      intersection
a - b   # {1}        difference
a ^ b   # {1,4}      symmetric difference
a <= b  # False      subset
a >= b  # False      superset
a < b   # proper subset

# Methods (same as above)
a.union(b)
a.intersection(b)
a.difference(b)
a.symmetric_difference(b)
a.issubset(b)
a.issuperset(b)
a.isdisjoint(b)       # True if no common

# In-place operations
a.update(b)                    # a |= b
a.intersection_update(b)       # a &= b
a.difference_update(b)         # a -= b
a.symmetric_difference_update(b) # a ^= b

# frozenset: hashable, usable as dict key
fs = frozenset({1,2,3})
d = {fs: 'value'}  # works!

# --- Context Setup ---
x = 0
# ---------------------

# Set Comprehensions (removes duplicates)
{x**2 for x in [1, -1, 2, -2]}  # {1, 4}
{x for x in range(10) if x % 2 == 0}

# Element Hashability Requirement
# Elements MUST be hashable (int, str, tuple)
# s = {1, [2, 3]}  # TypeError (list is unhashable)

# Fast Membership Testing (O(1) average)
'apple' in {'apple', 'banana'}  # True (Extremely fast)

# --- Context Setup ---
condition = True
s = "string"
# ---------------------

# 1. Empty set vs Empty dict
not_a_set = {}      # Creates an empty dict!
is_a_set = set()    # Creates an empty set

# 2. Mutating set during iteration
for x in s:
    if condition:
        s.remove(x) # RuntimeError: Set changed size during iteration

# 3. Sets of sets
# s = {{1, 2}, {3, 4}}  # TypeError: set is unhashable
s = {frozenset({1, 2}), frozenset({3, 4})} # Valid

def greet(name: str = 'World') -> str:
    '''Return greeting.'''
    return f'Hello, {name}!'

# Mutable default arg pitfall!
def append(item, lst=None):  # CORRECT
    if lst is None: lst = []
    lst.append(item)
    return lst

# Positional-only / keyword-only
def f(pos1, pos2, /, both, *, kw_only):
    pass
# pos1, pos2 MUST be positional (before /)
# kw_only MUST be keyword (after *)

# *args and **kwargs
def func(*args, **kwargs):
    print(args)    # tuple
    print(kwargs)  # dict

# Full order: pos → *args → kw-only → **kwargs
def full(a, b, *args, c=10, **kw): ...

# Unpacking in calls
f(*[1,2,3])        # unpack list
f(**{'a':1,'b':2}) # unpack dict

# Multiple return values
def minmax(lst):
    return min(lst), max(lst)  # returns tuple
lo, hi = minmax([3,1,4])

# --- Context Setup ---
i = 0
n = 0
p = {"age": 30}
people = [{'name':'Bob','age':30}]
s = "string"
x = 0
y = 0
# ---------------------

# Lambda: lambda args: expression (No return!)
square = lambda x: x**2
add    = lambda x, y: x + y
grade  = lambda s: 'A' if s>=90 else 'B'

# Passing as arguments
sorted(people, key=lambda p: p['age'])

# Factory (Lambda returning lambda)
multiplier = lambda n: lambda x: x * n
double = multiplier(2)

# IIFE (Immediately invoked)
(lambda x: x*2)(5)  # 10

# Walrus in Lambda
f = lambda s: (n := len(s)) ** 2

# Loop capture pitfall! (Late Binding)
# BAD: fns = [lambda: i for i in range(3)]  # all 2!
fns = [lambda i=i: i for i in range(3)] # GOOD

# --- Context Setup ---
a = 0
b = 0
x = 0
# ---------------------

# map(func, iterable)
m = map(lambda x: x**2, [1, 2, 3])
print(list(m))  # [1, 4, 9]

# filter(func, iterable)
evens = filter(lambda x: x%2==0, [1,2,3,4])
print(list(evens)) # [2, 4]

# reduce(func, iterable)
from functools import reduce
prod = reduce(lambda a,b: a*b, [1,2,3,4])
print(prod)  # 24

# Note: map/filter return lazy iterators!
print(list(m))  # [] (Exhausted)

# LEGB Scope Rule:
# Local → Enclosing → Global → Built-in
x = 'global'
def outer():
    x = 'enclosing'
    def inner():
        nonlocal x     # Modifies 'enclosing' x
        x = 'local'

# Modifying global scope
count = 0
def increment():
    global count   # Required to modify global
    count += 1

# Implicit return
def no_return(): pass
print(no_return()) # Output: None

# First-Class Function (assign to variable)
f = print
f('Hello')

# Recursion (function calls itself)
def factorial(n: int) -> int:
    if n <= 1: return 1  # Base case
    return n * factorial(n - 1)

# Recursion limit (default ~1000)
import sys
sys.setrecursionlimit(2000)

# --- Context Setup ---
abstractmethod = None
dec1 = None
dec2 = None
name = "name"
# ---------------------

from functools import wraps

def my_decorator(func):
    @wraps(func)  # preserve __name__, __doc__
    def wrapper(*args, **kwargs):
        print('before')
        result = func(*args, **kwargs)
        print('after')
        return result
    return wrapper

@my_decorator
def say_hello(): print('hello')

# Decorator with arguments (factory)
def repeat(n):
    def decorator(func):
        @wraps(func)
        def wrapper(*a, **kw):
            for _ in range(n): func(*a, **kw)
        return wrapper
    return decorator

@repeat(3)
def hi(): print('hi')

# Stacking (applied bottom-up)
@dec1
@dec2   # dec1(dec2(f))
def f(): ...

# Built-in decorators
@staticmethod   # no self/cls
@classmethod    # cls as first arg
@property       # getter
@name.setter    # setter
@name.deleter   # deleter
@abstractmethod # from abc
def _dummy(): pass

# Docstrings (__doc__)
def area(r):
    """Return the area of a circle. (PEP 257)"""
    pass

from typing import Optional, Union, Any
from typing import Callable, TypeVar, Generic

# Basic type hints
def greet(name: str) -> str: ...
def f(x: int, y: Optional[str] = None) -> Union[int,str]: ...

# Modern syntax (3.10+)
def f(x: int | None = None) -> list[int]: ...

# Generic TypeVar
T = TypeVar('T')
def first(lst: list[T]) -> T:
    return lst[0]

# TypedDict
from typing import TypedDict
class Point(TypedDict):
    x: float
    y: float

# Callable[[arg_types], return_type]
def apply(fn: Callable[[int], str], x: int): ...

# Literal
from typing import Literal
def mode(m: Literal['r','w','a']): ...

# Read entire file
with open('file.txt', encoding='utf-8') as f:
    content = f.read()

# Read line by line (memory efficient)
with open('file.txt') as f:
    for line in f:
        print(line.strip())
    lines = f.readlines()  # list of all lines
    line  = f.readline()   # one line

# Write
with open('out.txt', 'w', encoding='utf-8') as f:
    f.write('Hello\n')
    f.writelines(['a\n', 'b\n'])

# Seek / Tell
f.seek(0)   # go to start
f.tell()    # current position (bytes)
f.flush()   # flush buffer

# --- Context Setup ---
new = 0
# ---------------------

from pathlib import Path

p = Path('/home/user/docs/file.txt')
p.name       # 'file.txt'
p.stem       # 'file'
p.suffix     # '.txt'
p.suffixes   # ['.txt']
p.parent     # Path('/home/user/docs')
p.parts      # ('/', 'home', 'user', ...)
p.anchor     # '/'

Path.cwd()   # current directory
Path.home()  # home directory
p / 'subdir' / 'file.py'  # join paths

p.exists();  p.is_file();  p.is_dir()
p.is_symlink(); p.is_absolute()
p.stat()     # os.stat_result

p.mkdir(parents=True, exist_ok=True)
p.rmdir()    # must be empty
p.touch()    # create file
p.unlink()   # delete file
p.rename(new); p.replace(new)  # move

p.read_text(encoding='utf-8')
p.write_text('content')
p.read_bytes(); p.write_bytes(b'data')

list(p.iterdir())      # dir contents
list(p.glob('*.py'))  # pattern match
list(p.rglob('*.py')) # recursive
p.resolve()            # absolute real path
p.relative_to('/home/user')  # 'docs/file.txt'

import os, shutil

os.getcwd()                    # current dir
os.chdir('/tmp')              # change dir
os.listdir('.')               # list entries
os.makedirs('a/b', exist_ok=True)
os.remove('file.txt')
os.rename('old', 'new')
os.stat('file.txt')

os.environ.get('HOME')
os.getenv('PATH', '')

os.path.join('a','b','c')    # 'a/b/c'
os.path.exists('file')
os.path.dirname('/a/b/c')    # '/a/b'
os.path.basename('/a/b/c')   # 'c'
os.path.splitext('f.txt')    # ('f', '.txt')
os.path.abspath('.')
os.path.expanduser('~')

# Walk directory tree
for root, dirs, files in os.walk('.'):
    for f in files:
        print(os.path.join(root, f))

shutil.copy('src', 'dst')     # copy file
shutil.copy2('src', 'dst')    # copy + metadata
shutil.copytree('src', 'dst') # copy directory
shutil.rmtree('dir')          # remove directory
shutil.move('src', 'dst')
shutil.make_archive('out', 'zip', 'dir')

# Create virtual environment
$ python -m venv .venv
$ python3 -m venv .venv

# Activate
$ .venv\Scripts\activate        # Windows (cmd)
$ .venv\Scripts\Activate.ps1   # Windows (PS)
$ source .venv/bin/activate    # macOS/Linux
$ deactivate                   # deactivate

# pip commands
$ pip install requests
$ pip install 'requests>=2.28'
$ pip install requests==2.28.2
$ pip install -r requirements.txt
$ pip uninstall requests
$ pip list
$ pip show requests
$ pip freeze > requirements.txt
$ pip install --upgrade pip
$ pip install --user package   # user-level

# pipx (isolated tool install)
$ pipx install black
$ pipx run black script.py

# Code quality tools
$ black .         # auto-format
$ isort .         # sort imports
$ flake8 .        # style / lint
$ pylint mymod.py # deep linting
$ mypy mymod.py   # type checking
$ pytest          # run tests
$ pytest -v       # verbose
$ pytest -k 'test_name'  # filter
$ pytest --cov=. --cov-report=html

# pyproject.toml (modern)
[build-system]
requires = ['setuptools>=61']

[project]
name = 'mypackage'
version = '1.0.0'
dependencies = ['requests>=2.28']

[project.optional-dependencies]
dev = ['pytest', 'black', 'mypy']