# 파이썬 치트시트: 문법, 명령어와 내장 함수를 표로 정리

URL: https://skillaria.top/ko/guides/python/python-cheat-sheet

파이썬 문법은 중괄호 대신 들여쓰기로 블록을 구분하며, 블록은 콜론 뒤에서 네 칸 들여씁니다. 기본 요소는 자료형 선언 없는 변수, if/elif/else 조건문, for와 while 반복문, def 함수이며, print, len, range, input, type 같은 내장 함수와 문자열, 리스트, 딕셔너리 메서드를 함께 쓰면 일상적인 작업의 대부분을 처리할 수 있습니다.

이 파이썬 치트시트는 처음 몇 달 동안 가까이 두고 볼 내용을 한 페이지에 모았습니다. 문법, 반복문, 내장 함수, 문자열, 리스트, 딕셔너리 메서드, 터미널 명령어가 들어 있습니다. 각 표는 짧은 참조용이며, 예제는 REPL에 그대로 붙여 넣어 실행해 볼 수 있습니다.

## 파이썬 기본 문법

파이썬의 가장 큰 특징은 블록을 중괄호가 아니라 들여쓰기로 구분한다는 점입니다. 콜론으로 끝나는 줄(`if`, `for`, `def`, `class`) 다음 줄들은 네 칸 들여씁니다. 탭과 스페이스를 섞으면 `IndentationError`가 발생합니다.

| 구문 | 예제 | 설명 |
| --- | --- | --- |

| 주석 | `# 텍스트` | #부터 줄 끝까지는 무시됩니다 |

| 변수 | `age = 25` | 자료형을 선언하지 않으며, 값이 자료형을 정합니다 |

| 다중 대입 | `a, b = 1, 2` | 언패킹, 값 교환: `a, b = b, a` |

| 출력 | `print("안녕하세요", name)` | 인자는 공백으로 구분됩니다 |

| 입력 | `s = input("이름: ")` | 항상 문자열을 반환합니다 |

| f-문자열 | `f"{name}: {price:.2f}"` | 식을 넣고 서식을 지정합니다 |

| 타입 힌트 | `count: int = 0` | IDE와 검사 도구를 위한 힌트이며, 실행 시에는 검사하지 않습니다 |

| 빈 블록 | `pass` | 문법상 본문이 필요한 곳의 자리 표시자 |

| 가져오기 | `from math import sqrt` | 모듈이나 모듈의 이름을 가져옵니다 |

### 자료형

| 자료형 | 리터럴 | 변경 가능 |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | 아니요 |

| `float` | `3.14`, `1e-3` | 아니요 |

| `bool` | `True`, `False` | 아니요 |

| `str` | `"텍스트"`, `'텍스트'`, `"""여러 줄"""` | 아니요 |

| `list` | `[1, 2, 3]` | 예 |

| `tuple` | `(1, 2)`, `(1,)` | 아니요 |

| `dict` | `{"a": 1}` | 예 |

| `set` | `{1, 2}`, 빈 집합은 `set()` | 예 |

| `NoneType` | `None` | — |

### 연산자

| 분류 | 연산자 | 예제 → 결과 |
| --- | --- | --- |

| 산술 | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| 비교 | `== != < > <= >=` | `1 < x < 10` — 체이닝 비교 |

| 논리 | `and or not` | `x or "기본값"` |

| 소속 | `in`, `not in` | `"a" in "abc"` → True |

| 동일성 | `is`, `is not` | `x is None` |

| 대입 | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## 조건문과 패턴 매칭

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "성인" if age >= 18 else "미성년자"   # 삼항 연산자

match command:
    case "start":
        print("시작")
    case "stop" | "exit":
        print("중지")
    case _:
        print("알 수 없는 명령")
```

거짓으로 취급되는 값은 `False`, `None`, `0`, 빈 문자열, 빈 컬렉션입니다. 그래서 `if len(items) > 0` 대신 그냥 `if items`라고 씁니다.

## 파이썬 반복문: for와 while 문법

### for 반복문

for 반복문의 문법은 `for 변수 in 시퀀스:`이며, 본문은 들여씁니다. 문자열, 리스트, 딕셔너리, 파일, `range` 등 순회할 수 있는 모든 객체를 돌 수 있습니다.

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

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

for i, fruit in enumerate(["사과", "배"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### while 반복문

```
attempts = 3
while attempts > 0:
    password = input("비밀번호: ")
    if password == "secret":
        print("로그인 성공")
        break
    attempts -= 1
else:
    print("시도 횟수를 모두 사용했습니다")   # break 없이 끝났을 때 실행
```

| 명령 | 동작 |
| --- | --- |

| `break` | 반복문을 즉시 빠져나갑니다 |

| `continue` | 다음 반복으로 넘어갑니다 |

| 반복문의 `else` | `break` 없이 끝났을 때 실행됩니다 |

| `range(stop)`, `range(start, stop, step)` | 숫자 시퀀스이며, `stop`은 포함되지 않습니다 |

### 컴프리헨션

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # 제너레이터 식
```

## 함수

```
def greet(name: str, greeting: str = "안녕하세요") -> str:
    """인사말을 반환합니다."""
    return f"{greeting}, {name}!"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("지민"))                  # 안녕하세요, 지민!
print(greet("지민", greeting="반가워"))  # 반가워, 지민!
```

| 요소 | 의미 |
| --- | --- |

| `def f(a, b=1)` | 기본값이 있는 매개변수 |

| `*args` | 위치 인자를 개수에 상관없이 받습니다(튜플) |

| `**kwargs` | 이름 있는 인자를 개수에 상관없이 받습니다(딕셔너리) |

| `return` | 값을 반환합니다. 없으면 함수는 `None`을 반환합니다 |

| `lambda x: ...` | 한 줄짜리 익명 함수 |

| `global`, `nonlocal` | 바깥 범위의 변수를 바꿉니다 |

기본값으로 `def f(items=[])`처럼 변경 가능한 값을 쓰지 마세요. 리스트는 한 번만 만들어지고 호출 사이에 계속 쌓입니다. 올바른 방법은 `items=None`으로 두고 함수 안에서 `if items is None: items = []`를 쓰는 것입니다.

## 파이썬 내장 함수

파이썬 내장 함수는 import 없이 바로 쓸 수 있습니다. 거의 모든 스크립트에 등장하는 기본 함수들입니다.

| 함수 | 동작 | 예제 → 결과 |
| --- | --- | --- |

| `print()` | 값을 출력합니다 | `print(1, 2, sep="-")` → 1-2 |

| `input()` | 키보드에서 문자열을 읽습니다 | `int(input())` |

| `len()` | 컬렉션이나 문자열의 길이 | `len("abc")` → 3 |

| `type()` | 객체의 타입 | `type(3.0)` → <class 'float'> |

| `isinstance()` | 타입 확인 | `isinstance(5, int)` → True |

| `int() float() str() bool()` | 타입 변환 | `int("42")` → 42 |

| `list() tuple() set() dict()` | 컬렉션 만들기 | `list("ab")` → ['a', 'b'] |

| `range()` | 숫자 범위 | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | (인덱스, 원소) 쌍 | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | 시퀀스를 짝지어 묶습니다 | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | 합계, 최솟값, 최댓값 | `max([3, 7, 1])` → 7 |

| `abs() round()` | 절댓값과 반올림 | `round(3.14159, 2)` → 3.14 |

| `sorted()` | 정렬된 새 리스트 | `sorted(words, key=len, reverse=True)` |

| `reversed()` | 역순 이터레이터 | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | 함수 적용 / 걸러 내기 | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | 하나라도 참 / 모두 참 | `all(x > 0 for x in nums)` |

| `open()` | 파일 열기 | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | 도움말과 속성 목록 | `help(str.split)`, `dir(list)` |

| `id() hash()` | 객체의 식별자와 해시 | `hash("a")` |

언제나 곁에 두기 좋은 파이썬 레퍼런스는 REPL의 `help()` 함수입니다. `help(dict)`는 딕셔너리의 모든 메서드를 설명과 함께 보여 주고, `dir(obj)`는 객체가 가진 이름 목록을 보여 줍니다.

## 문자열 메서드

파이썬 문자열의 문법상 특징은 문자열이 변경 불가능하다는 것입니다. 모든 메서드는 새 문자열을 반환합니다. 슬라이스는 리스트와 같은 방식으로 씁니다. `s[1:4]`, 뒤집기는 `s[::-1]`입니다.

| 메서드 | 예제 → 결과 |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" hi \n".strip()` → 'hi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"cat".replace("c", "b")` → 'bat' |

| `find() index()` | `"hello".find("l")` → 2, 없으면 -1 (`index`는 오류) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## 리스트 명령

리스트는 변경 가능한 순서 있는 컬렉션입니다. 대부분의 메서드는 리스트를 제자리에서 바꾸고 `None`을 반환합니다. 그래서 `a = a.sort()`는 흔한 실수입니다.

| 연산 | 동작 | 예제 |
| --- | --- | --- |

| `append(x)` | 끝에 추가합니다 | `a.append(4)` |

| `extend(iter)` | 모든 원소를 추가합니다 | `a.extend([5, 6])` |

| `insert(i, x)` | 인덱스 위치에 넣습니다 | `a.insert(0, "first")` |

| `remove(x)` | 값이 처음 나오는 곳을 삭제합니다 | `a.remove(3)` |

| `pop(i)` | 원소를 삭제하고 반환합니다(기본값은 마지막) | `last = a.pop()` |

| `clear()` | 리스트를 비웁니다 | `a.clear()` |

| `index(x)` | 처음 나오는 위치의 인덱스 | `a.index("b")` |

| `count(x)` | 나오는 횟수 | `a.count(1)` |

| `sort()` | 제자리에서 정렬합니다 | `a.sort(key=str.lower)` |

| `reverse()` | 제자리에서 뒤집습니다 | `a.reverse()` |

| `copy()` | 얕은 복사 | `b = a.copy()` |

| `del a[i]` | 인덱스나 슬라이스로 삭제 | `del a[1:3]` |

| 슬라이스 | `a[start:stop:step]` | `a[-1]`은 마지막, `a[:3]`은 처음 세 개 |

## 딕셔너리 명령

| 연산 | 동작 | 예제 |
| --- | --- | --- |

| `d[key]` | 키의 값, 키가 없으면 `KeyError` | `d["name"]` |

| `get(key, default)` | 값이나 대체 값 | `d.get("age", 0)` |

| `d[key] = value` | 추가하거나 변경 | `d["city"] = "서울"` |

| `keys() values() items()` | 키, 값, 쌍 | `for k, v in d.items():` |

| `update()` | 다른 딕셔너리와 병합 | `d.update({"a": 1})` |

| `d1 | d2` | 병합한 새 딕셔너리 | `merged = defaults | user` |

| `pop(key, default)` | 삭제하고 값을 반환 | `d.pop("tmp", None)` |

| `popitem()` | 마지막으로 추가한 쌍을 삭제 | `d.popitem()` |

| `setdefault(key, value)` | 값을 반환하고, 키가 없으면 만듭니다 | `d.setdefault("tags", []).append("py")` |

| `key in d` | 키가 있는지 확인 | `if "name" in d:` |

| `dict.fromkeys()` | 키 목록으로 같은 값을 가진 딕셔너리 만들기 | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | 크기와 삭제 | `del d["old"]` |

### 튜플과 집합

| 연산 | 예제 → 결과 |
| --- | --- |

| 튜플 언패킹 | `x, y = (3, 4)` |

| 집합에 추가 | `s.add(5)`, 삭제는 `s.discard(5)` |

| 합집합 / 교집합 | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| 차집합 | `{1, 2} - {2}` → {1} |

| 리스트의 중복 제거 | `list(dict.fromkeys(items))` — 순서 유지 |

## 예외와 파일

```
try:
    number = int(input("숫자: "))
except ValueError as err:
    print("숫자가 아닙니다:", err)
else:
    print("성공")
finally:
    print("항상 실행됨")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("줄\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| 예외 | 발생 상황 |
| --- | --- |

| `SyntaxError`, `IndentationError` | 문법 오류 또는 들여쓰기 오류 |

| `NameError` | 이름이 정의되지 않음(오타) |

| `TypeError` | 맞지 않는 타입에 연산을 적용: `"1" + 1` |

| `ValueError` | 타입은 맞지만 값이 잘못됨: `int("abc")` |

| `IndexError`, `KeyError` | 인덱스나 키가 없음 |

| `FileNotFoundError` | 파일을 찾을 수 없음 |

| `ZeroDivisionError` | 0으로 나누기 |

## 클래스

```
from dataclasses import dataclass

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

    def bark(self) -> str:
        return f"{self.name}: 멍멍!"

@dataclass
class Point:
    x: float
    y: float

print(Dog("바둑이").bark())   # 바둑이: 멍멍!
print(Point(1, 2))            # Point(x=1, y=2)
```

## 파이썬 내장 모듈

표준 라이브러리는 인터프리터와 함께 설치되므로 `import`만 하면 됩니다.

| 모듈 | 용도 | 예제 |
| --- | --- | --- |

| `math` | 수학 계산 | `math.sqrt(16)` → 4.0 |

| `random` | 난수 | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | 날짜와 시간 | `datetime.date.today()` |

| `pathlib` | 경로와 파일 | `Path("data").glob("*.csv")` |

| `os`, `sys` | 시스템, 환경 변수, 인자 | `os.environ.get("HOME")`, `sys.argv` |

| `json` | JSON 읽기와 쓰기 | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | CSV 표 | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | 조합과 이터레이터 연결 | `itertools.chain(a, b)` |

| `re` | 정규 표현식 | `re.findall(r"\d+", s)` |

| `time` | 일시 정지와 시간 측정 | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | 비동기 코드 | `asyncio.run(main())` |

파이썬 3.15에는 지연 import(PEP 810)가 추가되었습니다. `lazy import pandas as pd`는 모듈을 처음 사용할 때까지 로드를 미루므로, 무거운 의존성이 있는 스크립트도 훨씬 빨리 시작합니다.

## 터미널에서 쓰는 파이썬 명령

'파이썬 명령어'를 찾는 사람들이 보통 원하는 것은 인터프리터를 실행하고 라이브러리를 설치하는 명령입니다. Windows에서는 `python3` 대신 `python`이나 `py`를 쓰는 경우가 많습니다.

| 명령 | 동작 |
| --- | --- |

| `python3 --version` | 버전 표시 |

| `python3` | 대화형 콘솔 REPL 열기(종료는 `exit()`) |

| `python3 script.py` | 파일 실행 |

| `python3 -c "print(2 + 2)"` | 한 줄 코드 실행 |

| `python3 -m venv .venv` | 가상 환경 만들기 |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | 가상 환경 활성화(Linux, macOS / Windows) |

| `python3 -m pip install requests` | 패키지 설치 |

| `pip list`, `pip freeze > requirements.txt` | 패키지 목록 보기와 저장 |

| `pip install -r requirements.txt` | 파일에 적힌 의존성 설치 |

| `python3 -m http.server 8000` | 현재 폴더를 여는 간단한 웹 서버 |

| `uv init`, `uv add requests`, `uv run main.py` | uv로 프로젝트 만들기, 의존성 추가, 실행 |

## 초보자가 자주 하는 실수

- **조건에 `=` 사용** — 조건에는 `==`가 필요합니다. 한 개의 `=`은 대입입니다.
- **콜론 누락** — `if`, `for`, `def` 뒤의 콜론을 빠뜨리면 `SyntaxError`가 납니다.
- **문자열과 숫자 더하기** — `"나이: " + 25`는 오류입니다. `f"나이: {25}"`라고 쓰세요.
- **순회하면서 리스트 변경** — `for x in a[:]`처럼 복사본을 순회하거나 새 리스트를 만드세요.
- **`input()`은 문자열을 반환** — 계산에 쓰려면 `int()`나 `float()`로 감싸세요.

## 정리

파이썬 문법은 들여쓰기, 콜론, 몇 가지 구문을 중심으로 돌아갑니다. 조건문, for와 while 반복문, 함수, 클래스가 그것입니다. 내장 함수 20여 개와 문자열, 리스트, 딕셔너리 메서드를 더하면 일상적인 작업 대부분을 처리할 수 있습니다. 이 치트시트를 저장해 두고, 표가 익숙해지면 모듈과 비동기 처리로 넘어가세요. 이 모든 내용은 '파이썬 3.15: 입문자에서 전문가까지' 강의에서 단계별로 실습합니다.

## FAQ

**파이썬 들여쓰기는 몇 칸으로 해야 하나요?**

PEP 8 표준에 따르면 한 단계당 네 칸입니다. 중요한 것은 블록 안에서 일관되게 쓰고, 탭과 섞지 않는 것입니다.

**리스트와 튜플은 무엇이 다른가요?**

리스트는 변경 가능해서 원소를 추가하거나 제자리에서 정렬할 수 있습니다. 튜플은 변경할 수 없어서 딕셔너리의 키로 쓸 수 있고, 고정된 값 묶음에 적합합니다.

**파이썬 객체의 모든 메서드를 어떻게 보나요?**

dir(obj)로 이름 목록을, help(obj)로 설명을 볼 수 있습니다. 예를 들어 help(str)은 문자열의 모든 메서드를 보여 줍니다.

**sort()와 sorted()는 무엇이 다른가요?**

list.sort()는 리스트 자체를 정렬하고 None을 반환합니다. sorted()는 정렬된 새 리스트를 반환하며, 어떤 순회 가능한 컬렉션에도 쓸 수 있습니다.

**줄 끝에 세미콜론이 필요한가요?**

필요하지 않습니다. 한 줄에 여러 명령을 쓸 때만 세미콜론을 사용할 수 있지만, 일반적인 코드에서는 명령마다 새 줄에 씁니다.


---
Source: Skillaria.Top (https://skillaria.top)