# Python 기초 문법 - 컴프리헨션과 메서드
> 관련 문서: [[02일차_2장 to 2.4_GPT 기초]], [[Python Lambda 함수 완전 가이드]]
## 개요
Python의 핵심 문법인 for문, enumerate, 컴프리헨션, 메서드에 대한 종합 설명입니다.
## 1. `for in` 구문 기초
### 기본 형태
```python
for 변수 in 반복할_것:
실행할_코드
```
### 리스트 반복
```python
# 리스트의 각 요소를 하나씩 가져오기
fruits = ['사과', '바나나', '포도']
for fruit in fruits:
print(fruit)
# 출력:
# 사과
# 바나나
# 포도
```
### 문자열 반복
```python
word = "안녕"
for char in word:
print(char)
# 출력:
# 안
# 녕
```
### 숫자 범위 반복
```python
for i in range(3): # 0, 1, 2
print(f"숫자: {i}")
# 출력:
# 숫자: 0
# 숫자: 1
# 숫자: 2
```
## 2. enumerate() 함수
### 기본 개념
`enumerate()`는 **순서와 값을 동시에** 가져오는 함수입니다.
### 기본 사용법
```python
ko_chars = ['가', '나', '다']
# enumerate 사용
for i, char in enumerate(ko_chars):
print(f"인덱스: {i}, 문자: {char}")
# 출력:
# 인덱스: 0, 문자: 가
# 인덱스: 1, 문자: 나
# 인덱스: 2, 문자: 다
```
### enumerate의 내부 동작
```python
# enumerate()가 실제로 반환하는 것
ko_chars = ['가', '나', '다']
enum_result = enumerate(ko_chars)
for item in enum_result:
print(item)
# 출력:
# (0, '가') # 튜플 형태
# (1, '나')
# (2, '다')
# 그래서 i, char = (0, '가') 이렇게 분해되는 것!
```
### enumerate 없이 vs 있을 때 비교
```python
ko_chars = ['가', '나', '다']
# enumerate 없이 (복잡한 방법)
for i in range(len(ko_chars)):
char = ko_chars[i]
print(f"인덱스: {i}, 문자: {char}")
# enumerate 사용 (간단한 방법)
for i, char in enumerate(ko_chars):
print(f"인덱스: {i}, 문자: {char}")
```
## 3. Dictionary Comprehension (딕셔너리 컴프리헨션)
### 컴프리헨션이란?
**컴프리헨션**은 "한 줄로 리스트나 딕셔너리를 만드는 방법"입니다.
### 리스트 컴프리헨션 기초
```python
# 기존 방식 (for문 사용)
numbers = []
for i in range(1, 6):
numbers.append(i * i)
print(numbers) # [1, 4, 9, 16, 25]
# 리스트 컴프리헨션 방식
numbers = [i * i for i in range(1, 6)]
print(numbers) # [1, 4, 9, 16, 25]
```
### 리스트 컴프리헨션 패턴
```python
# 기본 패턴
[표현식 for 변수 in 반복가능한것]
# 예시들
[x for x in range(5)] # [0, 1, 2, 3, 4]
[x * 2 for x in range(5)] # [0, 2, 4, 6, 8]
[x + 1 for x in [1, 2, 3]] # [2, 3, 4]
```
### 딕셔너리 컴프리헨션
```python
# 기존 방식 (for문 사용)
ko_chars = ['가', '나', '다']
character_to_ids = {}
for i, char in enumerate(ko_chars):
character_to_ids[char] = i
print(character_to_ids) # {'가': 0, '나': 1, '다': 2}
# 딕셔너리 컴프리헨션 방식
ko_chars = ['가', '나', '다']
character_to_ids = {char: i for i, char in enumerate(ko_chars)}
print(character_to_ids) # {'가': 0, '나': 1, '다': 2}
```
### 딕셔너리 컴프리헨션 패턴
```python
# 기본 패턴
{키표현식: 값표현식 for 변수 in 반복가능한것}
# 예시들
{x: x*2 for x in range(3)} # {0: 0, 1: 2, 2: 4}
{f'key{i}': i for i in range(3)} # {'key0': 0, 'key1': 1, 'key2': 2}
```
## 4. 역방향 딕셔너리
### 개념
키와 값을 바꾼 딕셔너리를 만드는 것입니다.
### 기본 예시
```python
# 원본 딕셔너리
character_to_ids = {'가': 0, '나': 1, '다': 2}
# 역방향 딕셔너리 (기존 방식)
ids_to_character = {}
for char, id in character_to_ids.items():
ids_to_character[id] = char
print(ids_to_character) # {0: '가', 1: '나', 2: '다'}
# 역방향 딕셔너리 (컴프리헨션)
ids_to_character = {id: char for char, id in character_to_ids.items()}
print(ids_to_character) # {0: '가', 1: '나', 2: '다'}
```
### enumerate로 동시에 만들기
```python
ko_chars = ['가', '나', '다']
# 정방향과 역방향 동시에
character_to_ids = {char: i for i, char in enumerate(ko_chars)}
ids_to_character = {i: char for i, char in enumerate(ko_chars)}
print(character_to_ids) # {'가': 0, '나': 1, '다': 2}
print(ids_to_character) # {0: '가', 1: '나', 2: '다'}
```
## 5. 메서드(Method) 개념
### 메서드란?
**메서드** = 특정 자료형(객체)에 딸린 함수들
```python
변수.메서드명()
```
### append() 메서드 상세 분석
```python
# 1부터 5까지 숫자의 제곱을 리스트로 만들기
numbers = []
for i in range(1, 6):
numbers.append(i * i) # append = "추가하다"
print(numbers) # [1, 4, 9, 16, 25]
```
### 단계별 실행 과정
```python
numbers = [] # 빈 리스트로 시작
# 첫 번째 반복: i=1
numbers.append(1 * 1) # numbers.append(1)
print(numbers) # [1]
# 두 번째 반복: i=2
numbers.append(2 * 2) # numbers.append(4)
print(numbers) # [1, 4]
# 세 번째 반복: i=3
numbers.append(3 * 3) # numbers.append(9)
print(numbers) # [1, 4, 9]
```
### 자료형별 주요 메서드
#### 리스트 메서드
```python
my_list = [1, 2, 3]
my_list.append(4) # 끝에 추가: [1, 2, 3, 4]
my_list.remove(2) # 특정 값 제거: [1, 3, 4]
my_list.insert(1, 5) # 특정 위치에 삽입: [1, 5, 3, 4]
length = len(my_list) # 길이: 4
```
#### 문자열 메서드
```python
text = "hello world"
text.upper() # 대문자로: "HELLO WORLD"
text.replace("o", "0") # 치환: "hell0 w0rld"
text.split(" ") # 분할: ["hello", "world"]
text.strip() # 공백 제거
```
#### 딕셔너리 메서드
```python
my_dict = {"a": 1, "b": 2}
my_dict.keys() # 키들: dict_keys(['a', 'b'])
my_dict.values() # 값들: dict_values([1, 2])
my_dict.get("a") # 값 가져오기: 1
```
## 6. 실제 토크나이저 구현 예시
### 완전한 예시 코드
```python
# 1. 고유 문자 추출
ko_text = "안녕하세요 반갑습니다"
ko_chars = sorted(list(set(ko_text)))
print(ko_chars) # [' ', '갑', '니', '다', '반', '세', '습', '안', '요', '하', '녕']
# 2. 문자 ↔ 숫자 매핑 딕셔너리 생성
character_to_ids = {char: i for i, char in enumerate(ko_chars)}
ids_to_character = {i: char for i, char in enumerate(ko_chars)}
print(character_to_ids) # {' ': 0, '갑': 1, '니': 2, ...}
print(ids_to_character) # {0: ' ', 1: '갑', 2: '니', ...}
# 3. 인코딩/디코딩 함수
def token_encode(s):
return [character_to_ids[c] for c in s]
def token_decode(l):
return "".join([ids_to_character[i] for i in l])
# 4. 테스트
text = "안녕"
encoded = token_encode(text)
decoded = token_decode(encoded)
print(f"원본: {text}")
print(f"인코딩: {encoded}")
print(f"디코딩: {decoded}")
```
## 학습 포인트
### 컴프리헨션의 장점
1. **코드가 짧아져요** - 5줄이 1줄로
2. **읽기 쉬워져요** - 의도가 명확
3. **빨라져요** - 파이썬 내부에서 최적화
### 메서드 학습 팁
1. **패턴 인식**: `변수.동작()` 형태
2. **자주 쓰는 것부터**: append, remove, split, join 등
3. **실습**: 직접 써보면서 익히기
4. **검색 습관**: 모르면 바로 찾아보기
---
*Tags: #Python #기초문법 #컴프리헨션 #enumerate #메서드 #토크나이저*