코딩 자율학습 나도코딩의 파이썬 입문

[박대선]

코딩 자율학습 나도코딩의 파이썬 입문 을 읽었다.  소스코드를 코드의 집형태로 다운받아 풀어 확보한후 유튜브를 보고 책을 읽으며 파이썬을 배울 수있도록 기획되었다. 아래 해당 주소가 있으니 필요하면 활용하자. 나는 출판사에서 제공하는 네이버자율학습단카페에도 가입해서 4주과정에 등록했다. 9 https://www.youtube.com/watch?v=kWiCuklohdY 으로 파이썬에 관심있으면 개념도 파악가능하다. 6시간이니 2배속으로해도 3시간은 필요하고 앞의 설치나 자세한 문법은 환경에 따라 다르니 집중하지 않아도 된다. 16 모듈(module)을 사용하는 방법은 아래와 같다.(기본 문법 → 설치 방법 → 직접 모듈 만들기까지 단계별 설명)  

# 1. 파이썬 모듈이란?; Python 파일(.py) 하나가 곧 모듈(module)
* 예: `math.py`, `mymodule.py`
* 모듈 안에는 변수, 함수, 클래스 등이 들어 있음
즉, 다른 파일에서 가져와 재사용할 수 있는 “기능 묶음”.

# 2. 기본 import 방법
1) 전체 모듈 import
```python
import math
print(math.sqrt(16))
```
2) 모듈에서 특정 함수만 import
```python
from math import sqrt
print(sqrt(16))
```
✔ 3) 별칭(alias) 주기
```python
import math as m
print(m.pi)
```
 4) 여러 함수 한번에 가져오기
```python
from math import sin, cos, tan
```

# 3. 외부 모듈(라이브러리) 설치 사용법; 외부 모듈은 우선 설치후 내부와 같이 임포트
1) pip로 설치
```
pip install requests
```
2) 설치 후 import
```python
import requests
r = requests.get("https://example.com")
print(r.status_code)
```
▶ 기억하기:
* `import`는 파이썬이 제공하는 기본 문법
* `pip install`은 *외부 라이브러리*를 내려받는 명령

# 4. 직접 모듈 만들기 (가장 중요한 부분)
1. `mymodule.py` 파일 생성
```python
# mymodule.py
def say_hello(name):
    return f"Hello, {name}!"
```

2. 같은 폴더에 새로운 파일(`main.py`) 생성 후 import
```python
# main.py
import mymodule
print(mymodule.say_hello("Alice"))
```
✔ 같은 폴더에 있기만 하면 모듈처럼 사용할 수 있음!

# 5. 모듈이 있는 위치 확인하기
```python
import math
print(math.__file__)
```

# 6. 폴더를 패키지처럼 사용하기
폴더 구조:
```
myproject/
    utilities/
        __init__.py
        helper.py
    main.py
```
`main.py`에서 사용:
```python
from utilities.helper import my_function
```
▶ `__init__.py` 파일이 있으면 폴더가 “패키지(package)”로 인식됨.

# 7. 모듈 자동 업데이트(리로드)
Jupyter Notebook 또는 REPL에서 모듈을 수정했다면:
```python
import importlib
import importlib.reload(mymodule)
```

# 8. 가장 자주 사용하는 파이썬 표준 모듈
| 모듈           | 기능      |
| `math`       | 기본 수학   |
| `random`     | 랜덤값     |
| `os`         | 파일/디렉토리 |
| `sys`        | 시스템 정보  |
| `datetime`   | 날짜/시간   |
| `json`       | JSON 처리 |
| `re`         | 정규식     |
| `statistics` | 통계      |

pandas·numpy·matplotlib 세 가지 데이터 분석 기본 모듈을 처음부터 사용할 수 있도록 정리한 실전 중심 가이드다.(단계별로 따라 하면 바로 분석 환경 구축 → 데이터 불러오기 → 전처리 → 시각화까지 가능)
# 0. 설치; 먼저 필요한 모듈을 설치.
```bash
pip install numpy pandas matplotlib
```

# 1. NumPy 기본 (수치 계산의 핵심)
**NumPy 배열 생성**
```python
import numpy as np
a = np.array([1, 2, 3])
b = np.array([[1, 2], [3, 4]])
```
**기본 연산**
```python
a + 5
a * 2
a.mean()
a.sum()
```
**랜덤 데이터**
```python
np.random.seed(0)
x = np.random.randn(1000)  # 표준정규분포 1000개
```
➡ **NumPy = 빠른 수학/벡터 연산**

# 2. Pandas 기본 (데이터프레임 처리)
**CSV 불러오기**
```python
import pandas as pd
df = pd.read_csv("data.csv")
```
**데이터 보기**
```python
df.head()
df.info()
df.describe()
```
**열 선택/필터링**
```python
df["age"]
df[df["age"] > 30]
df[(df["age"] > 30) & (df["city"] == "Seoul")]
```
**새 열 추가**
```python
df["income_per_age"] = df["income"] / df["age"]
```
**결측치 처리**
```python
df.isna().sum()
df = df.dropna()
df = df.fillna(0)
```
**그룹 요약 (Groupby)**
```python
df.groupby("city")["income"].mean()
```
➡ **Pandas = 테이블 데이터 처리의 핵심**

# 3. Matplotlib 기본 (시각화)
기본 설정:
```python
import matplotlib.pyplot as plt
```
**라인 그래프**
```python
plt.plot(df["age"], df["income"])
plt.xlabel("Age")
plt.ylabel("Income")
plt.title("Income by Age")
plt.show()
```
**막대 그래프**
```python
df["city"].value_counts().plot(kind="bar")
plt.show()
```
**히스토그램**
```python
df["income"].hist(bins=20)
plt.show()
```
➡ **Matplotlib = 가장 기본적인 그래프 도구**

# 4. 세 모듈을 함께 사용하는 예제; 아래는 가상의 CSV 파일을 읽고 → 전처리 → 분석 → 시각화까지 한 번에 수행하는 예제.
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# 데이터 읽기
df = pd.read_csv("data.csv")
# 결측치 처리
df = df.dropna()
# 새로운 변수 생성
df["income_per_age"] = df["income"] / df["age"]
# 그룹별 평균
grouped = df.groupby("city")["income"].mean()
print(grouped)
# 시각화
plt.figure(figsize=(8,5))
grouped.plot(kind="bar", color="skyblue")
plt.title("Average Income by City")
plt.ylabel("Average Income")
plt.show()
```

# 5. 실전 팁 (초보자 → 중급자)
✔ Numpy는 “숫자 계산”
* 배열 연산, 선형대수, 샘플링
* 머신러닝에서도 내부 계산은 대부분 NumPy 기반

✔ Pandas는 “표 형태 데이터 관리”
* CSV, Excel, SQL, JSON 처리
* 전처리(cleaning)과 EDA(탐색적 분석)의 핵심 도구

✔ Matplotlib은 “기본 그래프”
* seaborn, plotly 사용 전 반드시 익혀야 함
* 데이터 구조가 Pandas DataFrame이면 바로 플롯 가능

# 6. 다음 단계로 추천하는 확장 모듈
| 모듈                | 용도            |
| Seaborn       | 고급 통계 그래프     |
| Plotly        | 인터랙티브 그래프     |
| Scikit-learn  | 머신러닝          |
| Polars        | 초고속 DataFrame |
| Statsmodels | 통계 모델링        |

파이썬(Python) 프로젝트 구조 설계 가이드; 프로젝트 규모와 목적(작은 스크립트 → 패키지 → 애플리케이션)에 따라 구조를 설계할 수 있으며, 유지보수와 협업을 쉽게 해주는 표준적 베스트 프랙티스를 중심으로.
# 1. 기본 원칙
1) 모듈화: 기능 단위로 파일 나누기 (`data.py`, `utils.py`, `visualize.py`)
2) 패키지화: 관련 모듈을 폴더로 묶고 `__init__.py` 추가
3) 분리: 소스 코드 / 테스트 / 데이터 / 문서 / 설정
4) 명확한 네이밍: 폴더와 파일 이름은 소문자+_로 일관

# 2. 작은 프로젝트 구조 (단일 스크립트 → 모듈화)
```
my_project/
├─ main.py          # 프로그램 진입점
├─ utils.py         # 재사용 함수
├─ config.py        # 설정값
├─ data/
│   └─ data.csv
└─ README.md
```
* main.py: 프로그램 실행 파일, 함수 호출 중심
* utils.py: 반복되는 함수 모음
* config.py: 경로, 상수, 파라미터 등 설정 관리
* data/: 원본/처리 데이터 파일
* README.md: 프로젝트 설명

# 3. 중간 규모 프로젝트 구조 (패키지화 + 테스트)
```
my_project/
├─ my_project/           # 실제 파이썬 패키지
│   ├─ __init__.py
│   ├─ main.py
│   ├─ utils.py
│   ├─ data_handler.py
│   └─ visualization.py
├─ tests/                # 단위 테스트
│   ├─ test_utils.py
│   └─ test_data_handler.py
├─ data/
│   ├─ raw/
│   └─ processed/
├─ docs/
│   └─ manual.md
├─ requirements.txt      # pip 패키지 리스트
├─ setup.py              # 패키지 설치용(선택)
└─ README.md
```
* 패키지 폴더(my_project/): 기능별 모듈을 모음
* tests/: pytest, unittest 등 테스트 코드
* requirements.txt: 의존 패키지 명시 (`numpy`, `pandas`, `matplotlib`)
* setup.py: 패키지 배포용

# 4. 큰 규모 프로젝트 구조 (데이터 분석/웹/ML 등)
```
my_project/
├─ my_project/
│   ├─ __init__.py
│   ├─ core/             # 핵심 기능 모듈
│   │   ├─ __init__.py
│   │   ├─ preprocessing.py
│   │   ├─ modeling.py
│   │   └─ eval‎uation.py
│   ├─ data/             # 데이터 입출력 모듈
│   │   ├─ __init__.py
│   │   ├─ loader.py
│   │   └─ saver.py
│   ├─ visualization/    # 시각화 모듈
│   │   ├─ __init__.py
│   │   └─ plot.py
│   └─ main.py           # 프로그램 진입점
├─ tests/
│   ├─ test_core.py
│   ├─ test_data.py
│   └─ test_visualization.py
├─ notebooks/            # Jupyter Notebook
├─ data/
│   ├─ raw/
│   └─ processed/
├─ docs/
├─ scripts/              # 실행용 단일 스크립트
├─ requirements.txt
├─ setup.py
└─ README.md
```

# 5. 추가 권장 사항
1) 버전 관리: git 사용, `.gitignore` 설정 (`__pycache__/`, `*.pyc`)
2) 가상환경: venv, conda 등으로 의존성 격리
3) 코딩 스타일: PEP8 준수 (`black`, `flake8`)
4) 로깅: print 대신 `logging` 사용
5) 문서화: docstring, README, Sphinx 등

# 6. 실전 팁 
* 작은 프로젝트는 단일 스크립트 → 점차 모듈화
* 테스트는 초반부터 작성 → 유지보수 용이
* 데이터/설정/코드 분리 → 재현성 확보
* 패키지화 → 다른 프로젝트에서 재사용 가능

모듈을 사용할 때는 "from 모듈명 import 기능"을 해서 '기능'으로 사용하거나 "import 모듈명"으로 해서 '모듈명.기능'으로 사용한다. 임포트 다음이 로드되기에 이를 중심으로 사용하는 것이 원칙이기 때문인듯하다. 62 인덱스는 0에서 시작하고 슬라이싱으로 문자열의 일부를 추출하는 경우 콜론으로 시작위치와 마지막위치다음으로 구분한다. 즉 '123456789'에서 '2345'를 추출하려면 [2:5]가 아닌 [1:6]을 사용해야 하는 것이다. 첫위치나 마지막위치는 생략가능하므로 [:6] 혹은 [2:]은 [0:6] 혹은 [2:10]을 의미한다. -를 사용하여 뒤부터 위치지정도 가능하다. 마지막이 -1부터 시작하므로 처음부터 뒤에서 3번째까지를 원하면 [:-3]를 사용하여 '1234567'을 추출할 수있다. 0부터 시작하여 앞뒤로 +-1씩 변하는 것은 자연스럽지만 마지막위치는 이해하기 어렵다. 하지만 외국어를 배울 때도 사과가 왜 애플인지 묻기어려우니 그냥 암기하자. 74

문자열은 `str` 타입이며, 대부분의 함수는 `"문자열".함수()` 형태로 사용한다.
1. 문자열 정보 확인 / 길이
| `len(s)`       | 문자열 길이 반환  | `len("hello")  → 5`          |
| `s.isalpha()`  | 알파벳만?      | `"abc".isalpha()  → True`    |
| `s.isdigit()`  | 숫자만?       | `"123".isdigit()  → True`    |
| `s.isalnum()`  | 문자+숫자?     | `"abc123".isalnum()  → True` |
| `s.islower()`  | 모두 소문자?    | `"abc".islower()  → True`    |
| `s.isupper()`  | 모두 대문자?    | `"ABC".isupper()  → True`    |
| `s.isspace()`  | 공백만?       | `"   ".isspace()  → True`    |

2. 문자열 변경
| `s.lower()`        | 소문자로           | `"HeLLo".lower()  → "hello"`     |
| `s.upper()`        | 대문자로           | `"HeLLo".upper()  → "HELLO"`     |
| `s.capitalize()`   | 첫 글자만 대문자     | `"hello world".capitalize()`    → "Hello world"`   |
| `s.title()`        | 단어마다 첫 글자 대문자 | `"hello world"  → "Hello World"` |
| `s.swapcase()`     | 대 ↔ 소문자 변환  | `"Hello"  → "hELLO"`             |
| `s.replace(a, b)`  | 문자열 치환         | `"hi hi".replace("hi", "yo")`   → "yo yo"`   |

3. 검색
| `s.find(x)`   | x의 위치, 없으면 -1 | `"apple".find("p")  → 1"`   | 여기서 인덱스를 파인드에 저장하고 이를 이용하여 파인드+1부터 앞을 생략하고 검색지속이 가능하다. 즉 "apple".find("p", find+1)은 2가 나온다.
| `s.rfind(x)`  | 뒤에서부터 찾기      | `"apple".rfind("p")  → 2"`  |
| `s.index(x)`  | x의 위치, 없으면 에러 | `"apple".index("p")  → 1"`  |따라서 인덱스함수사용을 자제하고 가급적 파인드함수를 사용하는 것이 좋다. 에러가 발생하면 기분도 별로인데다가 프로그램을 수정하고 재실행해야 하기 때문이다. 재실행이 필요한 경우 등은 예외다. 
| `s.count(x)`  | x의 개수          | `"banana".count("a")  → 3"` |

4. 문자열 자르기 / 결합
| `s.split(delim)`    | 구분자로 나누기     | `"a,b,c".split(",")`                |
| `s.rsplit(delim)`   | 오른쪽부터 나누기    | 동일                                  |
| `delim.join(list)`  | 리스트를 문자열로 결합 | `".".join(["a","b","c"]) → "a.b.c"` |

5. 공백 처리
| `s.strip()`   | 양쪽 공백 제거   | `"  hi  ".strip()  → "hi"` |
| `s.lstrip()`  | 왼쪽 공백 제거   | `"  hi".lstrip()  → "hi"`  |
| `s.rstrip()`  | 오른쪽 공백 제거  | `"hi  ".rstrip()  → "hi"`  |

6. 정렬·배치
| `s.center(n)`  | 가운데 정렬      | `"hi".center(6)  → "  hi  "` |
| `s.ljust(n)`   | 왼쪽 정렬       | `"hi".ljust(5)  → "hi   "`   |
| `s.rjust(n)`   | 오른쪽 정렬      | `"hi".rjust(5) → "   hi"`   |
| `s.zfill(n)`   | 앞쪽을 0으로 채움  | `"42".zfill(5)  → "00042"`   |

7. 문자열 확인 관련
| `s.startswith(x)`  | x로 시작?   | `"hello".startswith("he")` |
| `s.endswith(x)`    | x로 끝나나?  | `"hello".endswith("lo")`   |

8. 고급 기능
| `s.encode()`  | 문자열 → 바이트                        |
| `b.decode()`  | 바이트 → 문자열                        |
| `s.format()`  | 문자열 포매팅 (`"{} {}".format(a, b)`) |
| `f"{변수}"`     | f-string (최신, 가장 권장)             |

✔ 예제 코드
```python
text = "Hello World"
print(text.lower())       # hello world
print(text.upper())       # HELLO WORLD
print(text.split())       # ['Hello', 'World']
print(text.replace("World", "Python"))   # Hello Python
print(".".join(["a", "b", "c"]))         # a.b.c
```76 

문자열 포매팅(String Formatting)은 문자열 안에 변수를 넣거나 특정 형식으로 출력할 때 사용하는 방법이고 3가지 방식이 있다.
1. f-string (가장 많이 사용, Python 3.6+); 가장 직관적이고 빠른 문자열 포맷팅 방식.
```python
name = "철수"
age = 20
print(f"이름: {name}, 나이: {age}")
```
▶️ 출력
```
이름: 철수, 나이: 20
```
🎯 장점
* 변수 직접 사용: `{변수}`
* 수식 가능: `{1+2}`, `{age * 2}`
* 함수 호출도 가능
```python
print(f"5 + 3 = {5 + 3}")
```

2. format() 방식
```python
name = "영희"
age = 21
print("이름: {}, 나이: {}".format(name, age))
```
# 숫자 인덱스로 위치 지정
```python
print("이름: {0}, 나이: {1}".format(name, age))
```
# 키워드로 지정
```python
print("이름: {n}, 나이: {a}".format(n=name, a=age))
```

3. % 방식 (오래된 방식, C 스타일)
```python
name = "민수"
age = 22
print("이름: %s, 나이: %d" % (name, age))
```
# 서식 지정자
| 서식     | 의미            |
| `%s`   | 문자열(string)   |
| `%d`   | 정수(integer)   |
| `%f`   | 실수(float)     |
| `%.2f` | 소수점 2자리까지만 출력 |
예:
```python
print("키: %.2fcm" % 175.1234)   # 175.12
```

# 포매팅 공통 옵션
✔ 소수점 자리수
```python
value = 3.141592
print(f"{value:.2f}")      # 3.14
print("{:.2f}".format(value))  # 3.14
```
✔ 너비(width) 지정
```python
print(f"{42:5}")   # '   42'
```
✔ 0으로 채우기
```python
print(f"{42:05}")  # '00042'
```
✔ 정렬
```python
print(f"{'hi':<10}")   # 왼쪽 정렬
print(f"{'hi':>10}")   # 오른쪽 정렬
print(f"{'hi':^10}")   # 가운데 정렬
```

# 비교 요약
| 방식            | 장점              | 단점               |
| f-string  | 가장 직관적, 빠름, 권장  | Python 3.6+ 필요   |
| format()  | 위치/이름 지정 편함     | f-string보다 길고 복잡 |
| % 방식      | 간단한 출력에 짧음      | 오래된 스타일, 비추천     |

문자열 연결은 +나 ,를 사용하며 ,는 한칸띄기가 자동이다. 서식 지정자(format specifier)는 문자열 안에 값의 자료형, 출력 형식, 자릿수, 정렬 방식 등을 지정할 때 사용하며 주로 % 포매팅 방식과 format()/f-string 방식 두 가지에서 사용된다.
1. % 포매팅에서 쓰는 서식 지정자
| `%s`    | 문자열(string)  | `"이름: %s" % "철수"`          → 이름: 철수|
| `%d`    | 정수(integer)  | `"나이: %d" % 20`                → 나이: 20|
| `%f`    | 실수(float)    | `"키: %f" % 175.3`              → 키: 175.3|
| `%.2f`  | 소수점 2자리      | `"%.2f" % 3.14159  → 3.14` |
| `%c`    | 문자 하나        | `"%c" % 'A'`                   → A|
| `%o`    | 8진수          | `"%o" % 10  → 12`          |
| `%x`    | 16진수(소문자)    | `"%x" % 255  → ff`         |
| `%X`    | 16진수(대문자)    | `"%X" % 255  → FF`         |
| `%%`    | % 자체 출력      | `"100%%"`                      → %|

✔ 폭(width), 정렬
| `%10d`   | 10칸 확보 후 오른쪽 정렬     |
| `%-10d`  | 10칸 확보 후 왼쪽 정렬      |
| `%010d`  | 10칸 확보 + 빈칸을 0으로 채움 |
예:
```python
print("%10d" % 42)      # '        42'
print("%-10d" % 42)     # '42        '
print("%010d" % 42)    # '0000000042'
```
2. format() / f-string의 서식 지정자; 서식 지정은 { } 안의 : 뒤에 형식을 넣는 방식.
예) `f"{값:서식}"`

🔹 정수 포매팅
| `d`       | 정수    | `f"{42:d}"`        |
| `x`, `X`  | 16진수  | `f"{255:x}"  → ff`  |
| `o`       | 8진수   | `f"{10:o}"  → 12`   |
| `b`       | 2진수   | `f"{10:b}"  → 1010` |
🔹 실수 포매팅
| `f`        | 고정 소수점   | `f"{3.14:f}"`             |
| `.2f`      | 소수점 2자리  | `f"{3.14159:.2f}"  → 3.14` |
| `e` / `E`  | 지수 표현    | `f"{0.00123:e}"`          |

🔹 정렬 및 채우기
형식: `"{값:채우기문자정렬폭}"`
| `<`      | 왼쪽 정렬       | `f"{'hi':<10}"`      |
| `>`      | 오른쪽 정렬      | `f"{'hi':>10}"`      |
| `^`      | 가운데 정렬      | `f"{'hi':^10}"`      |
| `0` 채우기 | 숫자를 0으로 채움 | `f"{42:05}"  → 00042` |

🔹 천 단위 콤마 추가
```python
f"{1000000:,}"     # '1,000,000'
"{:,}".format(1000000)
```

탈출문자(Escape Sequence)는 문자열 안에서 특수한 기능을 하는 문자 조합이다. 주로 `\`(백슬래시)로 시작하며, 보통 문자열 안에서 바로 표현하기 어려운 문자들을 나타낼 때 사용한다.
| 탈출문자          | 의미              | 예시                      |
| `\'`          | 작은따옴표           | `'It\'s mine'`          |
| `\"`          | 큰따옴표            | `"He said \"Hi\""`      |
| `\\`          | 역슬래시 출력         | `"C:\\Program Files\\"` |
| `\n`          | 줄바꿈(new line)   | `"Hello\nWorld"`        |
| `\t`          | 탭(tab)          | `"Name:\tJohn"`         |
| `\r`          | 커서를 줄 처음으로 | `"Hello\rHi"`           |
| `\b`          | 백스페이스           | `"abc\b"`               |
| `\f`          | 폼피드(form feed) | 잘 안 쓰임                  |
| `\v`          | 수직 탭            | 거의 사용 X                 |
| `\0`          | Null 문자        | `"abc\0def"`            |
| `\xhh`        | 16진수 ASCII 문자  | `"\x41" → 'A'`          |
| `\ooo`        | 8진수 ASCII 문자    | `"\101" → 'A'`          |
| `\uXXXX`      | 유니코드(4자리)      | `\uAC00 → '가'`          |
| `\UXXXXXXXX`  | 유니코드(8자리)      | `\U0001F600 → 😀`       |

# 가장 많이 쓰는 것들 예시
✔ 줄바꿈 `\n`
```python
print("Hello\nWorld")
```
출력:
```
Hello
World
```
✔ 탭 `\t`
```python
print("Name:\tJohn")
```
출력:
```
Name:   John
```
✔ 따옴표 출력
```python
print("He said \"Hi\"")
print('It\'s OK')
```
✔ 역슬래시 자체 출력
```python
print("C:\\Users\\Tom")
```
# 원시 문자열(raw string) — 역슬래시를 문자 그대로 사용하고 싶을 때 `r"문자열"` 형태로 쓰면 `\`가 탈출문자로 처리되지 않는다.
```python
print(r"C:\Users\Tom")
```
출력:
```
C:\Users\Tom
``` 84 

파이선을 실행하려면 원도하단의 검색창에서 python을 입력하고 >>>표시가 나오면 명령을 입력할 상태가 된 것이다. 86 파이썬에서 리스트(list)란 숫자나 문자, 다른 리스트 등 여러 값을 하나의 변수에 순서대로 저장할 수 있는 변경 가능한(mutable) 자료형이다.
```python
# 리스트 생성
fruits = ["apple", "banana", "cherry"]
# 요소 접근
print(fruits[0])  # apple
# 요소 추가
fruits.append("orange")
# 요소 삭제
fruits.remove("banana")
# 리스트 길이
print(len(fruits))
```

✔️ 기본 기능 요약
| `append(x)`                      | 리스트 끝에 요소 추가                     | `[1,2].append(3)`  → `[1,2,3]`       |
| `extend(iterable)`               | 리스트를 확장 (여러 요소 추가)               | `[1,2].extend([3,4])`  → `[1,2,3,4]` |
| `insert(i, x)`                   | 원하는 위치에 요소 삽입                    | `[1,3].insert(1,2)`  → `[1,2,3]`     |
| `remove(x)`                      | 값 x 제거 (첫 번째만)                   | `[1,2,2,3].remove(2)`  → `[1,2,3]`   |
| `pop([i])`                       | 인덱스 i 위치 요소 제거 후 반환 (i 없으면 마지막)  | `[1,2,3].pop()`  → 3, 리스트는 `[1,2]`   |
| `clear()`                        | 모든 요소 삭제                         | `[1,2,3].clear()`  → `[]`            |
| `index(x[, start[, end]])`       | 값 x의 인덱스 반환                      | `[1,2,3].index(2)`  → 1              |
| `count(x)`                       | 값 x의 등장 횟수 반환                    | `[1,2,2,3].count(2)`  → 2            |
| `sort(key=None, reverse=False)`  | 오름차순 정렬 (reverse=True 시 내림차순)    | `[3,1,2].sort()`  → `[1,2,3]`        |
| `reverse()`                      | 리스트 요소 순서 뒤집기                    | `[1,2,3].reverse()`  → `[3,2,1]`     |
| `copy()`                         | 리스트 복사 (shallow copy)            | `lst2 = lst1.copy()`                |

# 내장 함수와 함께 사용
| `len(list)`       | 리스트 길이           | `len([1,2,3])`  → 3              |
| `sum(list)`       | 모든 요소 합          | `sum([1,2,3])`  → 6              |
| `max(list)`       | 최대값              | `max([1,2,3])`  → 3              |
| `min(list)`       | 최소값              | `min([1,2,3])`  → 1              |
| `list(iterable)`  | 반복 가능한 객체 → 리스트  | `list("abc")`  → `['a','b','c']` |

# 예제
```python
numbers = [3, 1, 4, 1, 5]
numbers.append(9)         # [3,1,4,1,5,9]
numbers.insert(2, 2)      # [3,1,2,4,1,5,9]
numbers.remove(1)          # [3,2,4,1,5,9]
numbers.sort()             # [1,2,3,4,5,9]
numbers.reverse()          # [9,5,4,3,2,1]
print(numbers.count(4))    # 1
print(numbers.index(3))    # 3
``` 94

딕셔너리(dictionary)란 키(key)와 값(value) 쌍으로 데이터를 저장하는 변경 가능한(mutable) 자료형이다. 순서가 있으며(파이썬 3.7+), 키는 고유해야 한다.
✔️ 기본 예시
```python
person = {
    "name": "Alice",
    "age": 25,
    "city": "Seoul"
}
print(person["name"])  # Alice
```
✔️ 주요 기능
*1. 요소 추가/수정
```python
person["job"] = "developer"  # 추가
person["age"] = 26           # 수정
```
*2. 요소 삭제
```python
del person["city"]      # 특정 키 삭제
person.pop("age")       # pop()으로 삭제
person.clear()          # 모든 요소 삭제
```
*3. 딕셔너리 순회
```python
for key in person:
    print(key, person[key])
for key, value in person.items():
    print(key, value)
```
*4. 값 얻기 (안전하게)
```python
person.get("age", 0)  # 키 없으면 기본값 0 반환
```
✔️ 딕셔너리 활용 예
### JSON 데이터 다루기
```python
import json
data = '{"name": "Bob", "age": 30}'
obj = json.loads(data)
print(obj["name"])
```
### 카운팅
```python
count = {}
for ch in "hello":
    count[ch] = count.get(ch, 0) + 1
``` 
## 딕셔너리 주요 메서드
| `dict.keys()`               | 모든 키 반환                | `{'a':1,'b':2}.keys()`  → `dict_keys(['a','b'])`           |
| `dict.values()`             | 모든 값 반환                | `{'a':1,'b':2}.values()`  → `dict_values([1,2])`           |
| `dict.items()`              | 키-값 쌍 반환               | `{'a':1,'b':2}.items()`  → `dict_items([('a',1),('b',2)])` |
| `dict.get(key, default)`    | 키에 해당하는 값 반환, 없으면 기본값  | `d.get('c',0)`  → 0                                        |
| `dict.pop(key[, default])`  | 키 제거 후 값 반환            | `d.pop('a')`  → 1                                          |
| `dict.popitem()`            | 마지막 키-값 쌍 제거 후 반환      | `d.popitem()`  → ('b',2)                                   |
| `dict.update(other_dict)`   | 다른 딕셔너리로 값 업데이트        | `d.update({'b':3, 'c':4})`                                |
| `dict.clear()`              | 모든 요소 제거               | `d.clear()`  → `{}`                                        |
| `dict.copy()`               | 얕은 복사                  | `d2 = d.copy()`                                           |

## 내장 함수와 함께 사용
| `len(dict)`     | 딕셔너리 항목 수         | `len({'a':1,'b':2})`  → 2                    |
| `dict()`        | 다른 자료형 → 딕셔너리 변환  | `dict([('a',1),('b',2)])`  → `{'a':1,'b':2}` |
| `sorted(dict)`  | 키 기준 정렬된 리스트 반환   | `sorted({'b':2,'a':1})`  → `['a','b']`       |

## 예제
```python
person = {"name": "Alice", "age": 25, "city": "Seoul"}
# 값 가져오기
print(person.get("age"))  # 25
print(person.get("job", "None"))  # None
# 키, 값, 쌍
print(person.keys())    # dict_keys(['name','age','city'])
print(person.values())  # dict_values(['Alice',25,'Seoul'])
print(person.items())   # dict_items([('name','Alice'),('age',25),('city','Seoul')])

# 값 수정/추가
person["age"] = 26
person["job"] = "developer"
# 제거
person.pop("city")
last_item = person.popitem()  # ('job', 'developer')
``` 101

튜플(tuple)이란 
* 여러 값을 순서대로 저장할 수 있는 자료형
* 변경 불가능(immutable) → 값을 수정할 수 없음
* 리스트와 비슷하지만 읽기 전용 형태로 사용될 때 유용

✔️ 기본 예시
```python
numbers = (1, 2, 3)
print(numbers[0])  # 1
```
✔️ 튜플의 특징
*1. 변경 불가
```python
numbers[0] = 10   # 에러 발생
```
*2. 다양한 타입 저장 가능
```python
mix = (1, "apple", True)
```
*3. 언패킹(unpacking) 가능
```python
a, b, c = (10, 20, 30)
print(a, b, c)  # 10 20 30
```
*4. 한 요소만 가진 튜플; 콤마(,)가 중요!
```python
t = (5,)     # 튜플
x = (5)      # 정수
```

✔️ 언제 튜플을 사용할까?
* 값이 변하면 안 되는 데이터일 때
* 함수에서 여러 값을 반환할 때
* 리스트보다 속도가 빠른 경우가 많아 성능상 이점이 필요할 때

✔️ 예시: 함수 반환값
```python
def calc(x, y):
    return x + y, x * y
result = calc(3, 4)  # (7, 12)
```107

세트(set)란?
* 중복을 허용하지 않는 자료형
* 순서가 없다(unordered)
* 변경 가능(mutable)
* 교집합/합집합/차집합 같은 수학적 집합 연산이 가능

✔️ 기본 예시
```python
s = {1, 2, 3, 3, 4}
print(s)   # {1, 2, 3, 4}  → 중복 제거됨
```
✔️ 주요 기능
*1. 원소 추가/삭제
```python
s.add(5)      # 요소 추가
s.remove(2)   # 요소 삭제 (없으면 에러)
s.discard(10) # 요소 삭제 (없어도 에러 없음)
s.clear()     # 모두 삭제
```

✔️ 집합 연산
*1. 합집합
```python
a | b
a.union(b)
```
*2. 교집합
```python
a & b
a.intersection(b)
```
*3. 차집합
```python
a - b
a.difference(b)
```
*4. 대칭차집합
```python
a ^ b
a.symmetric_difference(b)
```

✔️ 예시
```python
a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # {1, 2, 3, 4, 5}
print(a & b)  # {3}
print(a - b)  # {1, 2}
print(a ^ b)  # {1, 2, 4, 5}
```

✔️ 세트의 활용
* 리스트의 중복을 빠르게 제거할 때
```python
lst = [1, 1, 2, 3, 3]
unique = list(set(lst))
```

* 값이 포함되어 있는지(멤버십 검사) 빠르게 확인할 때
```python
if "apple" in {"apple", "banana"}:
    print("있음!")
```109

자료구조 변환은 한 자료형을 다른 자료형으로 바꾸는 것을 말하고 주로 리스트, 튜플, 세트, 딕셔너리 사이에서 변환을 많이 한다.
1️ 리스트(List) 변환
```python
# 튜플 → 리스트
t = (1, 2, 3)
lst = list(t)  # [1, 2, 3]
# 세트 → 리스트
s = {4, 5, 6}
lst2 = list(s)  # [4, 5, 6] (순서 보장 X)
```

2️ 튜플(Tuple) 변환
```python
# 리스트 → 튜플
lst = [1, 2, 3]
t = tuple(lst)  # (1, 2, 3)
# 세트 → 튜플
s = {4, 5, 6}
t2 = tuple(s)  # (4, 5, 6) (순서 보장 X)
```

3️ 세트(Set) 변환
```python
# 리스트 → 세트 (중복 제거)
lst = [1, 2, 2, 3]
s = set(lst)  # {1, 2, 3}
# 튜플 → 세트
t = (4, 5, 5, 6)
s2 = set(t)  # {4, 5, 6}
```

4️ 딕셔너리(Dictionary) 변환; 딕셔너리로 변환할 때는 키-값 쌍이 필요.
```python
# 리스트 → 딕셔너리 (튜플 2개짜리 요소)
lst = [("a", 1), ("b", 2)]
d = dict(lst)  # {'a': 1, 'b': 2}
# 세트 → 딕셔너리 (값만 키로 사용)
s = {"x", "y"}
d2 = dict.fromkeys(s, 0)  # {'x': 0, 'y': 0}
```

🔹 요약
| 변환 전         | 변환 후    | 함수/방법                  |
| 리스트          | 튜플      | `tuple(lst)`           |
| 튜플           | 리스트     | `list(t)`              |
| 리스트/튜플       | 세트      | `set(lst)`             |
| 세트           | 리스트/튜플  | `list(s)` / `tuple(s)` |
| 리스트(튜플 2개씩) | 딕셔너리    | `dict(lst)`            |
| 세트           | 딕셔너리    | `dict.fromkeys(s, 값)`  |112

조건문(if문)은 특정 조건이 참(True)일 때만 코드를 실행하고, 거짓(False)이면 다른 코드를 실행하도록 할 때 사용한다.
# 파이썬 조건문 기본 형태
```python
if 조건:
    실행문
```
### 예시
```python
x = 10
if x > 5:
    print("x는 5보다 큽니다.")
```

# if - else
```python
if 조건:
    실행문1
else:
    실행문2
```
### 예시
```python
age = 15
if age >= 20:
    print("성인입니다.")
else:
    print("미성년자입니다.")
```

# if - elif - else; 여러 조건을 체크할 때 사용.
```python
if 조건1:
    실행문1
elif 조건2:
    실행문2
else:
    실행문3
```
### 예시
```python
score = 85
if score >= 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 70:
    print("C")
else:
    print("D")
```

# 조건문의 들여쓰기(Indentation); 파이썬에서는 들여쓰기(스페이스 4칸) 가 매우 중요.
```python
if True:
    print("이 줄은 들여쓰기 필요")
print("이 줄은 조건문 밖")
```

# 비교/논리 연산자 정리
✔ 비교 연산자
| `==`  | 같다     |
| `!=`  | 같지 않다  |
| `>`   | 크다     |
| `<`   | 작다     |
| `>=`  | 크거나 같다 |
| `<=`  | 작거나 같다 |
✔ 논리 연산자
| `and`  | 둘 다 True      |
| `or`   | 하나라도 True     |
| `not`  | True/False 반전 |
예시:
```python
x = 10
if x > 5 and x < 20:
    print("x는 5보다 크고 20보다 작다.")
```120

파이썬에서 들여쓰기(Indentation)와 콜론(:)은 조건문, 반복문, 함수 등 블록 구조를 만드는 핵심 요소다. 다른 언어와 달리 `{ }`를 사용하지 않고, 콜론과 들여쓰기로 코드 범위를 결정한다.
# 1. 콜론(:)의 역할; 파이썬에서 여기서부터 새로운 코드 블록이 시작된다는 의미.
사용되는 위치:
* `if`, `elif`, `else`
* `for`, `while`
* `def` 함수 정의
* `class` 정의
* `try`, `except`, `finally`
예시:
```python
if x > 10:
    print("10보다 큼")
```
`:`은 조건이 끝났음을 알려주고, 그 다음 줄부터 들여쓰기된 블록 시작을 의미.

# 2. 들여쓰기(Indentation)의 역할; 파이썬은 들여쓰기(스페이스 4칸) 로 같은 블록에 속하는 코드들을 묶는다.
예시:
```python
if x > 10:
    print("조건 참일 때 실행됨")
    print("이 줄도 if 블록 안")
print("이 줄은 if 블록 밖")
```
들여쓰기된 두 줄은 `if`에 속하고, 마지막 줄은 들여쓰기가 없어서 if문 밖.

# 들여쓰기 오류 예제
❌ **오류 발생**
```python
if x > 10:
print("오류!")
```
오류 메시지: `IndentatixxonError: expected an indented block` → 조건문 뒤에는 반드시 들여쓴 코드가 있어야 함.
✔ 올바른 예시
```python
if x > 10:
    print("정상입니다!")
```

# 들여쓰기는 스페이스 4칸이 표준
* PEP 8(파이썬 공식 스타일 가이드) 권장사항
* Tab(탭) 대신 스페이스 4칸 사용이 일반적
* IDE나 에디터에서 자동 설정 가능

# 콜론 + 들여쓰기 함께 보기
```python
age = 18
if age >= 20:
    print("성인입니다.")
else:
    print("미성년자입니다.")
print("프로그램 종료")
```121

입력문(input)은 사용자가 키보드로 입력한 값을 프로그램에서 받아서 사용할 때 쓰는 함수다.
# 1. 기본 input() 사용법
```python
변수 = input("안내문구")
```
예시:
```python
name = input("이름을 입력하세요: ")
print("안녕하세요,", name, "님!")
```

# 2. input()은 항상 문자열(str)로 입력됨; 숫자를 입력해도 문자열로 받아온다. 
예시:
```python
age = input("나이 입력: ")
print(type(age))   # <class 'str'>
```

# 3. 숫자로 사용하려면 형 변환 필요
🔹 정수(int)로 변환
```python
age = int(input("나이를 입력하세요: "))
print(age + 1)
```
🔹 실수(float)로 변환
```python
height = float(input("키를 입력하세요: "))
print(height + 1.5)
```

# 4. 여러 값을 한 번에 입력받기
### 공백으로 구분된 값 입력
```python
a, b = input("두 숫자 입력: ").split()
```
### 숫자로 변환
```python
a, b = map(int, input("두 숫자를 입력하세요: ").split())
print(a + b)
```

# 5. 입력 예시 모음
✔ 단어 입력
```python
word = input("단어: ")
```
✔ 한 줄 문장 입력
```python
sentence = input("문장: ")
```
✔ 리스트로 입력 받기
```python
items = input("값들을 입력: ").split()
print(items)
```

# 간단한 종합 예제
```python
name = input("이름: ")
age = int(input("나이: "))
if age >= 20:
    print(name, "님은 성인입니다.")
else:
    print(name, "님은 미성년자입니다.")
``` 123

파이썬의 반복문(loop)은 코드를 여러 번 반복해서 실행할 때 사용한다. 대표적으로 for문과 while문 두 가지가 있다.
# 1. for 반복문; 일정 횟수 반복하거나, 리스트·문자열 같은 데이터를 하나씩 꺼낼 때 사용.
✔ 기본 형태
```python
for 변수 in 반복가능한자료:
    실행문
```
🔹 예제 1: 1부터 5까지 출력
```python
for i in range(1, 6):
    print(i)
```
`range(1,6)`은 1~5를 의미합니다.
🔹 예제 2: 리스트 반복
```python
fruits = ["사과", "바나나", "포도"]
for f in fruits:
    print(f)
```
🔹 예제 3: 문자열 반복
```python
for ch in "hello":
    print(ch)
```

✔ range() 설명; `range(시작, 끝, 증가폭)`
```python
range(5)        # 0~4
range(1, 5)     # 1~4
range(1, 10, 2) # 1, 3, 5, 7, 9
```

# 2. while 반복문; 조건이 참(True) 동안 계속 반복.
✔ 기본 형태
```python
while 조건:
    실행문
```
🔹 예제 1: 1~5까지 출력
```python
i = 1
while i <= 5:
    print(i)
    i += 1
```
🔹 예제 2: 무한 반복
```python
while True:
    print("무한 반복입니다")
```
❗ 꼭 `break`로 탈출해야 함!

# ✂ break / continue
✔ break: 반복문 종료
```python
for i in range(10):
    if i == 5:
        break
    print(i)
```
✔ continue: 다음 반복으로 건너뛰기
```python
for i in range(5):
    if i == 2:
        continue
    print(i)
```

🎮 간단한 실전 예제: 비밀번호 맞추기
```python
correct = "1234"
while True:
    pw = input("비밀번호 입력: ")
    if pw == correct:
        print("로그인 성공!")
        break
    else:
        print("틀렸습니다.")
```128

파이썬의 한 줄 for문(리스트 컴프리헨션)은 짧고 깔끔하게 리스트를 만들거나 표현할 때 사용한다.
# 1. 기본 형태 (리스트 컴프리헨션)
```python
[표현식 for 변수 in 반복가능한자료]
```
🔹 예제 1: 1~5까지 리스트 만들기
```python
nums = [i for i in range(1, 6)]
print(nums)
# [1, 2, 3, 4, 5]
```
🔹 예제 2: 각 숫자에 2를 곱한 리스트
```python
double = [i * 2 for i in range(5)]
print(double)
# [0, 2, 4, 6, 8]
```
🔹 예제 3: 문자열 각 글자를 리스트로
```python
chars = [c for c in "hello"]
print(chars)
# ['h', 'e', 'l', 'l', 'o']
```

# 2. 조건문 포함 한 줄 for문
```python
[표현식 for 변수 in 자료 if 조건]
```
🔹 예제 4: 짝수만 리스트로
```python
evens = [i for i in range(10) if i % 2 == 0]
print(evens)
# [0, 2, 4, 6, 8]
```
🔹 예제 5: 문자열에서 모음만 뽑기
```python
vowels = [ch for ch in "apple" if ch in "aeiou"]
print(vowels)
# ['a', 'e']
```

# 3. if-else 포함 한 줄 for문; 형태가 조금 다릅니다. **if-else가 표현식 안에 들어가야 합니다.**
```python
[값1 if 조건 else 값2 for 변수 in 자료]
```
🔹 예제 6: 짝수/홀수 구분 리스트
```python
result = ["짝수" if i % 2 == 0 else "홀수" for i in range(5)]
print(result)
# ['짝수', '홀수', '짝수', '홀수', '짝수']
```

👍 한 줄 for문의 장점
* 코드가 짧아지고 깔끔함
* 리스트 생성이 빠름
* 직관적인 반복 + 조건 처리 136

파이썬에서 함수를 만드는 기본 방법
```python
def 함수이름(매개변수):
    수행할_코드
    return 반환값
```

📌 예시 1: 인사하는 함수
```python
def hello(name):
    print(f"안녕하세요, {name}님!")
```
사용:
```python
hello("민수")
```
📌 예시 2: 두 수를 더해 반환하는 함수
```python
def add(a, b):
    return a + b
```
사용:
```python
result = add(3, 5)
print(result)  # 8
```
📌 예시 3: 매개변수가 없는 함수
```python
def say_hi():
    return "Hi!"
```143

파이썬 코드 스타일 가이드는 주로 PEP 8을 기준으로 한다. 아래는 가장 중요한 항목들을 실무 기준에 맞춰 정리한 핵심 스타일 가이드다.
1. 들여쓰기(Indentation); 공백 4칸 사용 (탭 사용 ❌)
```python
def func():
    if True:
        print("OK")
```
2. 줄 길이(Line length); 한 줄은 79자 이하 권장, 긴 import 문이나 표현식은 괄호로 묶어서 줄 바꿈
```python
from module import (very_long_function_name,
                    another_function_name)
```
3. 빈 줄(Blank lines)
* 함수 사이: 2줄
* 클래스 내부 메서드 사이: 1줄

4. 네이밍 규칙(Naming)
### 함수, 변수: snake_case
```python
user_name = "Tom"
def get_user():
    ...
```
### 클래스: CamelCase
```python
class MyClass:
    ...
```
### 상수: UPPER_CASE
```python
MAX_SIZE = 100
```
5. 공백(Whitespace) 규칙
### 연산자 앞뒤로 공백 1칸
```python
a = b + 3
```
### 함수 호출 시 괄호 안에 공백 넣지 않기
```python
func(1, 2)   # good
func( 1, 2 ) # bad
```
6. 문자열 따옴표
* `'` 또는 `"` 아무거나 사용 가능
* 프로젝트 내에서 일관성 유지가 중요

7. 주석(Comment)
### 한 줄 주석
```python
# 사용자 정보를 가져오는 함수
def get_user():
    ...
```
### Docstring(함수 설명)
```python
def add(a, b):
    """두 숫자를 더해 반환한다."""
    return a + b
```
8. import 스타일
* 항상 파일 상단에 작성
* 순서:
  1. 표준 라이브러리
  2. 서드파티 라이브러리
  3. 로컬 모듈
```python
import os
import sys
import requests
from myproject.utils import helper
```
9. 예외 처리 스타일
```python
try:
    x = int(value)
except ValueError:
    print("Invalid number")
```
10. 라인 계속(Line continuation); 괄호 사용 권장 (백슬래시 \ 지양)
```python
total = (
    price
    + tax
    - discount
)
```
# 요약
| 들여쓰기    | 4칸                              |
| 길이      | 줄당 79자                          |
| 네이밍     | 변수/함수 snake_case, 클래스 CamelCase |
| 공백      | 연산자 앞뒤, 괄호 안 X                  |
| 주석      | Docstring 사용                    |
| import  | 표준 → 서드파티 → 로컬                  | 149

파이썬에서 함수 매개변수의 기본값(default value)을 사용하면 함수 호출 시 일부 인자를 생략할 수 있어서 코드가 더 깔끔해진다.
1️ 기본 문법
```python
def 함수이름(매개변수=기본값):
    수행할_코드
```
* 매개변수에 값이 전달되면 전달된 값 사용
* 값이 전달되지 않으면 기본값 사용

2️ 예시 1: 인사 함수
```python
def greet(name="친구"):
    print(f"안녕하세요, {name}님!")
```
```python
greet("민수")  # 안녕하세요, 민수님!
greet()       # 안녕하세요, 친구님!
```

3️ 예시 2: 덧셈 함수
```python
def add(a, b=10):
    return a + b
```
```python
print(add(5, 3))  # 8
print(add(5))     # 15 (b는 기본값 10 사용)
```

4️ 주의 사항
1) 기본값 있는 매개변수는 항상 뒤쪽에
   ```python
   def func(a, b=10):  # ✅
       ...
   def func(a=10, b):  # ❌ 오류
       ...
   ```
2) 가변 객체를 기본값으로 사용 주의
   * 리스트, 딕셔너리 같은 객체를 기본값으로 쓰면 공유 문제 발생
   ```python
   def add_item(item, lst=[]):  # ❌ 위험
       lst.append(item)
       return lst
   print(add_item(1))  # [1]
   print(add_item(2))  # [1, 2] (원치 않는 공유)
   ```
   * 안전한 방법
   ```python
   def add_item(item, lst=None):
       if lst is None:
           lst = []
       lst.append(item)
       return lst
   print(add_item(1))  # [1]
   print(add_item(2))  # [2] ✅
   ```152

파이썬에서 가변 인자(Variable-length Arguments)는 함수가 몇 개의 인자를 받을지 미리 알 수 없을 때 사용하고 두 가지 방식이 있다: `*args`와 `**kwargs`.
1️ *args (위치 인자 가변)
* 여러 개의 위치 인자를 튜플 형태로 받음
* 이름은 `*args`가 관례지만, `*anything` 가능
```python
def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total
```
사용 예:
```python
print(sum_all(1, 2, 3))   # 6
print(sum_all(5, 10, 15)) # 30
```

2️ **kwargs (키워드 인자 가변)
* 여러 개의 키워드 인자를 딕셔너리 형태로 받음
* 이름은 `**kwargs`가 관례
```python
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
```
사용 예:
```python
print_info(name="민수", age=25)
# name: 민수
# age: 25
```

3️ *args와 **kwargs 동시에 사용
```python
def func(a, b=0, *args, **kwargs):
    print("a:", a)
    print("b:", b)
    print("args:", args)
    print("kwargs:", kwargs)
```
```python
func(1, 2, 3, 4, x=5, y=6)
# a: 1
# b: 2
# args: (3, 4)
# kwargs: {'x': 5, 'y': 6}
```
> 순서 규칙: 일반 매개변수 → 기본값 매개변수 → *args → **kwargs

4️ 활용 팁
* `*args`는 위치 인자 여러 개를 한 번에 처리할 때
* `**kwargs`는 옵션 형태의 여러 키워드 인자를 받을 때
* 기본값 매개변수와 함께 쓰면 유연한 함수 설계 가능 155

파이썬에서 전역변수(Global Variable)와 지역변수(Local Variable)는 변수의 범위(scope)와 유효 범위(lifetime)에 따라 달라진다. 
1️ 지역 변수 (Local Variable)
* 함수 내부에서 선언된 변수
* 함수 안에서만 사용 가능
* 함수 호출이 끝나면 메모리에서 사라짐
```python
def my_func():
    x = 10  # 지역 변수
    print(x)
my_func()  # 10
# print(x)  # ❌ 오류, x는 함수 밖에서 존재하지 않음
```
2️ 전역 변수 (Global Variable)
* 모든 함수 밖에서 선언된 변수
* 프로그램 전체에서 접근 가능
```python
y = 20  # 전역 변수
def my_func():
    print(y)  # 전역 변수 접근 가능
my_func()  # 20
print(y)   # 20
```
3️ 전역 변수 수정하기
* 함수 안에서 전역 변수를 수정하려면 `global` 키워드 필요
```python
counter = 0  # 전역 변수
def increase():
    global counter  # 전역 변수 사용
    counter += 1
increase()
print(counter)  # 1
```
* 주의: 가능한 전역 변수를 수정하는 대신, 함수 반환값으로 처리하는 것이 안전
```python
def increase(n):
    return n + 1
counter = 0
counter = increase(counter)
print(counter)  # 1
```

4️ 범위 정리 (Scope)
| 변수 종류        | 선언 위치     | 접근 가능 범위  |
| 지역 변수        | 함수 내부     | 해당 함수 내부만 |
| 전역 변수        | 함수 외부     | 프로그램 전체   |
| nonlocal 변수  | 중첩 함수 내부  | 바로 바깥 함수  |

💡 팁:
* 지역 변수를 우선적으로 사용하며, 필요할 때만 전역 변수 사용
* 전역 변수는 프로그램 전체에 영향을 주므로 남용 금지 159

파이썬에서 입출력(Input/Output, I/O)은 프로그램과 사용자 또는 외부 데이터 간의 소통을 의미한다.
1️ 표준 입력 (Input)
* 사용자로부터 데이터를 받을 때 사용
* `input()` 함수 사용
* 기본적으로 문자열(String) 형태로 반환
```python
name = input("이름을 입력하세요: ")
print(f"안녕하세요, {name}님!")
```
* 숫자 입력 시에는 형 변환 필요
```python
age = int(input("나이를 입력하세요: "))
print(f"내년에는 {age + 1}살이 되겠군요!")
```

2️ 표준 출력 (Output)
* 화면에 데이터를 출력할 때 사용
* `print()` 함수 사용
```python
print("Hello, Python!")  # 문자열 출력
print(1, 2, 3)           # 여러 값 출력
print("a", "b", sep="-") # 구분자 지정
print("Hello", end="!")  # 줄바꿈 없이 출력
```

3️ 파일 입출력 (File I/O)
### 파일 열기
```python
# 읽기 모드
f = open("example.txt", "r")  
# 쓰기 모드 (파일이 없으면 생성)
f = open("example.txt", "w")  
# 추가 모드
f = open("example.txt", "a")  
# 읽기+쓰기 모드
f = open("example.txt", "r+")
```

### 파일 읽기
```python
f = open("example.txt", "r")
content = f.read()       # 전체 읽기
print(content)
f.close()
```
```python
# 한 줄씩 읽기
with open("example.txt", "r") as f:
    for line in f:
        print(line.strip())  # 줄바꿈 제거
```

### 파일 쓰기
```python
with open("example.txt", "w") as f:
    f.write("안녕하세요!\n")
    f.write("파이썬 입출력 예제입니다.")
```
* `with` 구문을 사용하면 파일 자동으로 닫힘 → `f.close()` 필요 없음

4️ 입출력 요약
| 사용자 입력     | `input()`                              | 문자열 반환, 필요 시 형 변환     |
| 화면 출력      | `print()`                              | 여러 값, 구분자, 줄바꿈 제어 가능  |
| 파일 열기      | `open(filename, mode)`                 | r: 읽기, w: 쓰기, a: 추가 등 |
| 파일 읽기      | `read()`, `readline()`, `readlines()`  | 전체, 한 줄, 모든 줄 리스트 반환  |
| 파일 쓰기      | `write()`, `writelines()`              | 파일에 문자열 작성            |
| 안전한 파일 처리  | `with open(...) as f`                  | 자동으로 파일 닫기            | 166

파이썬에서 한글이 포함된 파일 입출력은 기본적으로 인코딩(encoding) 설정이 중요하다. 윈도우에서는 `'cp949'`나 `'utf-8-sig'`, 대부분의 환경에서는 `'utf-8'`을 사용하면 안전하다.
1️ 한글 파일 쓰기
```python
# UTF-8로 파일 쓰기
with open("example.txt", "w", encoding="utf-8") as f:
    f.write("안녕하세요!\n")
    f.write("파이썬 한글 파일 입출력 예제입니다.\n")
```
* `encoding="utf-8"` 지정 필수
* `w` 모드는 기존 파일 덮어쓰기
* `a` 모드는 기존 내용 뒤에 추가

2️ 한글 파일 읽기
```python
with open("example.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)
```
* `read()`: 전체 읽기
* `readlines()`: 줄 단위로 리스트 반환
* `readline()`: 한 줄씩 읽기
```python
with open("example.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())  # 줄바꿈 제거
```

3️ 한글 CSV 파일 입출력 예제
```python
import csv
# 쓰기
with open("example.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["이름", "나이", "도시"])
    writer.writerow(["민수", 25, "서울"])
    writer.writerow(["지은", 30, "부산"])

# 읽기
with open("example.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)
```

4️ 주의 사항
1) 한글 파일 읽기/쓰기 시 encoding 지정 필수
2) 윈도우 Excel에서 열 파일은 `'utf-8-sig'`로 저장하면 깨짐 방지
```python
with open("example.csv", "w", newline="", encoding="utf-8-sig") as f:
    ...
```
3) `with` 구문 사용 → 파일 자동 닫기, 안전한 입출력

💡 요약:
| 구분        | 모드   | 인코딩          | 설명               |
| 쓰기        | `w`  | `utf-8`      | 기존 내용 덮어쓰기       |
| 추가        | `a`  | `utf-8`      | 기존 내용 뒤에 추가      |
| 읽기        | `r`  | `utf-8`      | 전체 내용 또는 줄 단위 읽기 |
| Excel 호환  | `w`  | `utf-8-sig`  | Excel에서 한글 깨짐 방지 | 177

파이썬 pickle(피클) 모듈은 파이썬 객체를 바이너리 형태로 직렬화(serialize) 하거나 그 반대로 역직렬화(deserialize) 할 때 사용하는 모듈이다. 즉, 파이썬 객체를 그대로 파일로 저장하거나 다시 불러올 수 있는 기능을 제공한다.
1. pickle 기본 쓰기(저장)
```python
import pickle
data = {"name": "민수", "age": 25, "hobbies": ["게임", "독서"]}
# wb = write binary
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)
```
* `dump(객체, 파일객체)` → 객체를 파일에 저장
* 반드시 바이너리 모드(`"wb"`) 사용해야 함

2. pickle 기본 읽기(불러오기)
```python
import pickle
# rb = read binary
with open("data.pkl", "rb") as f:
    loaded_data = pickle.load(f)
print(loaded_data)
```

3. 문자열 형태로 직렬화/역직렬화; 파일로 저장하지 않고 메모리에서 직접 처리할 수도 있음.
```python
serialized = pickle.dumps(data)   # 객체 → 바이트 문자열
restored = pickle.loads(serialized)  # 바이트 → 객체
```

4. 여러 객체를 순서대로 저장하기 
```python
with open("multi.pkl", "wb") as f:
    pickle.dump("Hello", f)
    pickle.dump([1, 2, 3], f)
    pickle.dump({"a": 1}, f)
```
읽기:
```python
with open("multi.pkl", "rb") as f:
    print(pickle.load(f))
    print(pickle.load(f))
    print(pickle.load(f))
```

5. pickle 사용 시 주의사항
⚠️ 1. 보안 위험; pickle 파일은 임의의 파이썬 코드를 실행할 수 있음→ 신뢰할 수 없는 pickle 파일 절대 불러오지 말 것
⚠️ 2. 파이썬 전용; 다른 언어와 호환 안 되며 파이썬 버전에 따라 구조가 달라질 수 있음
⚠️ 3. 인코딩 필요 없음; pickle은 바이너리 형태이므로 `encoding` 지정 안 해도 됨

6. 언제 pickle을 쓸까?
| 상황                                 | pickle  | JSON |
| 파이썬 객체(클래스, 튜플, 딕트, 리스트 등) 그대로 저장  | ✅       | ❌    |
| 다른 언어와 주고받기                        | ❌       | ✅    |
| 사람이 읽을 수 있는 형식                     | ❌       | ✅    |
| 속도, 편의성                            | 빠름      | 보통   | 182

`with`문은 컨텍스트 매니저(context manager)를 사용해 리소스(파일, DB 연결 등)를 안전하게 열고 자동으로 정리(해제)하도록 도와주는 파이썬 문법이다.
1. 기본 예시: 파일 열기
```python
with open("data.txt", "r") as f:
    content = f.read()
print(content)
```
✔ 어떻게 동작할까?
* `open()`이 컨텍스트 매니저를 반환
* 블록이 끝나면 자동으로 파일이 닫힘(= f.close())

2. 예외가 발생해도 안전
```python
with open("data.txt") as f:
    x = 1 / 0  # 오류 발생
오류가 발생해도 파일은 자동으로 닫힘.

3. 여러 개 리소스를 한 번에
```python
with open("a.txt") as a, open("b.txt") as b:
    print(a.read(), b.read())
```

4. 커스텀 컨텍스트 매니저 만들기
(1) 클래스 방식
```python
class MyContext:
    def __enter__(self):
        print("ENTER")
        return "value"
    def __exit__(self, exc_type, exc_value, traceback):
        print("EXIT")
with MyContext() as v:
    print(v)
```

(2) 데코레이터 방식 (`contextlib.contextmanager`)
```python
from contextlib import contextmanager
@contextmanager
def my_context():
    print("ENTER")
    yield "value"
    print("EXIT")
with my_context() as v:
    print(v)
```

5. 왜 사용할까?
| 문제                     | with문 사용 시 |
| 파일/네트워크 자원 해제가 누락될 위험  | 자동 close   |
| 예외 발생 시 cleanup 어려움    | 자동 처리      |
| 코드가 길어짐                | 가독성 좋아짐    | 185

파이썬에서 클래스(class)는 객체(Object)를 만들어 내는 설계도다. 데이터(속성)와 기능(메서드)을 하나의 구조로 묶어 사용할 수 있게 해 준다.
1. 클래스 기본 구조
```python
class MyClass:
    # 생성자: 객체가 만들어질 때 자동 실행되며 주체의 색이나 나이 등 상태와 특징
    def __init__(self, value):
        self.value = value   # 속성
    # 메서드; 주체의 기능
    def show(self):
        print(self.value)
```
✔ 사용 예
```python
obj = MyClass(10)  # 객체(instance) 생성
obj.show()         # 메서드 호출
```
2. 속성(Attributes)과 메서드(Methods)
### 속성
```python
self.name = "Tom"
self.age = 20
```
### 메서드
```python
def greet(self):
    print(f"Hello, I'm {self.name}")
```
3. 클래스 예시: 간단한 사람(Person)
```python
class Person:
    def __init__(self, name, age): #나이 등 주체의 속성
        self.name = name
        self.age = age
    def introduce(self): #인쇄 등 주체의 기능
        print(f"{self.name} ({self.age}) 입니다.")
p = Person("홍길동", 20) # 주체의 이름과 나이라는 속성을 소개하는 기능으로 여러 주체에 대해 동일하게 적용될 수있는 설계도가 만든 객체들일 수도 
p.introduce()
```
4. 상속(Inheritance)
```python
class Animal:
    def sound(self):
        print("소리!")
class Dog(Animal):
    def bark(self):
        print("멍멍!")
d = Dog()
d.sound()  # 부모 클래스 메서드 사용
d.bark()
```
5. 클래스 변수 vs 인스턴스 변수
```python
class Counter:
    count = 0  # 클래스 변수(모든 인스턴스가 공유)
    def __init__(self):
        self.value = 0  # 인스턴스 변수(개별 객체만 가짐)
```
6. 정적 메서드 / 클래스 메서드
```python
class Math:
    @staticmethod
    def add(a, b):
        return a + b
    @classmethod
    def description(cls):
        return "This is Math class"
```
7. 캡슐화처럼 보이는 기법(파이썬스러운 방식)
```python
class Test:
    def __init__(self):
        self._protected = 1     # 관례상 내부용
        self.__private = 2      # name-mangling 적용됨
```193

인스턴스 변수(instance variable)는 클래스에서 생성된 각 객체(인스턴스)가 개별적으로 가지는 변수를 말한다. 즉, 같은 클래스로 만들어진 객체라 하더라도 인스턴스 변수의 값은 객체마다 다를 수 있다.
🔎 쉽게 설명하면
* 클래스 = 설계도
* 객체(인스턴스) = 설계도로 찍어낸 제품
* 인스턴스 변수 = 각 제품이 가지고 있는 고유한 속성

📌 특징
1. 객체가 생성될 때 함께 만들어짐
2. 각 객체마다 독립적인 값을 가짐
3. 일반적으로 `self`(Python), `this`(Java/C++) 등을 통해 접근

🐍 Python 예시
```python
class Person:
    def __init__(self, name, age):
        self.name = name    # 인스턴스 변수
        self.age = age      # 인스턴스 변수
p1 = Person("Alice", 25)
p2 = Person("Bob", 30)
print(p1.name, p1.age)  # Alice 25
print(p2.name, p2.age)  # Bob 30
```
→ `p1`과 `p2`는 서로 다른 값을 가진 인스턴스 변수를 가지고 있다.

☕ Java 예시
```java
class Person {
    String name;   // 인스턴스 변수
    int age;       // 인스턴스 변수
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
Person p1 = new Person("Alice", 25);
Person p2 = new Person("Bob", 30);
```

🔧 클래스 변수(static 변수)와의 차이
| 구분     | 인스턴스 변수   | 클래스 변수(Static) |
| 소속     | 객체(인스턴스)  | 클래스 자체         |
| 메모리    | 객체마다 독립적  | 모든 객체가 공유      |
| 생성 시점  | 객체 생성 시   | 프로그램 시작 시      |197

파이썬의 상속(Inheritance) 은 이미 존재하는 클래스를 기반으로 새로운 클래스를 만드는 기능이다. 부모 클래스(상위 클래스)의 속성과 메서드를 자식 클래스(하위 클래스)가 물려받아 재사용하거나 확장할 수 있다.
1. 기본 상속 문법
```python
class Parent:
    def speak(self):
        print("부모가 말합니다.")
class Child(Parent):
    pass
c = Child()
c.speak()   # 부모가 말합니다.
```
`Child(Parent)` 처럼 괄호 안에 부모 클래스를 넣으면 상속이 됩니다.

2. 메서드 오버라이딩(재정의); 자식 클래스에서 부모 클래스의 메서드를 다시 정의할 수 있다.
```python
class Parent:
    def speak(self):
        print("부모 말")
class Child(Parent):
    def speak(self):
        print("자식 말")
c = Child()
c.speak()   # 자식 말
```

3. super()로 부모 메서드 호출; 자식 클래스에서 오버라이딩하면서 부모 기능도 사용하고 싶을 때 `super()` 를 사용.
```python
class Parent:
    def speak(self):
        print("부모 말")
class Child(Parent):
    def speak(self):
        super().speak()
        print("자식 말")
c = Child()
c.speak()
```
출력:
```
부모 말
자식 말
```

4. 생성자 상속; 부모 클래스의 `__init__()` 을 사용할 때도 `super()` 를 활용.
```python
class Parent:
    def __init__(self, name):
        self.name = name
class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
c = Child("철수", 10)
print(c.name, c.age)
```

5. 다중 상속(Multiple Inheritance); 파이썬은 여러 클래스를 한 번에 상속할 수 있다.
```python
class A:
    def a(self):
        print("A")
class B:
    def b(self):
        print("B")
class C(A, B):
    pass
c = C()
c.a()
c.b()
``` 207

파이썬의 예외처리(Exception Handling) 는 프로그램 실행 중 발생하는 오류 상황을 안전하게 처리하고 프로그램이 비정상 종료되지 않도록 하기 위한 기능이다.
# 기본 구조: `try - except`
```python
try:
    # 문제가 발생할 가능성이 있는 코드
except 예외타입:
    # 예외 발생 시 실행되는 코드
```
예시:
```python
try:
    x = 10 / 0
except ZeroDivisixxonError:
    print("0으로 나눌 수 없습니다!")
```

# 여러 예외 처리
```python
try:
    value = int("abc")
except ValueError:
    print("정수로 변환할 수 없습니다")
except ZeroDivisixxonError:
    print("0으로 나눌 수 없습니다")
```

# 하나의 except에 여러 예외 처리
```python
try:
    x = int("abc")
except (ValueError, TypeError):
    print("입력 오류 발생")
```

# 예외 객체 가져오기
```python
try:
    x = int("abc")
except ValueError as e:
    print("오류 내용:", e)
```

# `else`와 `finally`
✔ `else`: 예외가 발생하지 않았을 때 실행
```python
try:
    x = int("100")
except ValueError:
    print("변환 실패")
else:
    print("정상 실행:", x)
```

✔ `finally`: 예외 발생 여부와 상관없이 항상 실행(파일 닫기, DB 연결해제 등에서 사용)
```python
try:
    f = open("test.txt", "r")
except FileNotFoundError:
    print("파일이 없습니다")
finally:
    print("작업 종료")
```

# 직접 예외 발생시키기: `raise`
```python
def set_age(age):
    if age < 0:
        raise ValueError("나이는 음수가 될 수 없습니다.")
    return age
```

# 사용자 정의 예외
```python
class MyError(Exception):
    pass
try:
    raise MyError("내가 만든 예외")
except MyError as e:
    print(e)
``` 241

파이썬의 스페셜 메소드(Special Method) 는 클래스 내부에서 특정 이름으로 정의하면 파이썬이 특별한 상황에서 자동으로 호출해주는 “매직 메소드(magic method)”다. 이름은 항상 앞뒤로 `__`(언더스코어 두 개) 가 붙는다. (예: `__init__`, `__str__`, `__len__`, `__add__` 등)
# 스페셜 메소드란? 파이썬 객체가 연산자, 내장 함수, 문법적 동작과 상호작용하도록 만드는 메소드로 직접 호출하는 경우는 거의 없고 파이썬이 필요할 때 자동으로 호출
# 자주 쓰는 스페셜 메소드 정리
## 1️ 객체 생성 관련
| `__init__(self, ...)`  | 생성자             |
| `__new__(cls, ...)`    | 객체 생성 단계(잘 안 씀) |
| `__del__(self)`        | 소멸자(지양)         |
```python
class Person:
    def __init__(self, name):
        self.name = name
```
## 2️ 출력/표현 관련
| `__str__`   | `print(obj)` 또는 `str(obj)`    |
| `__repr__`  | 개발자용 표현, `repr(obj)` 또는 대화형 쉘 |
```python
class Person:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return f"Person({self.name})"
    def __repr__(self):
        return f"Person(name='{self.name}')"
```
## 3️ 산술 연산자 오버로딩
| `a + b`   | `__add__`      |
| `a - b`   | `__sub__`      |
| `a * b`   | `__mul__`      |
| `a / b`   | `__truediv__`  |
| `a // b`  | `__floordiv__` |
| `a % b`   | `__mod__`      |
```python
class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
```
## 4️ 비교 연산자
| `<`   | `__lt__` |
| `<=`  | `__le__` |
| `==`  | `__eq__` |
| `!=`  | `__ne__` |
| `>`   | `__gt__` |
| `>=`  | `__ge__` |
## 5️ 컨테이너/시퀀스 관련
| `len(obj)`          | `__len__`              |
| `obj[key]`          | `__getitem__`          |
| `obj[key] = value`  | `__setitem__`          |
| `del obj[key]`      | `__delitem__`          |
| `in obj`            | `__contains__`         |
| 반복(`for x in obj`)  | `__iter__`, `__next__` |
```python
class MyList:
    def __init__(self, data):
        self.data = data
    def __getitem__(self, idx):
        return self.data[idx]
    def __len__(self):
        return len(self.data)
```
## 6️ 호출 가능한 객체
| `obj()`  | `__call__` |
```python
class Adder:
    def __call__(self, a, b):
        return a + b
add = Adder()
print(add(3, 5))  # 8
```
## 7️ 컨텍스트 매니저 (`with`)
| `with obj:`  | `__enter__`, `__exit__` |
```python
class FileManager:
    def __enter__(self):
        print("열기")
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("닫기")
with FileManager():
    print("작업")
```
# ✨ 스페셜 메소드의 핵심 요약
* 객체가 파이썬 문법과 자연스럽게 상호작용하도록 만드는 메소드
* 연산자 오버로딩, 출력 방식 정의, 반복·길이 등 통합된 인터페이스 구현 가능
* 클래스의 품질과 파이썬다운 구현에 매우 중요! 251

파이썬의 finally 문(정확히는 `finally` 블록)은 예외 처리 구조에서 예외 발생 여부와 상관없이 항상 실행되는 부분을 의미한다. 일반적으로 try–except–finally 형태로 사용한다.
# `finally`의 기본 형태
```python
try:
    # 예외가 발생할 가능성이 있는 코드
except SomeError:
    # 예외 발생 시 처리
finally:
    # 항상 실행되는 코드
```
✔ `try` 내부에서 예외가 발생하든/안 하든
✔ `except`가 실행되든
✔ `return`, `break`, `continue`가 있어도(대부분의 경우)
➡️ finally는 무조건 실행.

# 사용 목적; `finally`는 보통 다음 작업을 확실히 실행하고 싶을 때:
* 파일 닫기
* 데이터베이스 연결 종료
* 네트워크 소켓 정리
* 임시 리소스 해제 등
즉, 정리(clean-up) 작업을 보장하는 용도.

# 예시 1: 파일 닫기
```python
try:
    f = open("data.txt", "r")
    content = f.read()
except FileNotFoundError:
    print("파일이 없습니다.")
finally:
    print("파일 핸들 닫는 중...")
    f.close()
```

# 예시 2: 예외가 없어도 실행됨
```python
try:
    print("정상 코드 실행")
finally:
    print("무조건 실행됨!")
```

# 예시 3: return이 있어도 실행됨
```python
def test():
    try:
        return "try에서 반환"
    finally:
        print("finally 실행!")
print(test())
```
출력:
```
finally 실행!
try에서 반환
```

# 주의: `finally` 안에서 `return`을 사용하면?
`finally` 내부의 return이 바깥 return을 덮어버림→ 가급적 `finally`에서는 `return` 사용 금지
```python
def test():
    try:
        return "try"
    finally:
        return "finally"
print(test())  # 결과는 "finally"
```

# 정리
* `finally`는 항상 실행되는 블록
* 예외가 발생해도/안 해도 무조건 실행
* 주로 리소스 정리용
* `return`은 되도록 사용하지 말기 253

파이썬의 모듈(Module) 과 패키지(Package) 는 코드의 재사용성과 구조화에 매우 중요한 개념이다.
# 1. 모듈(Module); 하나의 `.py` 파일. 즉, 파이썬 코드가 저장된 파일 한 개가 곧 모듈.
예:
```
calculator.py
```
```python
# calculator.py
def add(a, b):
    return a + b
```
이제 다른 파일에서 이렇게 사용 가능:
```python
import calculator
print(calculator.add(3, 5))
```

# 2. 패키지(Package); 여러 모듈을 묶어놓은 디렉토리(폴더). 폴더 안에 보통 `__init__.py` 파일이 들어있다.
예:
```
mypkg/
    __init__.py
    math_utils.py
    string_utils.py
```
사용 예:
```python
import mypkg.math_utils
print(mypkg.math_utils.square(4))
```

# 3. 모듈 불러오는 방법
① 모듈 전체 import
```python
import calculator
calculator.add(1, 2)
```
② 특정 함수 import
```python
from calculator import add
add(1, 2)
```
③ 별명(alias) 사용
```python
import calculator as calc
calc.add(1, 2)
```
④ 패키지 내부 모듈 import
```python
from mypkg import math_utils
```

# 4. 패키지 내부 구조 만들기
예: 패키지를 직접 만들 경우
```
mypkg/
 ├─ __init__.py
 ├─ utils.py
 └─ calc/
      ├─ __init__.py
      └─ add.py
```
사용 예:
```python
from mypkg.utils import say_hello
from mypkg.calc.add import add
```

# 5. `__init__.py`의 역할
* “이 폴더는 패키지다”라고 알려주는 파일
* 패키지 초기 실행 코드 포함 가능
* 서브 모듈을 쉽게 import하도록 설정 가능
예:
```python
# mypkg/__init__.py
from .utils import say_hello
```
이제 아래처럼 사용 가능:
```python
import mypkg
mypkg.say_hello()
```

# 6. 모듈/패키지 검색 경로 (sys.path); 파이썬은 모듈을 찾을 때 다음 경로들을 탐색:
```python
import sys
print(sys.path)
```
이 목록에 있는 폴더에서 모듈을 찾아 import.

# 7. 모듈과 패키지 차이 요약
| 구분      | 모듈(Module)       | 패키지(Package)            |
| 정의      | .py 파일           | 여러 모듈을 담은 폴더            |
| 예       | `math.py`        | `mypkg/`                |
| import  | `import module`  | `import package.module` | 261

파이썬에서 필요한 패키지를 찾는 방법은 여러 가지가 있다. 상황에 따라 패키지 검색, 설치, 정보 확인 방법이 다르다.
1️ PyPI(Python Package Index)에서 검색; Python 공식 패키지 저장소.
* 사이트: [https://pypi.org](https://pypi.org)
* 예: `pandas`, `numpy`, `matplotlib` 등을 검색하면 설치 방법과 문서 확인 가능.

2️ pip 명령어로 검색; 터미널에서 `pip search`를 사용할 수 있었으나, 최신 pip 버전에서는 비활성화되어 대신 PyPI 사이트를 이용하는 것이 좋다.
설치 후 버전을 확인하거나 설치할 패키지를 검색할 때:
```bash
# 설치
pip install pandas
# 설치된 패키지 목록 확인
pip list
# 패키지 정보 확인
pip show pandas
```

3️ Anaconda Navigator/conda 검색; Anaconda 사용자는 GUI나 conda 명령어로 검색 가능:
```bash
# 패키지 검색
conda search numpy
# 설치
conda install numpy
```

4️ Google 검색; 원하는 기능이나 라이브러리 이름으로 검색:
```
python package for data visualization
```
→ 추천 라이브러리 예: Matplotlib, Seaborn, Plotly 277

https://cafe.naver.com/gilbutitbook
https://github.com/gilbutITbook/080357
https://www.youtube.com/@nadocoding
https://www.yes24.com/product/goods/117373102

1장 Hello, 파이썬! 1.1 개발 환경 설정하기 1.2 첫 번째 파이썬 프로그램 작성하기
2장 자료형과 변수 2.1 숫자 자료형 2.2 문자열 자료형 2.3 불 자료형 2.4 변수 2.5 주석 2.6 실습 문제: 역 이름 출력하기
3장 연산자 3.1 연산자의 종류 3.2 연산자의 우선순위 3.3 변수로 연산하기 3.4 함수로 연산하기 3.5 실습 문제: 스터디 날짜 정하기
4장 문자열 다루기 4.1 문자열이란 4.2 원하는 만큼 문자열 자르기: 슬라이싱 4.3 함수로 문자열 처리하기 4.4 문자열 포매팅 4.5 탈출 문자 4.6 실습 문제: 비밀번호 만들기
5장 자료구조 5.1 리스트 5.2 딕셔너리 5.3 튜플 5.4 세트 5.5 자료구조 변환하기 5.6 실습 문제: 당첨자 뽑기

6장 제어문 6.1 조건에 따라 분기하기: 조건문 6.2 같은 일 반복하기: 반복문 6.3 실습 문제: 택시 승객 수 구하기
7장 함수 7.1 함수 정의하기 7.2 전달값과 반환값 7.3 함수 호출하기 7.4 변수의 범위: 지역변수와 전역변수 7.5 실습 문제: 표준 체중 구하기
8장 입출력 8.1 표준 입력받기: input() 8.2 표준 출력 시 유용한 기능 8.3 다양한 형식으로 출력하기: format() 8.4 파일 입출력 8.5 데이터를 파일로 저장하기: pickle 모듈 8.6 파일 한 번에 열고 닫기: with 문 8.7 실습 문제: 보고서 파일 만들기
9장 클래스 9.1 게임 소개 9.2 클래스와 객체 생성하기 9.3 클래스 상속하기 9.4 동작 없이 일단 넘어가기: pass 9.5 부모 클래스 호출하기: super() 9.6 게임 완성 9.7 게임 최종 리뷰 9.8 실습 문제: 부동산 프로그램 만들기
10장 예외 처리 10.1 예외 처리하기 10.2 오류 발생시키기 10.3 사용자 정의 예외 처리하기 10.4 오류와 상관없이 무조건 실행하기: finally 10.5 실습 문제: 치킨 주문하기
11장 모듈과 패키지 11.1 모듈 다루기 11.2 패키지 다루기 11.3 모듈 공개 설정하기: __all__ 11.4 모듈 직접 실행하기 11.5 패키지와 모듈 위치 확인하기 11.6 패키지 설치하기 11.7 내장 함수 사용하기 11.8 외장 함수 사용하기 11.9 실습 문제: 나만의 모듈 만들기