Python 치트시트

name = "Vivory"
greeting = f"Hello, {name}!"
multiline = """First line
Second line"""
raw = r"C:\Users\path"     # raw string (no escaping)

x = 42                    # int
y = 3.14                  # float
z = 1_000_000             # readable large number
int("42")                 # str -> int
float("3.14")             # str -> float
round(3.14159, 2)         # 3.14

nums = [1, 2, 3, 4, 5]
nums.append(6)
nums.extend([7, 8])
nums.insert(0, 0)
first, *rest = nums        # unpacking
nums[-1]                   # last element
nums[1:4]                  # slice [2, 3, 4]
nums[::-1]                 # reverse

user = {"name": "Alice", "age": 30}
user["email"] = "alice@example.com"
user.get("phone", "N/A")   # default if missing
user.keys()                # dict_keys
user.values()              # dict_values
user.items()               # key-value pairs
{**user, "role": "admin"}  # merge/spread

# Sets: unordered, unique elements
tags = {"python", "dev", "ai"}
tags.add("web")
tags & {"python", "web"}   # intersection: {"python", "web"}
tags | {"rust"}            # union

# Tuples: immutable sequences
point = (10, 20)
x, y = point               # unpacking

type(42)                   # <class 'int'>
isinstance(42, int)        # True
isinstance("hi", (str, int))  # True (any of)
list("hello")              # ['h', 'e', 'l', 'l', 'o']
tuple([1, 2, 3])           # (1, 2, 3)
set([1, 1, 2])             # {1, 2}
bool(0)                    # False
bool("")                   # False

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

# Ternary
status = "pass" if score >= 60 else "fail"

for item in ["a", "b", "c"]:
    print(item)

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

for i in range(0, 10, 2):  # 0, 2, 4, 6, 8
    print(i)

names = ["Alice", "Bob", "Charlie"]
for i, name in enumerate(names):
    print(f"{i}: {name}")

scores = [90, 85, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

count = 0
while count < 5:
    if count == 3:
        count += 1
        continue       # skip 3
    print(count)
    count += 1

while True:
    data = input("Enter (q to quit): ")
    if data == "q":
        break

command = "start"
match command:
    case "start":
        print("Starting...")
    case "stop" | "quit":
        print("Stopping...")
    case _:
        print(f"Unknown: {command}")

for n in range(2, 10):
    for i in range(2, n):
        if n % i == 0:
            break
    else:
        # Only runs if inner loop had no break
        print(f"{n} is prime")

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

result = greet("World")
result = greet("World", greeting="Hi")

def log(*args, **kwargs):
    print("Args:", args)
    print("Kwargs:", kwargs)

log(1, 2, 3, level="INFO", tag="app")
# Args: (1, 2, 3)
# Kwargs: {'level': 'INFO', 'tag': 'app'}

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

# Commonly used with sorted/filter/map
users = [{"name": "Bob", "age": 25}, {"name": "Alice", "age": 30}]
sorted(users, key=lambda u: u["age"])

import functools, time

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

@timer
def slow_func():
    time.sleep(1)

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

for num in fibonacci(10):
    print(num)

# Generator expression
sum(x**2 for x in range(100))

from typing import Optional, Union

def process(data: list[str], limit: int = 10) -> dict[str, int]:
    return {item: len(item) for item in data[:limit]}

def find_user(user_id: int) -> Optional[dict]:
    ...

def parse(value: Union[str, int]) -> str:
    return str(value)

def min_max(nums: list[int]) -> tuple[int, int]:
    return min(nums), max(nums)

lo, hi = min_max([3, 1, 4, 1, 5, 9])
print(f"min={lo}, max={hi}")   # min=1, max=9

squares = [x**2 for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]

# Equivalent to:
result = []
for x in range(10):
    result.append(x**2)

word_lengths = {w: len(w) for w in ["hello", "world", "python"]}
# {'hello': 5, 'world': 5, 'python': 6}

# Swap keys and values
original = {"a": 1, "b": 2}
swapped = {v: k for k, v in original.items()}

unique_lengths = {len(w) for w in ["hi", "hello", "hey", "world"]}
# {2, 3, 5}

# Flatten a 2D list
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Create a 2D grid
grid = [[0 for _ in range(3)] for _ in range(3)]

# Filter + transform
valid_scores = [s * 10 for s in scores if s >= 60]

# if-else (value expression, not filter)
labels = ["even" if x % 2 == 0 else "odd" for x in range(5)]
# ['even', 'odd', 'even', 'odd', 'even']

# Filter and use computed value
results = [y for x in data if (y := expensive_calc(x)) > threshold]

# Read lines until empty
while (line := input("Enter: ")) != "quit":
    print(f"Got: {line}")

"hello world python".split()        # ['hello', 'world', 'python']
"a,b,c".split(",")                  # ['a', 'b', 'c']
"one::two::three".split("::", 1)    # ['one', 'two::three']

", ".join(["Alice", "Bob", "Charlie"])
# "Alice, Bob, Charlie"
"\n".join(lines)

"  hello  ".strip()             # "hello"
"  hello  ".lstrip()            # "hello  "
"hello world".replace("world", "Python")
"aabbaabb".replace("aa", "x", 1)   # "xbbaabb" (max 1)

filename = "report_2024.csv"
filename.startswith("report")     # True
filename.endswith((".csv", ".tsv"))  # True (tuple of suffixes)
"python" in "I love python"        # True

n = 42
f"{n:05d}"           # "00042" (zero-pad)
f"{3.14159:.2f}"     # "3.14"  (2 decimals)
f"{1000000:,}"       # "1,000,000" (comma sep)
f"{0.85:.1%}"        # "85.0%" (percentage)
f"{'hello':>20}"     # "               hello" (right-align)

import re

re.search(r"\d+", "order-42-shipped")   # <Match: '42'>
re.findall(r"[\w.]+@[\w.]+", text)     # extract emails
re.sub(r"\s+", " ", messy_text)        # normalize whitespace

pattern = re.compile(r"^\d{3}-\d{4}$")
pattern.match("123-4567")               # matches

"hello".upper()                # "HELLO"
"HELLO".lower()                # "hello"
"hello world".title()          # "Hello World"
"Hello".isalpha()              # True
"42".isdigit()                 # True
"hello world".count("l")       # 3
"hello world".find("world")    # 6 (-1 if not found)

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

# Read lines
with open("data.txt") as f:
    lines = f.readlines()  # list of lines

# Write
with open("output.txt", "w") as f:
    f.write("Hello\n")

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

from pathlib import Path

p = Path("src/app/main.py")
p.name                # "main.py"
p.stem                # "main"
p.suffix              # ".py"
p.parent              # Path("src/app")
p.exists()            # True/False

# Glob
for py in Path("src").rglob("*.py"):
    print(py)

import json

# Read
with open("config.json") as f:
    config = json.load(f)

# Write
with open("output.json", "w") as f:
    json.dump(data, f, indent=2, ensure_ascii=False)

# String conversion
json_str = json.dumps({"key": "value"})
obj = json.loads(json_str)

import csv

# Read
with open("data.csv") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row["name"], row["score"])

# Write
with open("output.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "score"])
    writer.writeheader()
    writer.writerow({"name": "Alice", "score": 95})

import os, shutil

os.makedirs("output/reports", exist_ok=True)
os.listdir(".")               # list directory
shutil.rmtree("build/")       # remove directory tree
shutil.copytree("src/", "backup/src/")

try:
    result = int(user_input)
    data = 10 / result
except ValueError:
    print("Not a valid number")
except ZeroDivisionError:
    print("Cannot divide by zero")
except Exception as e:
    print(f"Unexpected error: {e}")
finally:
    print("Cleanup here")

def validate_age(age: int) -> None:
    if age < 0:
        raise ValueError(f"Age cannot be negative: {age}")
    if age > 150:
        raise ValueError(f"Age unrealistic: {age}")

# Re-raise current exception
try:
    risky_operation()
except Exception:
    logger.error("Operation failed")
    raise

class AppError(Exception):
    """Base exception for our app."""

class NotFoundError(AppError):
    def __init__(self, resource: str, id: int):
        self.resource = resource
        self.id = id
        super().__init__(f"{resource} #{id} not found")

try:
    raise NotFoundError("User", 42)
except NotFoundError as e:
    print(e)   # "User #42 not found"

assert len(data) > 0, "Data cannot be empty"
assert isinstance(config, dict), f"Expected dict, got {type(config)}"

# Assertions are removed with python -O (optimized mode)
# Never use for input validation in production

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s"
)
logger = logging.getLogger(__name__)

logger.info("Server started on port %d", 8000)
logger.warning("Disk usage at %d%%", 92)
logger.error("Connection failed", exc_info=True)

class User:
    def __init__(self, name: str, email: str):
        self.name = name
        self.email = email

    def greet(self) -> str:
        return f"Hi, I'm {self.name}"

user = User("Alice", "alice@example.com")
print(user.greet())

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

    def speak(self) -> str:
        raise NotImplementedError

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

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

dog = Dog("Rex")
print(dog.speak())   # "Rex says Woof!"

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

    @property
    def radius(self) -> float:
        return self._radius

    @radius.setter
    def radius(self, value: float):
        if value < 0:
            raise ValueError("Radius must be positive")
        self._radius = value

    @property
    def area(self) -> float:
        return 3.14159 * self._radius ** 2

class DateUtils:
    @staticmethod
    def is_leap_year(year: int) -> bool:
        return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

    @classmethod
    def from_string(cls, date_str: str) -> "DateUtils":
        # Alternative constructor
        return cls()

DateUtils.is_leap_year(2024)   # True (no instance needed)

from dataclasses import dataclass, field

@dataclass
class Product:
    name: str
    price: float
    tags: list[str] = field(default_factory=list)

    @property
    def display_price(self) -> str:
        return f"${self.price:.2f}"

p = Product("Widget", 9.99, ["sale"])
print(p)   # Product(name='Widget', price=9.99, tags=['sale'])

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

    def __repr__(self) -> str:
        return f"Point({self.x}, {self.y})"

    def __str__(self) -> str:
        return f"({self.x}, {self.y})"

    def __eq__(self, other) -> bool:
        return self.x == other.x and self.y == other.y

print(Point(1, 2))         # (1, 2) — uses __str__
print(repr(Point(1, 2)))   # Point(1, 2) — uses __repr__