Python 기초 문법 완전 정리

Python code

# 동적 타이핑 — 타입 선언 불필요
name = "Python"
version = 3.12
is_awesome = True
count = 100

# 타입 힌트 (Python 3.5+) — 런타임 강제 아님, IDE/mypy용
salary: int = 50_000_000
user_name: str = "Alice"
ratio: float = 0.75
active: bool = True

# 여러 변수 동시 할당
x, y, z = 1, 2, 3
a = b = c = 0

# 타입 확인
print(type(name))     # <class 'str'>
print(type(version))  # <class 'float'>
print(isinstance(name, str))  # True

# 언더스코어로 숫자 가독성
population = 51_000_000
pi = 3.141_592_653

# None — null에 해당
result = None
print(result is None)  # True (== 대신 is 사용)

Python code

name = "  python developer  "
score = 98.765

# f-string 포맷팅 (Python 3.6+)
print(f"이름: {name.strip()}")
print(f"점수: {score:.2f}")          # 소수점 2자리
print(f"퍼센트: {score / 100:.1%}") # 백분율
print(f"{'중앙정렬':^20}")           # 패딩/정렬
print(f"{1000000:,}")               # 천단위 콤마

# 주요 문자열 메서드
s = "Hello, Python World"
print(s.upper())           # HELLO, PYTHON WORLD
print(s.lower())           # hello, python world
print(s.replace("Python", "Kotlin"))
print(s.split(", "))       # ['Hello', 'Python World']
print(s.startswith("Hello"))  # True
print(s.strip())           # 앞뒤 공백 제거
print(s.find("Python"))    # 7 (인덱스)
print(s.count("l"))        # 3

# 슬라이싱 [start:stop:step]
text = "Hello World"
print(text[0:5])    # Hello
print(text[-5:])    # World
print(text[::-1])   # dlroW olleH (역순)

# join
words = ["Python", "is", "awesome"]
print(" ".join(words))  # Python is awesome

Python code

score = 85

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

# 한 줄 조건식 (삼항 연산자)
result = "합격" if score >= 60 else "불합격"

# 연속 비교 (Python만의 특징)
if 80 <= score < 90:
    print("B등급")

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

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

# enumerate — 인덱스와 값 동시에
fruits = ["🍎", "🍌", "🍇"]
for idx, fruit in enumerate(fruits, start=1):
    print(f"{idx}: {fruit}")

# zip — 두 리스트 병렬 순회
names  = ["Alice", "Bob"]
scores = [95, 87]
for name, sc in zip(names, scores):
    print(f"{name}: {sc}")

# for-else: break 없이 완료되면 else 실행
for n in range(2, 10):
    if 7 % n == 0 and n != 7:
        print(f"{n}는 7의 약수")
        break
else:
    print("7은 소수")

Python code

# 리스트 컴프리헨션
squares = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 조건 필터
evens = [x for x in range(20) if x % 2 == 0]

# 중첩 컴프리헨션
matrix = [[i * j for j in range(1, 4)] for i in range(1, 4)]
flat   = [x for row in matrix for x in row]

# 딕셔너리 컴프리헨션
words = ["python", "kotlin", "golang"]
word_len = {w: len(w) for w in words}
# {'python': 6, 'kotlin': 6, 'golang': 6}

# 세트 컴프리헨션 (중복 제거)
letters = {c for c in "programming" if c not in "aeiou"}

# 제너레이터 표현식 (메모리 효율)
gen = (x**2 for x in range(1_000_000))   # 즉시 계산 안 함
print(next(gen))   # 0
print(next(gen))   # 1

# sum()에 제너레이터 전달 (괄호 하나로)
total = sum(x**2 for x in range(100))

# walrus operator := (Python 3.8+)
data = [1, -2, 3, -4, 5]
positive = [y for x in data if (y := x * 2) > 0]
print(positive)   # [2, 6, 10]

Python code

# 기본 match/case
def http_status(status):
    match status:
        case 200: return "OK"
        case 404: return "Not Found"
        case 500 | 503: return "Server Error"   # OR 패턴
        case _:   return "Unknown"

# 구조 분해 패턴
def process_command(command):
    match command.split():
        case ["quit"]:
            return "종료"
        case ["go", direction]:
            return f"{direction}(으)로 이동"
        case ["go", direction, speed]:
            return f"{direction}으로 {speed} 속도로 이동"
        case _:
            return "알 수 없는 명령"

# 클래스 패턴
from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

def where_is(point):
    match point:
        case Point(x=0, y=0): return "원점"
        case Point(x=0, y=y): return f"Y축 위 {y}"
        case Point(x=x, y=0): return f"X축 위 {x}"
        case Point(x=x, y=y): return f"({x}, {y})"

print(where_is(Point(0, 5)))    # Y축 위 5
print(process_command("go north fast"))

Python code

import re

# walrus := — 할당과 평가를 동시에
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# while 루프에서 유용
numbers = iter(data)
while (n := next(numbers, None)) is not None:
    if n % 2 == 0:
        print(f"짝수: {n}")

# 정규식 매치 결과 재사용
text = "Python 3.12 출시"
if m := re.search(r"Python (\d+\.\d+)", text):
    print(f"버전: {m.group(1)}")   # 3.12

# 컴프리헨션에서 중복 계산 제거
def heavy(x): return x * x

# 나쁜 예: heavy() 두 번 호출
results_bad = [heavy(x) for x in range(10) if heavy(x) > 25]

# 좋은 예: walrus로 한 번만 호출
results = [y for x in range(10) if (y := heavy(x)) > 25]
print(results)  # [36, 49, 64, 81]

Python code

class Validator:
    """값 검증 디스크립터"""
    def __set_name__(self, owner, name):
        self.name = name
        self.private = f"_{name}"

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self  # 클래스에서 접근 시
        return getattr(obj, self.private, None)

    def __set__(self, obj, value):
        self._validate(value)
        setattr(obj, self.private, value)

    def _validate(self, value): ...

class PositiveInt(Validator):
    def _validate(self, value):
        if not isinstance(value, int) or value <= 0:
            raise ValueError(f"{self.name}은 양의 정수여야 함: {value}")

class RangeFloat(Validator):
    def __init__(self, lo, hi):
        self.lo, self.hi = lo, hi

    def _validate(self, value):
        if not (self.lo <= value <= self.hi):
            raise ValueError(f"{self.name}은 {self.lo}~{self.hi} 범위: {value}")

class Product:
    price    = PositiveInt()
    quantity = PositiveInt()
    discount = RangeFloat(0.0, 1.0)

    def __init__(self, price, quantity, discount):
        self.price = price
        self.quantity = quantity
        self.discount = discount

    @property
    def total(self):
        return self.price * self.quantity * (1 - self.discount)

p = Product(1000, 5, 0.1)
print(p.total)   # 4500.0

try:
    p.price = -100
except ValueError as e:
    print(e)

Python code

<span class="cm">// PEP 695 타입 파라미터 (3.12+) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("PEP 695 타입 파라미터 (3.12+)") }

Python code

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

@dataclass
class Circle:
    center: Point
    radius: float

def describe_shape(shape):
    match shape:
        # 리터럴 매칭
        case 0:
            return "영(zero)"

        # 클래스 패턴 + 가드
        case Point(x=0, y=0):
            return "원점"
        case Point(x, y) if x == y:
            return f"대각선 위의 점 ({x}, {y})"
        case Point(x, y):
            return f"점 ({x}, {y})"

        # 중첩 패턴
        case Circle(center=Point(0, 0), radius=r):
            return f"원점 중심 원, 반지름={r}"
        case Circle(center=c, radius=r) if r > 10:
            return f"큰 원: 중심={c}, 반지름={r}"

        # 시퀀스 패턴
        case [x]:
            return f"단일 원소: {x}"
        case [x, y, *rest]:
            return f"첫 둘: {x}, {y} (나머지 {len(rest)}개)"

        # 매핑 패턴
        case {"type": "user", "name": name, **extra}:
            return f"사용자: {name}, 추가정보: {extra}"

        # 와일드카드
        case _:
            return "알 수 없는 형태"

# 테스트
shapes = [
    Point(0, 0), Point(3, 3), Point(1, 2),
    Circle(Point(0, 0), 5), Circle(Point(1, 1), 15),
    [42], [1, 2, 3, 4, 5],
    {"type": "user", "name": "홍길동", "age": 30},
    "기타",
]

for s in shapes:
    print(f"{str(s):>45} → {describe_shape(s)}")

Python code

data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# step을 이용한 슬라이싱
print(data[::2])      # [0, 2, 4, 6, 8] 짝수 인덱스
print(data[1::2])     # [1, 3, 5, 7, 9] 홀수 인덱스
print(data[::-1])     # 역순

# slice 객체로 재사용
every_third = slice(None, None, 3)
print(data[every_third])  # [0, 3, 6, 9]

# 슬라이스 대입
data[2:5] = [20, 30, 40]
print(data)  # [0, 1, 20, 30, 40, 5, 6, 7, 8, 9]

# 길이가 다른 대입 (확장/축소)
data[2:5] = [99]
print(data)  # [0, 1, 99, 5, 6, 7, 8, 9]

Python code

text = "  Hello, Python World!  "

# 공백 제거
print(text.strip())       # "Hello, Python World!"
print(text.lstrip())      # "Hello, Python World!  "

# 검색
print(text.find("Python"))     # 9 (인덱스)
print(text.count("l"))         # 3
print("Python" in text)        # True

# 변환
print(text.strip().upper())    # "HELLO, PYTHON WORLD!"
print(text.strip().title())    # "Hello, Python World!"
print(text.strip().replace("World", "세계"))

# 분할과 결합
words = "a,b,c,d".split(",")
print(words)               # ['a', 'b', 'c', 'd']
print("-".join(words))     # "a-b-c-d"

# 판별 메서드
print("12345".isdigit())   # True
print("hello".isalpha())   # True

Python code

pi = 3.141592653589793
big = 1234567890

# 소수점 자릿수
print(f"{pi:.2f}")          # 3.14
print(f"{pi:.4f}")          # 3.1416

# 천 단위 구분
print(f"{big:,}")           # 1,234,567,890
print(f"{big:_}")           # 1_234_567_890

# 퍼센트
ratio = 0.8567
print(f"{ratio:.1%}")       # 85.7%

# 진법 변환
n = 255
print(f"{n:b}")   # 11111111 (2진)
print(f"{n:o}")   # 377      (8진)
print(f"{n:x}")   # ff       (16진)

# 패딩과 정렬
for i in range(1, 4):
    print(f"{i:>5}: {'■' * i}")

Python code

from datetime import datetime, date, timedelta, timezone

# 현재 시간
now = datetime.now()
print(f"현재: {now:%Y-%m-%d %H:%M:%S}")

# 특정 날짜 생성
birthday = date(2000, 3, 15)
print(f"생일: {birthday:%Y년 %m월 %d일}")

# 날짜 연산
delta = date.today() - birthday
print(f"태어난 지 {delta.days}일")

future = datetime.now() + timedelta(days=30, hours=5)
print(f"30일 5시간 후: {future:%Y-%m-%d %H:%M}")

# UTC 시간대
utc_now = datetime.now(timezone.utc)
kst = timezone(timedelta(hours=9))
kst_now = utc_now.astimezone(kst)
print(f"한국 시간: {kst_now:%H:%M:%S %Z}")

Python code

from enum import Enum, auto, IntEnum

class Color(Enum):
    RED = auto()
    GREEN = auto()
    BLUE = auto()

# 사용법
print(Color.RED)          # Color.RED
print(Color.RED.name)     # RED
print(Color.RED.value)    # 1

# 비교와 반복
if Color.RED is Color.RED:
    print("같은 멤버입니다")

for c in Color:
    print(f"{c.name}: {c.value}")

# IntEnum: 정수 비교 가능
class Priority(IntEnum):
    LOW = 1
    MEDIUM = 2
    HIGH = 3

print(Priority.HIGH > Priority.LOW)  # True
print(Priority.HIGH == 3)            # True

Python code

from typing import TypeAlias

# Python 3.10+ TypeAlias
Vector: TypeAlias = list[float]
Matrix: TypeAlias = list[Vector]

# 복잡한 타입에 별칭 부여
JsonValue: TypeAlias = (
    str | int | float | bool
    | None | list["JsonValue"]
    | dict[str, "JsonValue"]
)

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

def transpose(m: Matrix) -> Matrix:
    return [list(row) for row in zip(*m)]

# Python 3.12+ type 문 (더 간결)
# type Point = tuple[float, float]
# type Callback = Callable[[int], str]

v: Vector = [1.0, 2.0, 3.0]
print(scale(v, 2))  # [2.0, 4.0, 6.0]

Python code

from typing import TypeVar, Generic

T = TypeVar('T')
N = TypeVar('N', int, float)  # 제한된 TypeVar

# 제네릭 함수
def first(items: list[T]) -> T:
    return items[0]

print(first([1, 2, 3]))       # 1 (int)
print(first(["a", "b"]))      # "a" (str)

# 제한된 TypeVar
def add_nums(a: N, b: N) -> N:
    return a + b

print(add_nums(1, 2))       # 3
print(add_nums(1.5, 2.3))   # 3.8

# 제네릭 클래스 (Python 3.12+는 class Box[T]: 가능)
class Box(Generic[T]):
    def __init__(self, item: T) -> None:
        self.item = item
    def get(self) -> T:
        return self.item

box = Box(42)
print(box.get())  # 42

Python code

from typing import Literal, get_args

Mode = Literal["read", "write", "append"]

def open_file(path: str, mode: Mode) -> str:
    return f"{path}를 {mode} 모드로 열기"

# 정상 호출
print(open_file("data.txt", "read"))

# 타입 체커가 오류 감지 (런타임은 통과)
# open_file("data.txt", "delete")  # mypy 에러!

# Literal 값 추출
print(get_args(Mode))  # ('read', 'write', 'append')

# Literal과 오버로드 결합
from typing import overload

@overload
def process(action: Literal["count"]) -> int: ...
@overload
def process(action: Literal["list"]) -> list: ...

def process(action):
    if action == "count":
        return 42
    return [1, 2, 3]

print(process("count"))  # 42

Python code

from typing import Final, final

# Final 변수 — 재할당 금지
MAX_RETRIES: Final = 3
API_URL: Final[str] = "https://api.example.com"

# mypy가 다음을 에러로 감지
# MAX_RETRIES = 5  # Cannot assign to final name

# Final과 클래스
class Config:
    DEBUG: Final = False
    VERSION: Final[str] = "1.0.0"

    # @final 데코레이터 — 오버라이드 금지
    @final
    def get_version(self) -> str:
        return self.VERSION

# @final 클래스 — 상속 금지
@final
class Singleton:
    _instance = None

print(f"MAX_RETRIES={MAX_RETRIES}")
print(f"VERSION={Config.VERSION}")

Python code

# Python 3.10+ 파이프 문법
def process(value: int | str) -> str:
    if isinstance(value, int):
        return f"숫자: {value * 2}"
    return f"문자: {value.upper()}"

print(process(5))        # 숫자: 10
print(process("hello"))  # 문자: HELLO

# Optional은 X | None 의 단축
def find_user(user_id: int) -> str | None:
    users = {1: "Alice", 2: "Bob"}
    return users.get(user_id)

result = find_user(1)
if result is not None:
    print(result.upper())  # ALICE

# isinstance에서도 사용 (3.10+)
def check(val: object) -> str:
    if isinstance(val, int | str):
        return f"int 또는 str: {val}"
    return "기타 타입"

print(check(42))       # int 또는 str: 42
print(check([1, 2]))   # 기타 타입

Python code

# while 루프에서 활용
import re

data = ["apple 3", "banana 5", "", "cherry 2"]
results = []

for line in data:
    if match := re.match(r"(\w+) (\d+)", line):
        name, count = match.groups()
        results.append((name, int(count)))

print(results)  # [('apple', 3), ('banana', 5), ('cherry', 2)]

# 리스트 컴프리헨션에서 중복 계산 방지
values = [1, 4, 9, 16, 25]
filtered = [sqrt for v in values
            if (sqrt := v ** 0.5) > 2]
print(filtered)  # [3.0, 4.0, 5.0]

# any/all과 함께
names = ["Alice", "Bob", "Charlie"]
if found := next((n for n in names if len(n) > 4), None):
    print(f"긴 이름 발견: {found}")  # Alice

Python code

import datetime

name = "Python"
version = 3.12

# 디버깅 출력 (3.8+)
print(f"{name = }")          # name = 'Python'
print(f"{version = :.1f}")   # version = 3.1

# 표현식과 메서드 호출
items = [1, 2, 3]
print(f"합계: {sum(items)}")
print(f"대문자: {name.upper()!r}")  # 'PYTHON'

# 변환 플래그
val = "hello\nworld"
print(f"{val!r}")   # repr: 'hello\nworld'
print(f"{val!s}")   # str:  hello\nworld
print(f"{val!a}")   # ascii

# 중첩 f-string (3.12+)
width = 10
align = ">"
print(f"{'hello':{align}{width}}")  #      hello

# 날짜 포맷
now = datetime.datetime.now()
print(f"현재: {now:%Y년 %m월 %d일}")

Python code

# 확장 언패킹
first, *middle, last = [1, 2, 3, 4, 5]
print(first, middle, last)  # 1 [2, 3, 4] 5

# 중첩 언패킹
data = ("Alice", (90, 85, 92))
name, (math, eng, sci) = data
print(f"{name}: 수학={math}")

# 딕셔너리 병합 (3.9+)
defaults = {"color": "red", "size": 10}
custom = {"size": 20, "weight": "bold"}
merged = {**defaults, **custom}
print(merged)  # {'color': 'red', 'size': 20, 'weight': 'bold'}

# 3.9+ 파이프 연산자
merged2 = defaults | custom
print(merged2)

# 함수 인자 언패킹
def greet(name, age, city):
    print(f"{name}({age})은 {city}에 삽니다")

info = {"name": "Alice", "age": 30, "city": "서울"}
greet(**info)

Python code

# setdefault: 키가 없으면 기본값 설정 후 반환
groups: dict[str, list] = {}
for name, dept in [("Alice", "Dev"), ("Bob", "Dev"), ("Carol", "HR")]:
    groups.setdefault(dept, []).append(name)
print(groups)  # {'Dev': ['Alice', 'Bob'], 'HR': ['Carol']}

# dict comprehension으로 변환
prices = {"apple": 1000, "banana": 500, "cherry": 2000}
expensive = {k: v for k, v in prices.items() if v >= 1000}
print(expensive)  # {'apple': 1000, 'cherry': 2000}

# 딕셔너리 뷰 활용
a = {"x": 1, "y": 2, "z": 3}
b = {"y": 20, "z": 30, "w": 40}
common_keys = a.keys() & b.keys()
print(common_keys)  # {'y', 'z'}

# dict.fromkeys()
defaults = dict.fromkeys(["a", "b", "c"], 0)
print(defaults)  # {'a': 0, 'b': 0, 'c': 0}

# __missing__ 활용
class AutoDict(dict):
    def __missing__(self, key):
        self[key] = type(self)()
        return self[key]

Python code

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

# 기본 집합 연산
print(a & b)   # 교집합: {4, 5}
print(a | b)   # 합집합: {1, 2, 3, 4, 5, 6, 7, 8}
print(a - b)   # 차집합: {1, 2, 3}
print(a ^ b)   # 대칭차: {1, 2, 3, 6, 7, 8}

# 부분집합 / 상위집합
small = {1, 2}
print(small <= a)      # True (부분집합)
print(a >= small)      # True (상위집합)
print(a.isdisjoint(b)) # False (교집합 존재)

# 세트 컴프리헨션
text = "hello world"
unique_vowels = {c for c in text if c in "aeiou"}
print(unique_vowels)  # {'e', 'o'}

# 변경 가능 연산
a.add(10)
a.discard(99)   # 없어도 에러 안 남
a.update([20, 30])
print(a)

Python code

# frozenset 생성
fs = frozenset([1, 2, 3, 4, 5])
print(fs)  # frozenset({1, 2, 3, 4, 5})

# 집합 연산은 가능 (새 frozenset 반환)
fs2 = frozenset([4, 5, 6])
print(fs & fs2)  # frozenset({4, 5})
print(fs | fs2)  # frozenset({1, 2, 3, 4, 5, 6})

# 딕셔너리 키로 사용 가능
permissions = {
    frozenset(["read"]): "viewer",
    frozenset(["read", "write"]): "editor",
    frozenset(["read", "write", "admin"]): "admin",
}
user_perms = frozenset(["read", "write"])
print(permissions[user_perms])  # editor

# 세트의 세트
set_of_sets = {frozenset([1, 2]), frozenset([3, 4])}
print(frozenset([1, 2]) in set_of_sets)  # True

Python code

from collections import namedtuple
from typing import NamedTuple

# collections 방식
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
print(f"x={p.x}, y={p.y}")
print(f"거리: {(p.x**2 + p.y**2)**0.5:.2f}")

# typing 방식 (타입 힌트 포함)
class User(NamedTuple):
    name: str
    age: int
    email: str = "없음"  # 기본값

u = User("Alice", 30)
print(f"{u.name} ({u.age}) - {u.email}")

# _asdict(), _replace()
d = u._asdict()
print(d)  # {'name': 'Alice', 'age': 30, 'email': '없음'}

u2 = u._replace(age=31)
print(u2)  # User(name='Alice', age=31, email='없음')

# 언패킹 지원
name, age, email = u
print(name, age)

Python code

from collections import Counter

# 빈도 세기
text = "abracadabra"
counter = Counter(text)
print(counter)  # Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

# 가장 흔한 요소
print(counter.most_common(3))  # [('a', 5), ('b', 2), ('r', 2)]

# 산술 연산
c1 = Counter("aabb")
c2 = Counter("abcc")
print(c1 + c2)  # Counter({'a': 3, 'b': 3, 'c': 2})
print(c1 - c2)  # Counter({'a': 1, 'b': 1})

# 단어 빈도 분석
words = "the cat sat on the mat the cat".split()
word_count = Counter(words)
for word, count in word_count.most_common():
    print(f"{word:>5}: {'■' * count} ({count})")

# total() (Python 3.10+)
print(f"총 글자 수: {counter.total()}")

Python code

from collections import defaultdict

# 리스트 기본값
grouped = defaultdict(list)
for name, score in [("수학", 90), ("영어", 85), ("수학", 95), ("영어", 92)]:
    grouped[name].append(score)
print(dict(grouped))  # {'수학': [90, 95], '영어': [85, 92]}

# int 기본값 (0)
counter = defaultdict(int)
for char in "hello world":
    counter[char] += 1
print(dict(counter))

# set 기본값
tags = defaultdict(set)
tags["python"].add("언어")
tags["python"].add("프로그래밍")
tags["java"].add("언어")
print(dict(tags))

# 커스텀 팩토리
def default_user():
    return {"name": "unknown", "active": False}

users = defaultdict(default_user)
print(users["new_user"])  # {'name': 'unknown', 'active': False}

Python code

from collections import OrderedDict

# OrderedDict 고유 기능
od = OrderedDict()
od["c"] = 3
od["a"] = 1
od["b"] = 2

# move_to_end: 항목을 끝으로 이동
od.move_to_end("c")
print(list(od.keys()))  # ['a', 'b', 'c']

# move_to_end(last=False): 처음으로 이동
od.move_to_end("b", last=False)
print(list(od.keys()))  # ['b', 'a', 'c']

# popitem: LIFO (기본) 또는 FIFO
print(od.popitem())           # ('c', 3) 마지막
print(od.popitem(last=False)) # ('b', 2) 처음

# 순서가 같아야 동등
od1 = OrderedDict([("a", 1), ("b", 2)])
od2 = OrderedDict([("b", 2), ("a", 1)])
print(od1 == od2)  # False (순서 다름)

# 일반 dict는 순서 무시
print({"a": 1, "b": 2} == {"b": 2, "a": 1})  # True