Python Cheat Sheet

name = "Glenn"
age = 28
height = 1.75
is_student = True
x, y, z = 10, 20, 30
a, b = 5, 10
a, b = b, a

int_num = 42
float_num = 3.14159
complex_num = 3 + 4j
big_num = 1_000_000
hex_num = 0xFF
oct_num = 0o777
bin_num = 0b1010

s = "  Hello World  "
print(s.strip())
print(s.upper())
print(s.lower())
print(s.capitalize())
print(s.title())
print(s.replace("World", "Python"))
print(s.split())
print("-".join(["a", "b", "c"]))
print(s[0:5])
print(s[6:])
print(s[::-1])

int("42")
float("3.14")
str(42)
bool(0)
bool("")
bool("hello")
list((1, 2, 3))
tuple([1, 2, 3])
set([1, 2, 2, 3])
dict([("a", 1), ("b", 2)])

None
True
False
NotImplemented
Ellipsis
print(None is None)
print(True and False)
print(Ellipsis)

10 + 3
10 - 3
10 * 3
10 / 3
10 // 3
10 % 3
10 ** 3

5 == 5
5 != 3
5 < 10
5 > 3
5 <= 5
5 >= 3

True and False
True or False
not True
print(5 > 3 and 10 < 20)
print(5 > 10 or 3 < 5)

"apple" in ["apple", "banana"]
"grape" not in ["apple", "banana"]
"a" in "hello"
5 in range(10)
x = [1, 2]
y = x
print(x is y)

5 & 3
5 | 3
5 ^ 3
~5
5 << 1
5 >> 1

if condition:
    statement
elif other_condition:
    statement
else:
    statement

result = "Pass" if score >= 70 else "Fail"

for item in iterable:
    print(item)

for i, value in enumerate(items, start=1):
    print(i, value)

for i in range(5):
    print(i)

while condition:
    statement

while True:
    if condition:
        break

count = 0
while count < 10:
    count += 1
    if count % 2 == 0:
        continue
    print(count)

match value:
    case 0:
        print("Zero")
    case n if n > 0:
        print("Positive")
    case _:
        print("Other")

numbers = [1, 2, 3]
numbers.append(4)
numbers.insert(0, 0)
value = numbers.pop()
numbers.remove(2)
numbers.sort()
squares = [x**2 for x in range(5)]
evens = [x for x in range(10) if x % 2 == 0]

person = {"name": "Alice", "age": 30}
person["city"] = "New York"
name = person.get("name", "Unknown")
age = person.pop("age")
keys = person.keys()
values = person.values()
items = person.items()
squares = {x: x**2 for x in range(5)}

a = {1, 2, 3}
b = {3, 4, 5}
a.add(6)
a.discard(2)
a.remove(3)
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)
squares = {x**2 for x in range(5)}

coords = (3, 4)
x, y = coords
first, *rest = [1, 2, 3, 4]
single = (42,)
from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
print(p.x, p.y)

range(10)
range(2, 10)
range(2, 10, 2)
list(range(5))
s = [0, 1, 2, 3, 4, 5]
s[1:4]
s[::2]
s[1::2]
s[-1]
s[-3:]
s[:3]

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

def sum_all(*args):
    return sum(args)

def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

square = lambda x: x**2
add = lambda a, b: a + b
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Time: {end - start:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Done"

def make_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))
print(triple(5))

def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model
        self.odometer = 0

    def drive(self, miles):
        self.odometer += miles
        return f"Driven {miles} miles"

    def __str__(self):
        return f"{self.make} {self.model}"

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if not value:
            raise ValueError("Name cannot be empty")
        self._name = value

from dataclasses import dataclass, field

@dataclass
class Person:
    name: str
    age: int
    email: str = ""
    hobbies: list = field(default_factory=list)

    @property
    def is_adult(self) -> bool:
        return self.age >= 18

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

    @classmethod
    def from_string(cls, s):
        parts = s.split(",")
        return cls(int(parts[0]), int(parts[1]))

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

def read_large_file(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()

class ManagedFile:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()

import asyncio

async def fetch_data(name, delay):
    await asyncio.sleep(delay)
    return f"Data from {name}"

async def main():
    results = await asyncio.gather(
        fetch_data("API 1", 1),
        fetch_data("API 2", 0.5),
        fetch_data("API 3", 1.5)
    )
    for result in results:
        print(result)

from typing import List, Dict, Optional, TypeVar, Generic

T = TypeVar("T")

def greet(name: str) -> str:
    return f"Hello, {name}"

def find_user(id: int) -> Optional[Dict[str, str]]:
    return {"name": "Alice"}

def process(items: List[int]) -> List[int]:
    return [i * 2 for i in items]

class PositiveNumber:
    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name, 0)

    def __set__(self, obj, value):
        if value < 0:
            raise ValueError("Must be positive")
        obj.__dict__[self.name] = value

with open("file.txt", "r") as f:
    content = f.read()

with open("file.txt", "w") as f:
    f.write("Hello")

with open("file.txt", "a") as f:
    f.write("New line")

import json

data = {"name": "Alice", "age": 30}
json_str = json.dumps(data, indent=2)
parsed = json.loads(json_str)

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
except ValueError:
    print("Invalid value")
else:
    print("Success")
finally:
    print("Cleanup")

class CustomError(Exception):
    def __init__(self, message, code):
        super().__init__(message)
        self.code = code

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

from functools import lru_cache

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

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0

import unittest

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(2 + 3, 5)

    def test_positive(self):
        self.assertTrue(5 > 0)