Python 3.x Complete Cheatsheet

name = "Alice"
age = 30
f"Hello, {name}! You are {age} years old."
f"{3.14159:.2f}"          # format spec: 2 decimal places → '3.14'
f"{1000000:,}"            # thousands separator → '1,000,000'
f"{'left':<10}"           # left-align in 10 chars
f"{'right':>10}"          # right-align in 10 chars
f"{'center':^10}"         # center in 10 chars
f"{255:#x}"               # hex with prefix → '0xff'
f"{value!r}"              # repr()
f"{value!s}"              # str()
f"{value!a}"              # ascii()

"Hello, {}!".format("Alice")
"Hello, {name}!".format(name="Alice")
"{0} + {1} = {2}".format(1, 2, 3)
"{:.2f}".format(3.14159)

"Hello, %s!" % "Alice"
"Pi is %.2f" % 3.14159
"%d items at $%.2f each" % (5, 1.99)

from string import Template
t = Template("Hello, $name!")
t.substitute(name="Alice")
t.safe_substitute(name="Alice")  # won't raise on missing keys

import textwrap
textwrap.dedent(text)         # remove common leading whitespace
textwrap.indent(text, "  ")   # add prefix to each line
textwrap.wrap(text, width=70) # wrap to list of lines
textwrap.fill(text, width=70) # wrap to single string

b"hello".hex()
bytes.fromhex("68656c6c6f")
b"hello".decode("utf-8")
"hello".encode("utf-8")

open(file, mode='r', encoding=None, errors=None)

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

# Read all lines without newlines
with open("file.txt") as f:
    lines = f.read().splitlines()

# Iterate line by line (memory efficient)
with open("file.txt") as f:
    for line in f:
        print(line.strip())

# Write multiple lines
with open("file.txt", "w") as f:
    f.writelines(f"{line}\n" for line in data)

from pathlib import Path

p = Path("file.txt")
p.read_text(encoding="utf-8")
p.write_text("content")
p.exists()
p.is_file()
p.unlink()
p.rename("new.txt")
p.mkdir(parents=True, exist_ok=True)
list(p.glob("*.py"))
p.stat().st_size
p.parent / p.stem / p.suffix

x = 10
a, b, c = 1, 2, 3
a, *rest = [1, 2, 3, 4]
x, y = y, x              # swap values

if x > 0:
    ...
elif x == 0:
    ...
else:
    ...

value = "yes" if condition else "no"

# match (3.10+)
match command:
    case "quit":
        ...
    case "go" | "move":
        ...
    case _:
        ...

for item in iterable:
    if condition: continue
    if condition: break
else:
    # runs if loop did not break
    ...

def func(pos, /, normal, *, kw_only, key=default, **kwargs):
    """Docstring."""
    return value

fn = lambda x, y: x + y

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

[x*2 for x in range(10) if x % 2 == 0]       # list
{x: x**2 for x in range(5)}                   # dict
{x for x in range(5)}                         # set
(x*2 for x in range(10))                      # generator

class Animal:
    class_var = "shared"

    def __init__(self, name):
        self.name = name

    def speak(self):
        ...

    @classmethod
    def create(cls, name):
        return cls(name)

    @staticmethod
    def info():
        ...

    @property
    def label(self):
        return self.name.upper()

class Dog(Animal):
    def speak(self):
        super().speak()

try:
    risky()
except ValueError as e:
    handle(e)
except (TypeError, KeyError):
    ...
else:
    # runs if no exception
    ...
finally:
    # always runs
    ...

raise ValueError("message")

class MyError(Exception):
    def __init__(self, msg):
        super().__init__(msg)

def count_up(n):
    for i in range(n):
        yield i

gen = count_up(5)
next(gen)       # 0
list(gen)       # [1, 2, 3, 4]

squares = (x**2 for x in range(10))

def chain(*iters):
    for it in iters:
        yield from it

import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("before")
        result = func(*args, **kwargs)
        print("after")
        return result
    return wrapper

@my_decorator
def hello():
    print("hello")

def repeat(n):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

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

from contextlib import contextmanager

@contextmanager
def managed_resource():
    setup()
    try:
        yield resource
    finally:
        teardown()

class ManagedResource:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        cleanup()
        return False

import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch_data()
    tasks = [asyncio.create_task(fetch_data()) for _ in range(3)]
    results = await asyncio.gather(*tasks)

asyncio.run(main())

from typing import Optional, Union, List, Dict

def func(x: int, y: float = 1.0) -> str: ...
def f(items: list[int]) -> dict[str, int]: ...   # 3.9+ built-in generics
def f(val: int | None) -> str | None: ...        # 3.10+ union syntax

if n := len(data):
    print(f"List has {n} items")

while chunk := f.read(8192):
    process(chunk)

if __name__ == "__main__":
    main()

class Point:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x, self.y = x, y