Python Complete Revision Cheat Sheet

# Variables (no declaration needed)
name = 'Alice'
age = 30
price = 9.99
is_active = True
nothing = None

# Type checking
type(name)       # str
type(age)        # int
type(price)      # float
type(is_active)  # bool

# Type conversion
int('42')        # 42
float('3.14')    # 3.14
str(100)         # '100'
bool(0)          # False
bool(1)          # True
bool('')         # False

s = 'Hello, World!'

# Common methods
s.upper()          # 'HELLO, WORLD!'
s.lower()          # 'hello, world!'
s.strip()          # removes leading/trailing whitespace
s.replace('H','J') # 'Jello, World!'
s.split(', ')      # ['Hello', 'World!']
s.startswith('He') # True
s.endswith('!')    # True
len(s)             # 13
s[0]               # 'H'
s[-1]              # '!'
s[0:5]             # 'Hello'
s[::-1]            # reverse string

# f-strings (Python 3.6+) - preferred
name = 'Alice'
age = 30
print(f'Name: {name}, Age: {age}')  # Name: Alice, Age: 30
print(f'{age * 2}')                  # 60
print(f'{price:.2f}')                # formatted float

# String joining
words = ['Python', 'is', 'great']
' '.join(words)    # 'Python is great'

# Multi-line string
text = '''Line 1
Line 2
Line 3'''

nums = [1, 2, 3, 4, 5]

# Access
nums[0]       # 1
nums[-1]      # 5
nums[1:3]     # [2, 3]
nums[::2]     # [1, 3, 5]

# Modify
nums.append(6)         # [1,2,3,4,5,6]
nums.insert(0, 0)      # insert at index
nums.extend([7, 8])    # extend with another list
nums.remove(3)         # remove first occurrence of value
nums.pop()             # remove and return last item
nums.pop(0)            # remove and return item at index
nums.sort()            # sort in place
nums.sort(reverse=True)
nums.reverse()         # reverse in place
nums.index(4)          # find index of value
nums.count(2)          # count occurrences
len(nums)              # length

# Sorted (returns new list, does not modify original)
sorted(nums)
sorted(nums, reverse=True)
sorted(words, key=len)  # sort by length

# Copy
nums_copy = nums.copy()  # shallow copy
nums_copy = nums[:]       # also shallow copy

# Check membership
3 in nums        # True
9 not in nums    # True

t = (1, 2, 3)
point = (10, 20)

# Access (same as list but immutable)
t[0]        # 1
t[-1]       # 3

# Unpacking
x, y = point          # x=10, y=20
a, *rest = (1,2,3,4)  # a=1, rest=[2,3,4]

# Single-element tuple (note the comma)
one = (42,)

# Named tuple
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
p.x  # 3
p.y  # 4

person = {'name': 'Alice', 'age': 30, 'city': 'NYC'}

# Access
person['name']              # 'Alice'
person.get('age')           # 30
person.get('salary', 0)     # 0 (default if key missing)

# Modify
person['email'] = '[email protected]' # add/update
del person['city']           # delete key
person.pop('age')            # remove and return value

# Iteration
for key in person:
    print(key)

for key, value in person.items():
    print(key, value)

for value in person.values():
    print(value)

# Check membership
'name' in person      # True
'salary' in person    # False

# Useful methods
person.keys()         # dict_keys([...])
person.values()       # dict_values([...])
person.items()        # dict_items([...])
person.update({'age': 31, 'country': 'US'})  # merge/update

# Merge (Python 3.9+)
merged = dict1 | dict2

# Default dict
from collections import defaultdict
d = defaultdict(int)
d['missing_key'] += 1  # no KeyError; defaults to 0

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}

s1.add(5)          # add element
s1.remove(1)       # remove (raises error if missing)
s1.discard(99)     # remove safely (no error)

# Set operations
s1 | s2            # union: {1,2,3,4,5,6}
s1 & s2            # intersection: {3,4}
s1 - s2            # difference: {1,2}
s1 ^ s2            # symmetric difference: {1,2,5,6}

# Membership (O(1) average)
3 in s1            # True

# Convert list to set to remove duplicates
unique = list(set([1,2,2,3,3,4]))  # [1,2,3,4]

# if / elif / else
if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
else:
    grade = 'F'

# Ternary (one-liner)
status = 'adult' if age >= 18 else 'minor'

# for loop
for i in range(5):          # 0 1 2 3 4
    print(i)

for i in range(1, 10, 2):  # 1 3 5 7 9
    print(i)

for item in my_list:
    print(item)

for i, item in enumerate(my_list):
    print(i, item)

for a, b in zip(list1, list2):
    print(a, b)

# while loop
n = 0
while n < 5:
    print(n)
    n += 1

# Loop controls
break      # exit loop entirely
continue   # skip to next iteration
pass       # do nothing placeholder

# for...else (else runs if loop completes without break)
for item in items:
    if condition:
        break
else:
    print('No break occurred')

# List comprehension
squares = [x**2 for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]
flat = [n for row in matrix for n in row]

# Dict comprehension
square_map = {x: x**2 for x in range(5)}
# {0:0, 1:1, 2:4, 3:9, 4:16}

# Set comprehension
unique_lens = {len(word) for word in words}

# Generator expression (lazy evaluation, memory efficient)
total = sum(x**2 for x in range(1000000))

# Nested with condition
result = [x*y for x in range(5) for y in range(5) if x != y]

# Basic function
def greet(name):
    return f'Hello, {name}!'

# Default parameters
def greet(name, greeting='Hello'):
    return f'{greeting}, {name}!'

# *args (variable positional arguments)
def add(*args):
    return sum(args)
add(1, 2, 3)  # 6

# **kwargs (variable keyword arguments)
def info(**kwargs):
    for k, v in kwargs.items():
        print(f'{k}: {v}')
info(name='Alice', age=30)

# Combining all
def func(a, b, *args, key='default', **kwargs):
    pass

# Lambda (anonymous function)
square = lambda x: x**2
sort_key = lambda item: item['age']
sorted(people, key=lambda p: p['age'])

# Type hints (Python 3.5+)
def add(a: int, b: int) -> int:
    return a + b

# Unpacking arguments
def add(a, b, c):
    return a + b + c

args = [1, 2, 3]
add(*args)          # positional unpacking

kwargs = {'a':1, 'b':2, 'c':3}
add(**kwargs)        # keyword unpacking

# Basic decorator
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print('Before call')
        result = func(*args, **kwargs)
        print('After call')
        return result
    return wrapper

@my_decorator
def say_hello():
    print('Hello!')

# functools.wraps (preserves function metadata)
from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

# Common built-in decorators
@staticmethod    # no self or cls parameter
@classmethod     # receives cls instead of self
@property        # access method like an attribute

class Animal:
    species = 'Unknown'       # class variable (shared)

    def __init__(self, name, age):
        self.name = name      # instance variable
        self.age = age

    def speak(self):
        return f'{self.name} makes a sound'

    def __str__(self):
        return f'Animal({self.name}, {self.age})'

    def __repr__(self):
        return f'Animal(name={self.name!r}, age={self.age!r})'

    @classmethod
    def from_dict(cls, data):
        return cls(data['name'], data['age'])

    @staticmethod
    def is_valid_age(age):
        return age > 0


# Inheritance
class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)  # call parent __init__
        self.breed = breed

    def speak(self):              # method override
        return f'{self.name} says Woof!'


# Multiple inheritance
class C(A, B):
    pass

# Abstract class
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

# try / except / else / finally
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f'Error: {e}')
except (TypeError, ValueError) as e:
    print(f'Type or Value error: {e}')
except Exception as e:
    print(f'Unexpected error: {e}')
else:
    print('No error occurred')   # runs if no exception
finally:
    print('Always runs')          # cleanup code

# Raise exceptions
raise ValueError('Invalid input')
raise TypeError(f'Expected int, got {type(x)}')

# Custom exception
class InsufficientFundsError(Exception):
    def __init__(self, amount, balance):
        self.amount = amount
        self.balance = balance
        super().__init__(f'Cannot withdraw {amount}, balance is {balance}')

# Context manager (with statement)
with open('file.txt', 'r') as f:
    content = f.read()
# file automatically closed after block

# Read entire file
with open('data.txt', 'r') as f:
    content = f.read()         # entire file as string

# Read line by line (memory efficient)
with open('data.txt', 'r') as f:
    for line in f:
        print(line.strip())

# Read all lines into list
with open('data.txt', 'r') as f:
    lines = f.readlines()      # list of strings with newlines

# Write to file
with open('output.txt', 'w') as f:   # 'w' overwrites
    f.write('Hello\n')

with open('log.txt', 'a') as f:      # 'a' appends
    f.write('New log entry\n')

# Write multiple lines
lines = ['line1\n', 'line2\n', 'line3\n']
with open('output.txt', 'w') as f:
    f.writelines(lines)

# JSON
import json

with open('data.json', 'r') as f:
    data = json.load(f)        # file to dict

with open('data.json', 'w') as f:
    json.dump(data, f, indent=2)

json_str = json.dumps(data)    # dict to JSON string
data = json.loads(json_str)    # JSON string to dict

# CSV
import csv

with open('data.csv', 'r') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row['column_name'])

# Generator function (uses yield)
def count_up(n):
    i = 0
    while i < n:
        yield i
        i += 1

for num in count_up(5):
    print(num)  # 0 1 2 3 4

# Generator expression
gen = (x**2 for x in range(10))
next(gen)  # 0
next(gen)  # 1

# Custom iterator
class Countdown:
    def __init__(self, n):
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        if self.n <= 0:
            raise StopIteration
        self.n -= 1
        return self.n + 1

# itertools (very useful)
import itertools

itertools.chain([1,2], [3,4])           # [1,2,3,4]
itertools.combinations([1,2,3], 2)      # (1,2),(1,3),(2,3)
itertools.permutations([1,2,3], 2)
itertools.product([1,2], [3,4])         # cartesian product
itertools.groupby(data, key=lambda x: x['dept'])
itertools.islice(generator, 5)          # take first 5

# Import styles
import math
from math import sqrt, pi
from math import sqrt as sq
from os import path as p
import numpy as np       # aliased import

# Useful standard library modules
import os           # OS operations, path handling
import sys          # system parameters and functions
import re           # regular expressions
import json         # JSON encode/decode
import datetime     # date and time
import collections  # Counter, defaultdict, deque, OrderedDict
import itertools    # combinatoric iterators
import functools    # reduce, lru_cache, wraps, partial
import pathlib      # modern file path handling
import logging      # logging framework
import copy         # shallow and deep copy
import random       # random numbers
import string       # string constants
import time         # time functions
import threading    # thread-based parallelism
import subprocess   # run shell commands

# __name__ guard (entry point check)
if __name__ == '__main__':
    main()

# Sequence operations
len([1,2,3])             # 3
sum([1,2,3])             # 6
min([3,1,2])             # 1
max([3,1,2])             # 3
abs(-5)                  # 5
round(3.14159, 2)        # 3.14
sorted([3,1,2])          # [1,2,3]
reversed([1,2,3])        # iterator
enumerate(['a','b'])     # (0,'a'),(1,'b')
zip([1,2],[3,4])         # (1,3),(2,4)
map(str, [1,2,3])        # ['1','2','3']
filter(None, [0,1,'',2]) # [1,2]
any([0, False, 1])       # True
all([1, True, 'a'])      # True

# Object introspection
type(obj)                # type of object
isinstance(obj, int)     # True if obj is int or subclass
hasattr(obj, 'method')   # check attribute exists
getattr(obj, 'name')     # get attribute value
setattr(obj, 'name', v)  # set attribute value
dir(obj)                 # list all attributes/methods
vars(obj)                # __dict__ of object
callable(obj)            # True if obj is callable

# Functional tools
from functools import reduce, lru_cache, partial

reduce(lambda a,b: a+b, [1,2,3,4])  # 10

@lru_cache(maxsize=128)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

double = partial(pow, exp=2)
double(3)  # 9

import re

text = 'Contact: [email protected] or [email protected]'

# Match at start
re.match(r'Contact', text)

# Search anywhere
re.search(r'\w+@\w+\.\w+', text)

# Find all matches
re.findall(r'\w+@\w+\.\w+', text)
# ['[email protected]', '[email protected]']

# Substitute
re.sub(r'\s+', '-', 'hello world')  # 'hello-world'

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

# Compile for reuse (faster in loops)
pattern = re.compile(r'\d+')
pattern.findall('123 abc 456')      # ['123', '456']

# Common patterns
r'\d+'      # one or more digits
r'\w+'      # one or more word chars
r'\s+'      # one or more whitespace
r'^start'   # starts with
r'end$'     # ends with
r'[a-z]+'   # lowercase letters
r'(\d{3})-?(\d{4})'  # groups

from datetime import datetime, date, timedelta

now = datetime.now()               # current datetime
today = date.today()               # current date

# Create specific datetime
dt = datetime(2026, 1, 15, 10, 30) # year,month,day,hour,min

# Formatting
dt.strftime('%Y-%m-%d %H:%M:%S')   # '2026-01-15 10:30:00'
dt.strftime('%d/%m/%Y')            # '15/01/2026'

# Parsing
datetime.strptime('2026-01-15', '%Y-%m-%d')

# Arithmetic
tomorrow = today + timedelta(days=1)
next_week = today + timedelta(weeks=1)
diff = datetime(2026,12,31) - datetime.now()  # timedelta
diff.days                          # number of days