🐍
Python 치트시트

OS별 설치 가이드(uv/pyenv/winget), 기초 문법, F-String, 슬라이싱, 컴프리헨션, 데이터클래스, 데코레이터, 표준 모듈, 가상환경 및 실무 팁 레퍼런스
#python#install#uv#programming#backend#syntax#data-structures#async#type-hints최종 업데이트: 2026-09-27
Python 치트시트 핵심 명령어 및 실전 가이드

OS별 설치 가이드(uv/pyenv/winget), 기초 문법, F-String, 슬라이싱, 컴프리헨션, 데이터클래스, 데코레이터, 표준 모듈, 가상환경 및 실무 팁 레퍼런스
## 1. Python 설치 & 환경 구성 (Installation & Version Managers)
```bash
# ⚡ [1] 차세대 초고속 관리자 'uv' 설치 (가장 추천: 파이썬 자동 다운로드 및 실행)
# macOS / Linux:
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows (PowerShell):
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# 원하는 파이썬 버전 1초 만에 설치 및 확인
uv python install 3.12
uv python list
uv run --python 3.12 python --version
```
```bash
# 🪟 [2] Windows 환경 공식 설치
# 방법 A. Windows 패키지 관리자 (winget 추천)
winget install Python.Python.3.12

# 방법 B. python.org 공식 인스톨러(.exe) 설치 시 주의사항
# ⚠️ 반드시 설치 화면 첫 페이지의 [Add python.exe to PATH] 체크박스 선택 필수!

# 설치 확인 및 버전 확인 (Python Launcher)
py -0                 # 설치된 모든 파이썬 버전 목록
py -3.12 --version    # 특정 버전 실행

# 🍏 [3] macOS 환경 설치
# Homebrew를 통한 설치
brew update
brew install python@3.12

# 다중 버전 관리가 필요할 때 (pyenv)
brew install pyenv
pyenv install 3.12.3
pyenv global 3.12.3

# 🐧 [4] Linux (Ubuntu / Debian) 환경 설치
sudo apt update
sudo apt install -y python3 python3-pip python3-venv

# 최신 파이썬 버전 설치를 위한 deadsnakes PPA 등록
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install -y python3.12 python3.12-venv python3.12-dev
```

## 2. 기본 문법 & 제어문 (Basic Syntax & Control Flow)
```python
# [1] 변수 & f-string 포맷팅 (Python 3.6+)
name = "Lucky"
score = 95.678
print(f"이름: {name}, 점수: {score:.2f}") # 소수점 둘째자리: 95.68
# 디버깅용 self-documenting 표현식 (Python 3.8+)
print(f"{name=}, {score=}") # name='Lucky', score=95.678

# [2] 조건문 & 삼항 연산자 (Ternary Operator)
status = "Adult" if age >= 18 else "Minor"

# [3] Walrus 연산자 (대입 표현식 := Python 3.8+)
# 조건문 안에서 변수를 할당하고 즉시 평가
if (n := len(data)) > 10:
    print(f"데이터가 너무 깁니다: {n}개")

# [4] 구조적 패턴 매칭 (match-case Python 3.10+)
def handle_status(status_code):
    match status_code:
        case 200:
            return "OK"
        case 400 | 404 as err:
            return f"클라이언트 오류: {err}"
        case 500:
            return "서버 오류"
        case _:
            return "알 수 없는 코드"
```

## 3. 핵심 자료구조 (Lists, Dicts, Sets, Tuples)
```python
# 📋 [1] List (리스트: 순서 있음, 가변)
fruits = ["apple", "banana", "cherry"]
fruits.append("orange")      # 끝에 추가
fruits.insert(1, "grape")    # 인덱스 1에 삽입
fruits.extend(["mango", "kiwi"]) # 다른 리스트 병합
last = fruits.pop()          # 마지막 요소 꺼내기
fruits.sort(reverse=True)    # 원본 정렬
new_list = sorted(fruits)    # 원본 유지, 정렬된 새 리스트 반환

# 💡 슬라이싱 매직
arr = [0, 1, 2, 3, 4, 5]
print(arr[1:4])   # [1, 2, 3] (시작:끝-1)
print(arr[:3])    # [0, 2] (처음부터)
print(arr[::2])   # [0, 2, 4] (2칸씩 건너뛰기)
print(arr[::-1])  # [5, 4, 3, 2, 1, 0] (역순 뒤집기)

# 📖 [2] Dictionary (딕셔너리: Key-Value, 순서 보존)
user = {"name": "lucky", "role": "admin"}
age = user.get("age", 20)    # 키가 없을 때 기본값 20 반환 (KeyError 방지)
user.setdefault("tags", []).append("python") # 키가 없으면 초기화 후 연산

# 딕셔너리 병합 (Python 3.9+ | 연산자)
default_cfg = {"host": "localhost", "port": 8080}
custom_cfg = {"port": 9000, "debug": True}
merged = default_cfg | custom_cfg # custom_cfg가 우선 적용됨

# 🔢 [3] Set (집합: 중복 불가, 순서 없음)
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
print(s1 & s2)    # 교집합 {3, 4}
print(s1 | s2)    # 합집합 {1, 2, 3, 4, 5, 6}
print(s1 - s2)    # 차집합 {1, 2}
print(s1 ^ s2)    # 대칭차집합(둘 중 하나에만 있는 것) {1, 2, 5, 6}

# 🔒 [4] Tuple & 언패킹
point = (10, 20)
x, y = point
a, b, *rest = [1, 2, 3, 4, 5] # rest = [3, 4, 5]
```

## 4. 컴프리헨션 & 제너레이터 (Comprehensions & Generators)
```python
# [1] List Comprehension (리스트 내포)
evens = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]
squares = [x**2 if x % 2 == 0 else x for x in range(5)] # 조건부 if-else

# [2] Dict & Set Comprehension
words = ["apple", "banana", "cherry"]
word_len = {w: len(w) for w in words} # {'apple': 5, 'banana': 6, 'cherry': 6}
unique_lens = {len(w) for w in words} # {5, 6}

# [3] Generator (제너레이터: 메모리 효율적 지연 평가)
# 괄호()를 사용하면 한 번에 메모리에 올리지 않고 필요할 때 하나씩 생성
gen = (x**2 for x in range(1_000_000))
print(next(gen)) # 0
print(next(gen)) # 1

# yield를 사용한 제너레이터 함수
def fibonacci(limit):
    a, b = 0, 1
    for _ in range(limit):
        yield a
        a, b = b, a + b

for num in fibonacci(5):
    print(num, end=" ") # 0 1 1 2 3
```

## 5. 함수 & 매개변수 기법 (Functions & Args)
```python
# [1] 가변 인자 (*args, **kwargs)
def calculate_summary(title, *args, prefix="[LOG]", **kwargs):
    total = sum(args)
    print(f"{prefix} {title}: 합계={total}, 추가옵션={kwargs}")

calculate_summary("점수", 10, 20, 30, user="lucky", active=True)

# [2] 위치 전용(/) 및 키워드 전용(*) 인자 (Python 3.8+)
# / 앞의 인자는 반드시 위치로만, * 뒤의 인자는 반드시 이름으로만 전달
def connect(ip, port, /, *, timeout=10, secure=True):
    pass

# connect(ip="127.0.0.1", 80) -> 에러 (ip는 위치로만)
connect("127.0.0.1", 80, timeout=5, secure=False) # 정상

# [3] 람다(Lambda) & 고차 함수
nums = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, nums)) # [2, 4]
squared = list(map(lambda x: x**2, nums))         # [1, 4, 9, 16, 25]

# any(), all() 불리언 검사
has_negative = any(x < 0 for x in nums) # 하나라도 음수면 True -> False
all_positive = all(x > 0 for x in nums) # 모두 양수면 True -> True
```

## 6. 클래스 & 데이터클래스 (OOP & Dataclasses)
```python
# [1] @dataclass (Python 3.7+ 실무 권장 DTO)
# __init__, __repr__, __eq__ 등을 자동 생성
from dataclasses import dataclass, field

@dataclass
class User:
    id: int
    name: str
    roles: list[str] = field(default_factory=list) # 가변 기본값은 factory 사용
    is_active: bool = True

    def has_admin_role(self) -> bool:
        return "admin" in self.roles

u1 = User(id=1, name="Lucky", roles=["admin", "user"])
print(u1) # User(id=1, name='Lucky', roles=['admin', 'user'], is_active=True)

# [2] 일반 클래스 & 프로퍼티 (Getter / Setter)
class Account:
    def __init__(self, owner: str, balance: int = 0):
        self.owner = owner
        self._balance = balance # 관례상 비공개 변수 (_)

    @property
    def balance(self) -> int:
        return self._balance

    @balance.setter
    def balance(self, amount: int):
        if amount < 0:
            raise ValueError("잔액은 음수가 될 수 없습니다.")
        self._balance = amount
```

## 7. 데코레이터 & 컨텍스트 매니저 (Decorators & Context Managers)
```python
# [1] 커스텀 데코레이터 (실행 시간 측정)
import time
from functools import wraps

def measure_time(func):
    @wraps(func) # 원본 함수의 __name__, docstring 보존 필수
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        duration = time.perf_counter() - start
        print(f"[{func.__name__}] 실행 시간: {duration:.4f}초")
        return result
    return wrapper

@measure_time
def heavy_computation():
    time.sleep(0.5)

heavy_computation()

# [2] @contextmanager를 활용한 자원 관리 (with 문)
from contextlib import contextmanager

@contextmanager
def temporary_flag():
    print(">> 시작: 자원 할당")
    try:
        yield
    finally:
        print(">> 종료: 자원 정리 (예외 발생 시에도 반드시 실행)")

with temporary_flag():
    print("작업 수행 중...")
```

## 8. 예외 처리 & 파일 입출력 (Exceptions & I/O)
```python
# [1] 견고한 예외 처리 구조
class InsufficientFundsError(Exception):
    """사용자 정의 비즈니스 예외"""
    pass

try:
    value = int("invalid_num")
except ValueError as e:
    print(f"입력 변환 실패: {e}")
except (TypeError, KeyError) as e:
    print(f"타입 또는 키 오류: {e}")
else:
    print("예외가 발생하지 않았을 때만 실행")
finally:
    print("예외 발생 여부와 상관없이 항상 실행")

# [2] 현대적인 pathlib 파일 입출력 (권장)
from pathlib import Path

# 파일 쓰기 (UTF-8)
file_path = Path("output.txt")
file_path.write_text("Hello, Python World!", encoding="utf-8")

# 파일 읽기
content = file_path.read_text(encoding="utf-8")

# 디렉토리 순회
data_dir = Path("./logs")
if data_dir.exists():
    for f in data_dir.glob("*.log"):
        print(f.name, f.stat().st_size)
```

## 9. 가상환경 & 패키지 관리 (venv & pip / uv)
```bash
# 📦 [1] 표준 venv 가상환경 생성 및 활성화
python -m venv .venv

# 가상환경 활성화 (OS별)
source .venv/bin/activate       # macOS / Linux
.venv\Scripts\activate          # Windows PowerShell / CMD

# 비활성화
deactivate

# 📄 [2] 의존성 패키지 관리
pip install requests fastapi uvicorn
pip freeze > requirements.txt    # 현재 환경의 패키지 목록 추출
pip install -r requirements.txt  # 파일로부터 일괄 설치

# ⚡ [3] 초고속 모던 패키지 매니저 'uv' (pip 대비 10~100배 빠름)
# uv 설치 후 사용 (Rust 기반)
pip install uv
uv venv                         # .venv 생성 (0.01초)
uv pip install -r requirements.txt # 초고속 패키지 설치
```

## 10. 필수 표준 내장 모듈 (Standard Library Gems)
```python
# [1] collections 모듈
from collections import defaultdict, Counter, deque

# defaultdict: 존재하지 않는 키 접근 시 자동 기본값 생성
graph = defaultdict(list)
graph["node1"].append("node2") # KeyError 없이 빈 리스트 자동 생성

# Counter: 요소별 빈도수 자동 계산
counts = Counter(["apple", "banana", "apple", "cherry", "apple"])
print(counts.most_common(1)) # [('apple', 3)]

# deque: O(1) 양방향 큐
q = deque([1, 2, 3])
q.appendleft(0) # 맨 앞 삽입 O(1)
q.pop()         # 맨 뒤 추출 O(1)

# [2] itertools 모듈
from itertools import combinations, permutations, chain

arr = [1, 2, 3]
print(list(permutations(arr, 2))) # 순열: [(1,2), (1,3), (2,1), (2,3), (3,1), (3,2)]
print(list(combinations(arr, 2))) # 조합: [(1,2), (1,3), (2,3)]

# [3] datetime & json
from datetime import datetime, timezone
now = datetime.now(timezone.utc)
iso_str = now.isoformat() # ISO 8601 문자열 변환

import json
data = {"user": "lucky", "active": True}
json_str = json.dumps(data, indent=2, ensure_ascii=False)
parsed = json.loads(json_str)
```

## 11. 타입 힌트 (Type Hints: Typing)
```python
from typing import Optional, Union, Callable

# Python 3.10+ 최신 유니온 구문 (| 연산자)
def find_user(user_id: int) -> dict[str, str] | None:
    if user_id == 1:
        return {"name": "Lucky"}
    return None

# 함수 타입 힌트 (Callable[[인자타입], 반환타입])
def process_data(data: list[int], transformer: Callable[[int], int]) -> list[int]:
    return [transformer(x) for x in data]

# TypedDict: 사전 객체의 키-값 구조 엄격 검증
from typing import TypedDict

class UserProfile(TypedDict):
    id: int
    email: str
    nickname: str

profile: UserProfile = {"id": 1, "email": "test@test.com", "nickname": "Lucky"}
```

## 12. 비동기 프로그래밍 (AsyncIO Concurrency)
```python
import asyncio
import time

async def fetch_data(task_id: int, delay: float) -> str:
    print(f"태스크 {task_id} 시작...")
    await asyncio.sleep(delay) # 논블로킹 비동기 대기 (time.sleep 사용 금지!)
    print(f"태스크 {task_id} 완료")
    return f"결과-{task_id}"

async def main():
    # 여러 비동기 작업을 병렬로 동시 실행 (gather)
    start = time.perf_counter()
    results = await asyncio.gather(
        fetch_data(1, 1.0),
        fetch_data(2, 1.5),
        fetch_data(3, 0.8)
    )
    print("전체 결과:", results)
    print(f"총 소요 시간: {time.perf_counter() - start:.2f}초 (약 1.5초)")

# 비동기 이벤트 루프 실행
if __name__ == "__main__":
    asyncio.run(main())
```

## 13. 실무 팁 & Pythonic 트릭 (Pythonic Tricks)
```python
# [1] enumerate() - 인덱스와 요소를 동시에 순회
names = ["Alice", "Bob", "Charlie"]
for idx, name in enumerate(names, start=1):
    print(f"{idx}위: {name}")

# [2] zip() - 두 개 이상의 이터러블을 병렬 묶음 순회
ages = [24, 30, 28]
for name, age in zip(names, ages):
    print(f"{name} ({age}세)")

# [3] 메모리 절약 __slots__ (대량 객체 생성 시 메모리 50% 이상 절감)
class Point:
    __slots__ = ('x', 'y') # 인스턴스 딕셔너리(__dict__) 생성을 억제
    def __init__(self, x, y):
        self.x = x
        self.y = y

# [4] 리스트 중복 제거하면서 원래 순서 유지 (Python 3.7+ dict 특징 활용)
raw = [3, 1, 2, 3, 4, 1, 5]
deduped = list(dict.fromkeys(raw)) # [3, 1, 2, 4, 5] (set(raw)는 순서가 섞임)
```
💬
Python 치트시트

의견 및 질문

댓글 수정

댓글 삭제
