Python Cheatsheet

1
if __name__ == "__main__":
2
    main()  # Only runs when script is executed directly

1
name = "Vedant"  # str
2
age = 21         # int
3
price = 9.99     # float
4
is_active = True # bool

1
# Immutable - creates new object
2
s = "hello"
3
s[0] = "H"  # ❌ TypeError!
4

5
# Mutable - modifies same object
6
l = [1, 2, 3]
7
l[0] = 99   # ✅ Works! l = [99, 2, 3]

1
5 > 3 and 2 < 4  # True
2
'a' in 'apple'   # True
3
x is None        # True if x is None

1
False and expensive_function()  # Returns False, function NOT called
2
True and True and False and print("Never runs")  # Stops at False
3

4
0 and 5       # 0 (first falsy)
5
3 and 5       # 5 (all truthy, returns last)
6
1 and 2 and 3 # 3 (returns last truthy value)

1
True or expensive_function()  # Returns True, function NOT called
2
False or False or True or print("Never runs")  # Stops at True
3

4
0 or 5        # 5 (first truthy)
5
0 or ""       # "" (all falsy, returns last)
6
1 or 2 or 3   # 1 (returns first truthy value)

1
# Default values
2
name = user_input or "Guest"  # If user_input is empty, use "Guest"
3

4
# Guard clauses
5
if user and user.is_active and user.has_permission():
6
    # Stops checking if user is None
7

8
# Conditional execution
9
is_admin and send_admin_email()  # Only calls if is_admin is True

1
a = [1, 2, 3]
2
b = [1, 2, 3]
3
c = a
4

5
a == b   # True (same values)
6
a is b   # False (different objects in memory)
7
a is c   # True (same object)
8

9
# Always use 'is' for None
10
x = None
11
if x is None:    # ✅ Correct
12
if x == None:    # ⚠️ Works but not Pythonic

1
a = 256; b = 256
2
a is b  # True (Python caches -5 to 256)
3

4
a = 257; b = 257
5
a is b  # False (outside cache range)

1
s = "hello"; s[::-1]  # 'olleh'
2
"a,b,c".split(",")    # ['a', 'b', 'c']
3
"-".join(['a','b'])   # 'a-b'

1
name, age = "Vedant", 21
2

3
# 1. f-strings (Python 3.6+) ✅ PREFERRED
4
f"Name: {name}, Age: {age}"           # "Name: Vedant, Age: 21"
5
f"{age * 2}"                           # "42" (expressions allowed)
6
f"{3.14159:.2f}"                       # "3.14" (formatting)
7

8
# 2. .format() method
9
"Name: {}, Age: {}".format(name, age)  # positional
10
"Name: {n}, Age: {a}".format(n=name, a=age)  # named
11

12
# 3. % operator (old style)
13
"Name: %s, Age: %d" % (name, age)

1
l = [1, 2]; l.append(3)       # [1, 2, 3]
2
l.insert(1, 5)                # [1, 5, 2, 3]
3
l.extend([6, 7])              # [1, 5, 2, 3, 6, 7]
4
l.pop()                       # removes 7, returns 7
5
sorted(l)                     # returns sorted, doesn't modify l

1
t = (1, 2, 3)
2
a, b, c = t       # unpacking
3
t[0]              # access: 1
4
t.count(2)        # count occurrences
5
t.index(3)        # find index

1
s = {1, 2, 2, 3}  # {1, 2, 3} - auto removes duplicates
2
s.add(4)          # {1, 2, 3, 4}
3
{1, 2} & {2, 3}   # {2} - intersection
4

5
# Mutation variants (modify in place)
6
s1 = {1, 2, 3}
7
s1.intersection_update({2, 3, 4})  # s1 becomes {2, 3}

1
d = {'a': 1, 'b': 2}
2
d.get('c', 0)         # 0 (default)
3
d.update({'c': 3})    # {'a': 1, 'b': 2, 'c': 3}
4
for k, v in d.items(): print(k, v)
5

6
# fromkeys() - create dict with same value for all keys
7
keys = ['name', 'age', 'city']
8
default_dict = dict.fromkeys(keys, 'N/A')  # {'name': 'N/A', 'age': 'N/A', 'city': 'N/A'}
9
zero_dict = dict.fromkeys(['a', 'b', 'c'], 0)  # {'a': 0, 'b': 0, 'c': 0}

1
if condition:
2
    # code
3
elif other_condition:
4
    # code
5
else:
6
    # code
7

8
# Ternary operator
9
result = value_if_true if condition else value_if_false

1
age = 20
2
status = 'Adult' if age >= 18 else 'Minor'

1
for i in range(5):        # 0, 1, 2, 3, 4
2
for i in range(2, 7):     # 2, 3, 4, 5, 6
3
for i in range(0, 10, 2): # 0, 2, 4, 6, 8 (step=2)

1
while condition:
2
    # code

1
for i in range(5):
2
    if i == 3: break
3
    print(i)  # 0, 1, 2

1
# List comprehension
2
[expression for item in iterable if condition]
3
squares = [x**2 for x in range(5) if x % 2 == 0]  # [0, 4, 16]
4

5
# Dict comprehension
6
{key_expr: value_expr for item in iterable}
7
{x: x**2 for x in range(3)}  # {0: 0, 1: 1, 2: 4}
8

9
# Set comprehension
10
{expression for item in iterable}
11
{x % 3 for x in range(10)}  # {0, 1, 2}

1
def function_name(parameters):
2
    """Docstring: explains function"""
3
    # code
4
    return value

1
def func(a, b=10, *args, **kwargs):
2
    # a: positional
3
    # b: default value
4
    # *args: variable positional (tuple)
5
    # **kwargs: variable keyword (dict)
6
    pass
7

8
func(1)              # a=1, b=10
9
func(1, 20)          # a=1, b=20
10
func(1, 2, 3, 4)     # a=1, b=2, args=(3, 4)
11
func(1, x=5, y=10)   # a=1, b=10, kwargs={'x': 5, 'y': 10}

1
square = lambda x: x ** 2
2
square(5)  # 25
3

4
# With map/filter
5
list(map(lambda x: x*2, [1, 2, 3]))     # [2, 4, 6]
6
list(filter(lambda x: x > 2, [1, 2, 3, 4]))  # [3, 4]

1
x = 10  # global
2
def modify():
3
    global x
4
    x += 1  # modifies global x

1
# Creating iterator from iterable
2
my_list = [1, 2, 3]
3
my_iter = iter(my_list)  # Create iterator
4

5
next(my_iter)  # 1
6
next(my_iter)  # 2
7
next(my_iter)  # 3
8
next(my_iter)  # StopIteration error

1
class Counter:
2
    def __init__(self, max):
3
        self.max = max
4
        self.current = 0
5

6
    def __iter__(self):
7
        return self
8

9
    def __next__(self):
10
        if self.current < self.max:
11
            self.current += 1
12
            return self.current
13
        raise StopIteration
14

15
for num in Counter(3):
16
    print(num)  # 1, 2, 3

1
def countdown(n):
2
    while n > 0:
3
        yield n  # pauses here, returns value
4
        n -= 1
5

6
for num in countdown(3):
7
    print(num)  # 3, 2, 1
8

9
# Generator expression (like list comprehension)
10
gen = (x**2 for x in range(5))  # generator object
11
list(gen)  # [0, 1, 4, 9, 16]

1
# Infinite generator
2
def infinite_counter():
3
    n = 0
4
    while True:
5
        yield n
6
        n += 1

1
def my_decorator(func):
2
    def wrapper(*args, **kwargs):
3
        print("Before function")
4
        result = func(*args, **kwargs)
5
        print("After function")
6
        return result
7
    return wrapper
8

9
@my_decorator
10
def say_hello(name):
11
    print(f"Hello, {name}!")
12

13
say_hello("Vedant")
14
# Output:
15
# Before function
16
# Hello, Vedant!
17
# After function

1
from functools import wraps
2

3
def my_decorator(func):
4
    @wraps(func)  # ✅ Preserves __name__, __doc__, etc.
5
    def wrapper(*args, **kwargs):
6
        return func(*args, **kwargs)
7
    return wrapper
8

9
@my_decorator
10
def greet(name):
11
    """Greet someone."""
12
    return f"Hello, {name}!"
13

14
print(greet.__name__)  # 'greet' (without @wraps: 'wrapper')
15
print(greet.__doc__)   # 'Greet someone.' (without @wraps: None)

1
from functools import wraps
2

3
def repeat(times):
4
    def decorator(func):
5
        @wraps(func)
6
        def wrapper(*args, **kwargs):
7
            for _ in range(times):
8
                result = func(*args, **kwargs)
9
            return result
10
        return wrapper
11
    return decorator
12

13
@repeat(times=3)
14
def say_hello():
15
    print("Hello!")
16

17
say_hello()  # Prints "Hello!" 3 times

1
class Circle:
2
    def __init__(self, radius):
3
        self._radius = radius
4

5
    @property
6
    def radius(self):       # getter
7
        return self._radius
8

9
    @radius.setter
10
    def radius(self, value): # setter
11
        if value > 0:
12
            self._radius = value
13

14
    @property
15
    def area(self):         # computed property
16
        return 3.14 * self._radius ** 2
17

18
c = Circle(5)
19
c.radius      # 5 (uses getter)
20
c.radius = 10 # uses setter
21
c.area        # 314.0 (computed)

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name  # instance variable
4
        self.age = age
5

6
    def greet(self):
7
        return f"Hi, I'm {self.name}"
8

9
p = Person("Vedant", 21)
10
p.greet()  # "Hi, I'm Vedant"

1
class Parent:
2
    def greet(self):
3
        return "Hello from Parent"
4

5
class Child(Parent):
6
    def greet(self):
7
        parent_msg = super().greet()  # call parent
8
        return f"{parent_msg} and Child"

1
class Parent:
2
    pass
3
class Child(Parent):  # One parent
4
    pass

1
class A:
2
    pass
3
class B:
4
    pass
5
class C(A, B):  # Multiple parents
6
    pass

1
class Grandparent:
2
    pass
3
class Parent(Grandparent):
4
    pass
5
class Child(Parent):  # Chain: Grandparent → Parent → Child
6
    pass

1
class Parent:
2
    pass
3
class Child1(Parent):  # Multiple children, one parent
4
    pass
5
class Child2(Parent):
6
    pass

1
class A:
2
    def show(self): print("A")
3
class B(A):
4
    def show(self): print("B")
5
class C(A):
6
    def show(self): print("C")
7
class D(B, C):  # Diamond problem
8
    pass
9

10
print(D.mro())  # [D, B, C, A, object]
11
D().show()      # "B" (follows MRO: left to right)

1
class BankAccount:
2
    def __init__(self, balance):
3
        self.__balance = balance  # private
4

5
    def get_balance(self):  # getter
6
        return self.__balance
7

8
    def deposit(self, amount):  # setter with validation
9
        if amount > 0:
10
            self.__balance += amount

1
from abc import ABC, abstractmethod
2

3
class Shape(ABC):
4
    @abstractmethod
5
    def area(self):
6
        pass  # must be implemented by subclass
7

8
class Circle(Shape):
9
    def __init__(self, radius):
10
        self.radius = radius
11

12
    def area(self):  # implementation
13
        return 3.14 * self.radius ** 2

1
class Dog:
2
    def speak(self): return "Woof"
3

4
class Cat:
5
    def speak(self): return "Meow"
6

7
for animal in [Dog(), Cat()]:
8
    print(animal.speak())  # Different behavior, same method

1
class MyClass:
2
    class_var = 10  # class variable
3

4
    def instance_method(self):
5
        # has access to self (instance)
6
        return self.class_var
7

8
    @classmethod
9
    def class_method(cls):
10
        # has access to cls (class)
11
        return cls.class_var
12

13
    @staticmethod
14
    def static_method():
15
        # no access to self or cls
16
        return "static"

1
class Book:
2
    def __init__(self, title, pages):
3
        self.title = title
4
        self.pages = pages
5

6
    def __str__(self):      # for print()
7
        return f"{self.title}"
8

9
    def __repr__(self):     # for debugging
10
        return f"Book('{self.title}', {self.pages})"
11

12
    def __len__(self):      # for len()
13
        return self.pages
14

15
    def __eq__(self, other): # for ==
16
        return self.title == other.title
17

18
b = Book("Python", 300)
19
print(b)      # Python (__str__)
20
len(b)        # 300 (__len__)

1
# Best practice: with statement (auto-closes)
2
with open('file.txt', 'r') as f:
3
    data = f.read()
4

5
# Writing
6
with open('output.txt', 'w') as f:
7
    f.write("Hello World\n")

1
try:
2
    # code that might raise exception
3
    result = 10 / 0
4
except ZeroDivisionError as e:
5
    # handle specific exception
6
    print(f"Error: {e}")
7
except Exception as e:
8
    # handle any exception
9
    print(f"General error: {e}")
10
else:
11
    # runs if no exception
12
    print("Success!")
13
finally:
14
    # always runs (cleanup)
15
    print("Cleanup")
16

17
# Raise exceptions
18
raise ValueError("Invalid value")

1
# Raise multiple exceptions at once
2
def process_items(items):
3
    errors = []
4
    for item in items:
5
        try:
6
            validate(item)
7
        except ValueError as e:
8
            errors.append(e)
9
    if errors:
10
        raise ExceptionGroup("Validation failed", errors)
11

12
# Handle with except*
13
try:
14
    process_items([1, -1, "bad"])
15
except* ValueError as eg:
16
    print(f"Value errors: {eg.exceptions}")
17
except* TypeError as eg:
18
    print(f"Type errors: {eg.exceptions}")

1
class ValidationError(Exception):
2
    def __init__(self, field: str, message: str):
3
        self.field = field
4
        self.message = message
5
        super().__init__(f"{field}: {message}")
6

7
raise ValidationError("email", "Invalid format")

1
original = [[1, 2], [3, 4]]
2
shallow = original.copy()  # or list(original)
3

4
shallow[0][0] = 99
5
print(original)  # [[99, 2], [3, 4]] ← Original also changed!

1
import copy
2

3
original = [[1, 2], [3, 4]]
4
deep = copy.deepcopy(original)
5

6
deep[0][0] = 99
7
print(original)  # [[1, 2], [3, 4]] ← Original unchanged!

1
import copy
2

3
a = [1, [2, 3]]
4

5
# Assignment (alias)
6
b = a
7
b is a  # True (same object)
8

9
# Shallow copy
10
c = a.copy()
11
c is a      # False (different list)
12
c[1] is a[1]  # True (nested list shared!)
13

14
# Deep copy
15
d = copy.deepcopy(a)
16
d is a      # False
17
d[1] is a[1]  # False (completely independent)

1
# Variables
2
name: str = "Vedant"
3
age: int = 21
4
price: float = 9.99
5
is_active: bool = True
6

7
# Functions
8
def greet(name: str) -> str:
9
    return f"Hello, {name}!"
10

11
def add(a: int, b: int) -> int:
12
    return a + b
13

14
# None return type
15
def log(message: str) -> None:
16
    print(message)

1
# Use built-in types directly (Python 3.10+)
2
numbers: list[int] = [1, 2, 3]
3
scores: dict[str, int] = {"alice": 100}
4
coords: tuple[int, int] = (10, 20)
5
unique: set[str] = {"a", "b"}
6

7
# Nested collections
8
matrix: list[list[int]] = [[1, 2], [3, 4]]
9
user_data: dict[str, list[int]] = {"scores": [90, 85, 88]}

1
# Optional = can be None (use | None)
2
def find_user(id: int) -> str | None:
3
    return None if id < 0 else "User"
4

5
# Union = multiple possible types (use |)
6
def process(value: int | str) -> str:
7
    return str(value)
8

9
# Multiple types
10
def handle(data: int | float | str | None) -> str:
11
    return str(data) if data else "Empty"

1
from typing import Callable, TypeVar
2

3
# Function type hints
4
def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
5
    return func(a, b)
6

7
# Generic type variable
8
T = TypeVar('T')
9
def first(items: list[T]) -> T:
10
    return items[0]

1
type Vector = list[float]  # Python 3.12+ syntax
2
type Matrix = list[Vector]
3

4
# Python 3.10-3.11
5
from typing import TypeAlias
6
Vector: TypeAlias = list[float]
7
Matrix: TypeAlias = list[Vector]
8

9
def scale(v: Vector, factor: float) -> Vector:
10
    return [x * factor for x in v]

1
from typing import Self
2

3
class Builder:
4
    def set_name(self, name: str) -> Self:
5
        self.name = name
6
        return self  # Enables method chaining
7

8
    def set_age(self, age: int) -> Self:
9
        self.age = age
10
        return self
11

12
# Usage
13
builder = Builder().set_name("Vedant").set_age(21)

1
from dataclasses import dataclass
2

3
@dataclass
4
class Person:
5
    name: str
6
    age: int
7
    email: str = ""  # default value
8

9
# Auto-generated __init__, __repr__, __eq__
10
p = Person("Vedant", 21)
11
print(p)  # Person(name='Vedant', age=21, email='')
12

13
p1 = Person("Vedant", 21)
14
p2 = Person("Vedant", 21)
15
p1 == p2  # True (auto __eq__)

1
from dataclasses import dataclass, field
2

3
@dataclass(frozen=True)  # Immutable (hashable)
4
class Point:
5
    x: int
6
    y: int
7

8
@dataclass(order=True)  # Adds comparison methods
9
class Student:
10
    name: str
11
    grade: float
12

13
@dataclass(slots=True)  # Memory efficient (Python 3.10+)
14
class User:
15
    name: str
16
    age: int
17
    # Uses __slots__ instead of __dict__ → less memory, faster access
18

19
# Mutable default values - use field()
20
@dataclass
21
class Team:
22
    name: str
23
    members: list = field(default_factory=list)  # ✅ Correct
24
    # members: list = []  # ❌ WRONG! Same mutable default trap

1
from dataclasses import dataclass, field
2

3
@dataclass
4
class Rectangle:
5
    width: float
6
    height: float
7
    area: float = field(init=False)  # Not in __init__
8

9
    def __post_init__(self):
10
        self.area = self.width * self.height
11

12
r = Rectangle(10, 5)
13
r.area  # 50.0 (computed automatically)

1
def http_status(status: int) -> str:
2
    match status:
3
        case 200:
4
            return "OK"
5
        case 404:
6
            return "Not Found"
7
        case 500:
8
            return "Server Error"
9
        case _:  # default (wildcard)
10
            return "Unknown"
11

12
http_status(200)  # "OK"
13
http_status(999)  # "Unknown"

1
match status:
2
    case 200 | 201 | 204:  # Multiple values
3
        return "Success"
4
    case 400 | 401 | 403 | 404:
5
        return "Client Error"
6
    case _:
7
        return "Other"

1
def analyze(point):
2
    match point:
3
        case (0, 0):
4
            return "Origin"
5
        case (0, y):  # Capture y
6
            return f"On Y-axis at {y}"
7
        case (x, 0):  # Capture x
8
            return f"On X-axis at {x}"
9
        case (x, y):  # Capture both
10
            return f"Point at ({x}, {y})"
11
        case _:
12
            return "Not a point"
13

14
analyze((0, 5))  # "On Y-axis at 5"

1
def process_event(event: dict):
2
    match event:
3
        case {"type": "click", "x": x, "y": y}:
4
            return f"Click at ({x}, {y})"
5
        case {"type": "keypress", "key": key}:
6
            return f"Key pressed: {key}"
7
        case {"type": type_}:  # Capture unknown type
8
            return f"Unknown event: {type_}"

1
match point:
2
    case (x, y) if x == y:
3
        return "On diagonal"
4
    case (x, y) if x > 0 and y > 0:
5
        return "First quadrant"
6
    case (x, y):
7
        return f"Point at ({x}, {y})"

1
@dataclass
2
class Point:
3
    x: int
4
    y: int
5

6
def locate(point):
7
    match point:
8
        case Point(x=0, y=0):
9
            return "Origin"
10
        case Point(x=0, y=y):
11
            return f"Y-axis at {y}"
12
        case Point(x=x, y=0):
13
            return f"X-axis at {x}"
14
        case Point():
15
            return "Somewhere else"

1
# Without walrus operator
2
data = get_data()
3
if data:
4
    process(data)
5

6
# With walrus operator ✅
7
if (data := get_data()):
8
    process(data)

1
# 1. While loops with assignment
2
while (line := file.readline()):
3
    process(line)
4

5
# 2. List comprehensions with expensive computation
6
# Without walrus - calls compute() twice:
7
[compute(x) for x in data if compute(x) > 0]
8

9
# With walrus - calls compute() once: ✅
10
[y for x in data if (y := compute(x)) > 0]
11

12
# 3. Regex matching
13
import re
14
if (match := re.search(r'\d+', text)):
15
    print(f"Found: {match.group()}")
16

17
# 4. Avoiding repeated dictionary lookups
18
if (value := my_dict.get('key')) is not None:
19
    process(value)

1
# Don't use for simple assignments
2
x := 5  # ❌ SyntaxError! Must be in parentheses or expression
3

4
# Don't overuse - readability matters
5
result = (a := 1) + (b := 2) + (c := 3)  # ⚠️ Hard to read
6

7
# Keep it simple
8
a, b, c = 1, 2, 3  # ✅ Clearer
9
result = a + b + c

1
# File handling (auto-closes)
2
with open('file.txt', 'r') as f:
3
    data = f.read()
4
# f is automatically closed here
5

6
# Multiple context managers
7
with open('in.txt') as f_in, open('out.txt', 'w') as f_out:
8
    f_out.write(f_in.read())
9

10
# Threading locks
11
import threading
12
lock = threading.Lock()
13
with lock:
14
    # Critical section
15
    pass

1
class Timer:
2
    def __enter__(self):
3
        import time
4
        self.start = time.time()
5
        return self  # Returned to 'as' variable
6

7
    def __exit__(self, exc_type, exc_val, exc_tb):
8
        import time
9
        self.end = time.time()
10
        print(f"Elapsed: {self.end - self.start:.2f}s")
11
        return False  # Don't suppress exceptions
12

13
with Timer() as t:
14
    # code to time
15
    pass

1
from contextlib import contextmanager
2

3
@contextmanager
4
def timer():
5
    import time
6
    start = time.time()
7
    try:
8
        yield  # Code inside 'with' runs here
9
    finally:
10
        end = time.time()
11
        print(f"Elapsed: {end - start:.2f}s")
12

13
with timer():
14
    # code to time
15
    pass