2025-01-20T02:26:20

doc/00_intro.md

@@ -1 +1,38 @@
-https://www.tutorialspoint.com/python/python_hello_world.htm
+# Python Programming Language
+
+파이썬은 가독성이 뛰어나고 생산성이 높아 초보자부터 전문가까지 널리 사용되는 고급 프로그래밍 언어입니다. 간결한 문법과 다양한 표준 라이브러리를 제공하여 빠르게 개발하고 유지보수하기 쉽다는 장점이 있습니다.
+
+## 파이썬의 역사
+* 1980년대 후반: 네덜란드의 귀도 반 로섬이 ABC 언어의 단점을 보완하고 새로운 프로그래밍 언어를 구상하기 시작했습니다.
+* 1991년: 파이썬의 첫 번째 버전이 공개되었습니다.
+* 현재: 파이썬은 웹 개발, 데이터 과학, 머신 러닝, 인공지능 등 다양한 분야에서 가장 인기 있는 언어 중 하나로 자리매김했습니다.
+
+## 파이썬의 특징
+* 간결한 문법: 다른 언어에 비해 적은 코드로 복잡한 작업을 수행할 수 있습니다.
+* 높은 가독성: 영어와 유사한 문법으로 코드를 읽고 이해하기 쉽습니다.
+* 동적 타이핑: 변수의 자료형을 미리 선언하지 않아도 됩니다.
+* 객체 지향: 실제 세계의 개념을 프로그램으로 모델링하기 쉽습니다.
+* 확장성: 다양한 라이브러리를 활용하여 기능을 확장할 수 있습니다.
+* 플랫폼 독립성: 운영체제에 상관없이 실행 가능합니다.
+
+## 파이썬 문법의 주요 특징
+* 인덴테이션: 들여쓰기를 통해 코드 블록을 구분합니다.
+* 변수: 변수 선언 시 자료형을 명시할 필요가 없습니다.
+* 데이터형: 숫자, 문자열, 리스트, 튜플, 딕셔너리 등 다양한 데이터형을 지원합니다.
+* 연산자: 산술 연산자, 비교 연산자, 논리 연산자 등을 사용하여 값을 비교하고 계산합니다.
+* 제어문: if, for, while 등의 제어문을 사용하여 프로그램의 흐름을 제어합니다.
+* 함수: 특정 기능을 수행하는 코드 블록을 함수로 정의하여 재사용할 수 있습니다.
+* 클래스: 객체 지향 프로그래밍에서 객체를 정의하는 틀입니다.
+
+## 파이썬의 활용 분야
+* 웹 개발: Django, Flask 등의 프레임워크를 활용하여 웹 애플리케이션 개발
+* 데이터 과학: NumPy, Pandas, Matplotlib 등의 라이브러리를 활용하여 데이터 분석 및 시각화
+* 머신 러닝: Scikit-learn, TensorFlow, Keras 등의 라이브러리를 활용하여 머신 러닝 모델 개발
+* 인공지능: 다양한 라이브러리를 활용하여 인공지능 모델 개발
+* 자동화: 파이썬 스크립트를 활용하여 반복적인 작업 자동화
+* 게임 개발: Pygame 등의 라이브러리를 활용하여 간단한 게임 개발
+
+---
+
+파이썬은 배우기 쉽고 활용도가 높아 프로그래밍 입문자에게 추천되는 언어입니다. 다양한 분야에서 활용되고 있으므로, 파이썬을 배우면 여러분의 개발 역량을 한층 더 높일 수 있을 것입니다.
+

doc/01_install.md

@@ -1,42 +1,69 @@
 # Python
 
+우분투에서 파이썬을 설치하는 가장 일반적인 방법은 apt 패키지 관리 시스템을 이용하는 것입니다.
+
 ```bash
-sudo apt install python2                    # python2를 설치합니다.
 sudo apt install python3                    # python3를 설치합니다.
-sudo apt install python-is-python2          # /usr/bin/python에 대한 링크를 Python 2.x로 지정합니다.
+
 sudo apt install python-is-python3          # /usr/bin/python에 대한 링크를 Python 3.x로 지정합니다.
 ```
 
+sudo 명령어를 사용할 때는 루트 권한이 필요하므로, 관리자 암호를 입력해야 합니다.
+
+파이썬 2를 사용해야 하는 경우 `sudo apt install python2`를 사용하여 설치할 수 있습니다. 하지만 파이썬 2는 더 이상 지원되지 않으므로 가능한 한 파이썬 3를 사용하는 것이 좋습니다.
+
+설치가 완료되었으면 다음 명령어를 입력하여 설치된 파이썬 버전을 확인합니다.
+
 ```bash
 python2 --version
 python3 --version
 ```
 
 ## PIP
-Package Installer for Python
+**pip**(Package Installer for Python)는 파이썬 패키지 관리 시스템으로, 파이썬 패키지(라이브러리)를 설치, 업데이트, 제거하는 데 사용되는 명령줄 도구입니다. 파이썬 개발에 있어서 필수적인 도구라고 할 수 있습니다.
+
+파이썬 패키지 관리자인 pip를 설치하려면 다음 명령어를 입력합니다.
 
 ```bash
 sudo apt install python3-pip
 ```
 
 ```bash
-pip install xxx
+pip install 패키지명 # 패키지 설치
-pip search xxx
+pip install 패키지명==버전 # 특정 버전 설치
-pip list
+pip install --upgrade 패키지명 # 패키지 업데이트
-pip show xxx
+pip uninstall 패키지명 # 패키지 제거
-pip uninstall xxx
+pip search 검색어 # 패키지 검색
-
+pip list # 설치된 패키지 목록 보기
-pip freeze > requirements.txt # 의존성 목록을 파일로 저장합니다.
+pip show 패키지명
-pip install -r requirements.txt # 의존성 목록을 설치합니다.
 ```
 
+### requirements.txt 파일 활용
+```python
+pip freeze > requirements.txt # 요구사항 목록을 파일로 저장
+pip install -r requirements.txt # 요구사항 파일 설치
+```
+
+* 가상 환경: 프로젝트마다 독립적인 환경을 만들어 관리하는 것이 좋습니다. virtualenv 또는 venv를 사용하여 가상 환경을 생성하고 활성화한 후 pip 명령을 실행합니다.
+* 권한: sudo 권한 없이 설치하려면 --user 옵션을 사용할 수 있지만, 시스템 전체에 설치하려면 sudo 권한이 필요합니다.
+* 패키지 버전: 특정 버전의 패키지를 설치해야 하는 경우 ==를 사용하여 버전을 명시합니다.
+* 요구사항 파일: 프로젝트에 필요한 패키지 목록을 requirements.txt 파일에 관리하면 다른 환경에서도 쉽게 동일한 환경을 구축할 수 있습니다.
+
 ## VENV
-가상 실행환경
+venv는 Python에 내장된 모듈로, 프로젝트별로 독립적인 파이썬 환경을 구축하는 데 사용됩니다. 즉, 각 프로젝트마다 서로 다른 버전의 Python과 패키지를 사용할 수 있도록 해주는 도구입니다.
+
+* 프로젝트 간의 충돌 방지: 각 프로젝트에서 사용하는 패키지 버전이 다를 경우, 글로벌 환경에서 충돌이 발생할 수 있습니다. venv를 사용하면 이러한 문제를 해결할 수 있습니다.
+* 패키지 관리의 용이성: 프로젝트별로 필요한 패키지만 설치하고 관리할 수 있어 시스템 전체에 영향을 미치지 않고 안전하게 작업할 수 있습니다.
+* 배포의 편리성: 다른 환경에서도 동일한 환경을 쉽게 구축할 수 있습니다.
+
+venv는 Python 3.3 이상에 내장되어 있으며, virtualenv는 별도로 설치해야 하는 도구입니다. venv를 사용하는 것이 일반적입니다.
 
 ```bash
 sudo apt install python3-venv
 ```
 
+### 가상 환경 생성하기
+가상 환경은 보통 프로젝트 디렉토리 안에 생성하는 것이 일반적입니다.
 프로젝트 디렉토리로 이동해서 가상 환경을 생성합니다. 일반적으로 `.venv` 디렉토리를 사용합니다.
 
 ```bash
@@ -44,12 +71,25 @@ cd project-dir
 python -m venv .venv 
 ```
 
-가상 환경을 시작합니다. 프롬프트 앞에 가상환경 이름이 표시됩니다.
+### 가상 환경 활성화하기
+가상 환경을 시작합니다. 활성화가 되면 명령 프롬프트 앞에 가상 환경 이름이 표시됩니다.
 
 ```bash
 source .venv/bin/activate #또는
 . .venv/bin/activate
+```
 
+활성화된 가상 환경 내에서 pip 명령을 사용하여 패키지를 설치합니다.
+
+### 가상 환경 비활성화하기
+
+```bash
 deactivate # 가상 환경을 종료합니다.
 ```
 
+### 가상 환경 삭제하기
+경우에 따라 가상 환경을 삭제하려면, 가상 환경 디렉토리를 삭제합니다.
+
+```bash
+rm -rf .venv
+```

doc/02_helloworld.md

@@ -1,15 +1,39 @@
 # Hello, World!
 
+프로그래밍을 처음 배우는 사람들이 가장 먼저 작성하는 프로그램이 바로 "Hello, World!"입니다. 이 프로그램은 화면에 "Hello, World!"라는 문자열을 출력하는 아주 간단한 기능을 수행합니다. 파이썬에서 이 프로그램을 작성하는 방법은 다음과 같습니다.
+
+```python
+# 이 코드는 "Hello, World!"를 출력합니다.
+print("Hello, World!")
+```
+> 코드에 설명을 추가하고 싶을 때에는 주석을  사용합니다. 파이썬에서는 `#` 기호 뒤에 주석을 작성합니다.
+
+> print() 함수는 파이썬에서 문자열이나 변수의 값을 화면에 출력하는 데 사용되는 함수입니다.
+괄호 안에 출력하고 싶은 내용을 넣으면 됩니다.
+
+> 출력할 문자열은 작은따옴표(') 또는 큰따옴표(")로 묶어서 표현합니다.
+
+> 스크립트 파일의 확장자는 *.py*를 사용하며, 파일 인코딩은 UTF-8을 사용하는 것이 원칙입니다.
+
+> C 계열의 프로그래밍 언어들과는 달리 줄 끝에 세미콜론(;)을 붙이지 않습니다. 다만, 여러 구문들을 한 줄에 붙여서 쓰려는 경우에는 세미콜론을 사용해서 구분해줍니다.
+
+텍스트 편집기를 열고, 파일 확장자를 .py (예: hello.py)로 저장합니다.
+터미널에 명령어 `python hello.py`를 입력하여 파일을 실행합니다.
+코드를 실행하면 콘솔 화면에 "Hello, World!"라는 문자열이 출력됩니다.
+
+
+## 조금 더 긴 Hello, World!
+
 ```python
 #!/usr/bin/env python3
 s = 'Hello, World!'
 print(s)    # print()는 화면에 출력하는 함수입니다.
 ```
 
-- 스크립트 파일의 확장자는 *.py*를 사용하며, 파일 인코딩은 UTF-8을 사용하는 것이 원칙입니다.
+> 변수는 값을 저장하기 위한 공간입니다. 변수에 문자열을 저장하고 출력하는 것도 가능합니다.
-- C 계열의 프로그래밍 언어들과는 달리 줄 끝에 세미콜론(;)을 붙이지 않습니다. 다만, 여러 구문들을 한 줄에 붙여서 쓰려는 경우에는 세미콜론을 사용해서 구분해줍니다.
+
-- C 계열의 프로그래밍 언어들과는 달리 중괄호(`{`)는 사용하지 않으며, 대신 들여쓰기를 사용합니다. 같은 블록은 들여쓴 칸 수가 동일해야 하며, 공백문자와 탭을 섞어서 사용하면 안됩니다.
+> C 계열의 프로그래밍 언어들과는 달리 중괄호(`{`)는 사용하지 않으며, 대신 들여쓰기를 사용합니다. 같은 블록은 들여쓴 칸 수가 동일해야 하며, 공백문자와 탭을 섞어서 사용하면 안됩니다.
-- 주석은 `#`로 시작합니다.
+
 
 ## 메인 함수를 사용한 Hello, World!
 

doc/03_00_data_types.md

@@ -0,0 +1,95 @@
+# 변수와 자료형
+
+**변수**는 우리가 프로그램에서 사용하는 데이터를 저장하기 위한 이름표와 같은 역할을 합니다. 마치 서랍에 물건을 넣고 서랍에 이름을 붙여 쉽게 찾는 것처럼, 변수에 값을 저장해두면 언제든지 불러와서 사용할 수 있습니다.
+
+## 변수의 선언 및 할당
+파이썬에서는 변수를 선언할 때 특별한 키워드를 사용할 필요가 없습니다. 단순히 변수 이름을 지정하고, 등호(=)를 사용하여 값을 할당하면 됩니다. 즉, 파이썬에서 변수는 할당과 함께 선언됩니다.
+
+```python
+# 숫자 할당하기
+age = 25
+height = 1.75
+
+# 문자열 할당하기
+name = "홍길동"
+greeting = "안녕하세요!"
+
+# 할당없이 선언만 하려면 None을 사용합니다. None은 다른 프로그래밍 언어의 null에 해당합니다.
+var = None 
+
+x, y, z = 100, 200, 300 # x=100, y=200, z=300
+i = j = k = 10 # i=10, j=10, k=10
+```
+
+## 변수 이름 규칙
+* 문자, 숫자, 언더바(_)만 사용 가능: 숫자로 시작할 수 없으며, 예약어는 사용할 수 없습니다.
+* 대소문자를 구분: age와 Age는 다른 변수입니다.
+* 띄어쓰기 불가: 변수 이름에 띄어쓰기를 사용하려면 언더바(_)를 사용합니다.
+
+## 파이썬의 주요 자료형
+
+> * int, float, complex
+> * str
+> * list, tuple, range
+> * bytes, bytearray, memoryview
+> * dict
+> * set, frozenset
+> * bool
+> * None
+
+파이썬에서 사용할 수 있는 주요 자료형은 다음과 같습니다.
+
+* 정수 (int): 정수 값을 저장합니다. (예: 10, -5, 0)
+* 실수 (float): 소수점이 포함된 숫자를 저장합니다. (예: 3.14, -0.5)
+* 문자열 (str): 문자들의 나열을 저장합니다. (예: "Hello", 'Python')
+* 불리언 (bool): 참(True) 또는 거짓(False) 값을 저장합니다.
+* 리스트 (list): 여러 개의 값을 순서대로 저장하는 자료형입니다. (예: [1, 2, 3], ["apple", "banana"])
+* 튜플 (tuple): 리스트와 유사하지만, 한번 생성된 후에는 값을 변경할 수 없습니다.
+* 딕셔너리 (dict): 키(key)와 값(value)의 쌍으로 이루어진 자료형입니다. (예: {"name": "홍길동", "age": 25})
+
+
+## 변수의 자료형 확인
+
+변수의 자료형을 확인하려면 `type()` 함수를 사용합니다.
+```python
+x = 10
+print(type(x))  # 출력: <class 'int'>
+```
+
+할당된 변수의 메모리 상 번지를 확인하려면, `id()`를 사용합니다.
+```python
+a = 123
+print(id(a))
+```
+
+## 변수의 형변환
+
+자료형을 함수명으로 사용하면 형변환을 할 수 있습니다.
+
+```python
+int(3.3) # 3
+int('100') # 100
+float(3) # 3.0
+```
+
+그 외에 `chr()`, `unichr()`, `hex()`등의 형변환 함수도 있습니다.
+
+## 변수 삭제
+할당된 변수를 제거하려면 `del`을 사용합니다.
+
+```python
+x = 100
+del x
+```
+
+## 상수
+파이썬에는 상수가 없습니다. 관례적으로 대문자 이름을 사용합니다.
+
+## 스왑
+
+```python
+x, y = 10, 20
+x, y = y, z
+```
+
+## 변수의 범위

doc/03_01_number.md

@@ -0,0 +1,66 @@
+# 숫자 자료형
+파이썬에서 숫자는 수학 연산이나 데이터 분석 등 다양한 작업에 필수적으로 사용됩니다. 파이썬은 숫자를 표현하는 다양한 자료형을 제공하며, 각 자료형은 특징과 용도가 다릅니다.
+
+- int :
+
+  정수형. 소수점이 없는 정수를 나타냅니다. (예; 10, -5, 0)
+  
+- float :
+
+  부동소수형. 소수점이 있는 실수를 나타냅니다. (예; 3.14, -0.5, 2.71828)
+  
+- complex : 
+
+  복소수형. 실수 부분과 허수 부분으로 구성된 복소수를 나타냅니다. 허수부 뒤에 j를 붙입니다(예; `3+2j`, `-1-5j`).
+  
+
+```python
+a = 100
+b = 3.14
+c = 0o34
+d = 0xff
+e = 1.28e-10
+```
+
+## 다양한 진법 표현
+0b 또는 0B로 시작하는 숫자는 2진수, 0o 또는 0O로 시작하는 숫자는 8진수, 0x 또는 0X로 시작하는 숫자는 16진수를 의미합니다. 특정한 상황에서 편리하게 사용됩니다.
+
+## 숫자 자료형의 특징
+* 파이썬은 동적 타이핑 언어이므로 변수의 자료형을 명시적으로 선언할 필요가 없습니다.
+* 숫자 자료형은 필요에 따라 자동으로 변환됩니다. (예: 정수와 실수의 연산 결과는 실수가 됩니다.)
+* 파이썬은 매우 큰 정수도 정확하게 처리할 수 있습니다.
+
+## 명시적 형 변환
+
+* `int()` 함수: 다른 자료형을 정수형으로 변환합니다.
+* `float()` 함수: 다른 자료형을 실수형으로 변환합니다.
+* `complex()` 함수: 다른 자료형을 복소수형으로 변환합니다.
+
+```python
+a = 3.14
+b = int(a)  # b는 3이 됩니다.
+c = complex(a)  # c는 3.14+0j가 됩니다.
+```
+
+## 숫자의 연산
+파이썬에서는 숫자 자료형에 대해 다양한 연산자를 사용할 수 있습니다.
+
+* 사칙연산: +, -, *, /, // (몫), % (나머지)
+* 지수: **
+* 비교 연산: ==, !=, >, <, >=, <=
+
+```python
+print(1 + 1) # 2
+print(1 - 2) # -1
+print(3 * 7) # 21
+print(4 / 2) # 2.0
+print(4 // 2) # 2
+print(4 % 3) # 1
+print(2 ** 4) # 16
+```
+
+> Python3 에서는 다른 프로그래밍 언어와는 달리, 정수 끼리의 나눗셈 결과가 실수(float)로 반환됩니다. 나눗셈의 결과를 정수로 받으려면 버림 나눗셈 연산자(`//`)를 사용해야 합니다.
+  
+> 나눗셈의 몫과 나머지를 함께 구하려면 `divmod()` 함수를 사용하면 됩니다.
+  
+> `**`는 거듭제곱 연산자입니다.

doc/03_02_bool.md

@@ -0,0 +1,67 @@
+# 부울
+
+부울 자료형은 참(True) 또는 거짓(False) 두 가지 값만을 가질 수 있는 자료형입니다. 즉, 어떤 조건이 만족되는지 여부를 나타내는 데 사용됩니다.
+
+부울 자료형은 조건문, 반복문, 그리고 논리 연산에서 사용됩니다.
+
+- bool
+  
+  `True` 또는 `False`값을 가질 수 있습니다. True와 False는 대문자로 시작합니다.
+  
+```python
+is_python_fun = True
+is_coding_hard = False
+```
+
+## 형변환
+
+```python
+bool(0)  # False
+bool(1)  # True
+bool("")  # False (빈 문자열)
+bool("hello")  # True (빈 문자열이 아니므로 True)
+```
+
+### 부울 값으로 간주되는 값들
+`0`과 `0.0` 이외의 모든 숫자는 `True`입니다. 또 빈 문자열 이외의 모든 문자열은 `True`입니다.
+
+#### True로 간주되는 값:
+* 숫자 0이 아닌 모든 숫자
+* 빈 문자열이 아닌 모든 문자열
+* 리스트, 튜플, 딕셔너리 등의 비어 있지 않은 컨테이너
+
+#### False로 간주되는 값:
+* 숫자 0
+* 빈 문자열 ("" 또는 '')
+* None
+* 리스트, 튜플, 딕셔너리 등의 비어 있는 컨테이너
+
+## 비교 연산
+
+```python
+x = 10
+y = 5
+is_greater = x > y  # is_greater는 True가 됩니다.
+```
+
+```python
+1 == 1.0 # True
+1 is 1.0 # False
+1 is not 1.0 # True
+```
+
+> 객체를 비교할 때에는 `is`와 `is not` 연산자를 사용합니다.
+
+## 논리 연산
+
+`and`, `or`, `not` 연산자를 사용합니다.
+
+* and: 두 조건이 모두 참일 때만 참
+* or: 두 조건 중 하나라도 참이면 참
+* not: 조건의 반대
+
+```python
+a = True
+b = False
+result = a and b  # result는 False가 됩니다.
+```

doc/03_03_string.md

@@ -0,0 +1,192 @@
+# 문자열
+
+파이썬에서 문자열은 텍스트 데이터를 다루는 데 있어 가장 기본적인 자료형이라고 할 수 있습니다.
+
+- str
+  
+  문자열은 홑따옴표 또는 쌍따옴표로 묶어서 표현합니다. 삼중 따옴표(홑따옴표 또는 쌍따옴표)로 여러 줄 문자열을 표현할 수 있습니다.
+  
+## 문자열의 생성
+
+```python
+# 작은따옴표 사용
+string1 = 'Hello, world!'
+
+# 큰따옴표 사용
+string2 = "Python is fun!"
+
+# 여러 줄 문자열 (""" 또는 ''' 사용)
+multiline_string = """
+This is a multi-line string.
+You can use triple quotes to create them.
+"""
+```
+
+## 인덱싱
+문자열의 특정 문자에 접근하는 방법입니다. 파이썬은 0부터 시작하는 인덱스를 사용합니다.
+
+```python
+string = "hello"
+print(string[0])  # h 출력
+print(string[-1])  # o 출력 (뒤에서 첫 번째 문자)
+```
+
+## 슬라이싱
+문자열의 일부분을 추출하는 방법입니다.
+
+```python
+string = "hello world"
+print(string[1:5])  # ello 출력 (1번 인덱스부터 5번 인덱스 바로 앞까지)
+```
+
+## 연산
+`+` 연산자를 사용하여 문자열을 연결할 수 있습니다.
+```python
+
+```
+
+`*` 연산자를 사용하여 문자열을 반복할 수 있습니다.
+```python
+repeat_string = "hello" * 3  # hellohellohello
+```
+
+
+## 문자열 메서드
+파이썬은 문자열을 다루기 위한 다양한 메소드를 제공합니다.
+
+- replace(바꿀문자열, 새문자열)
+
+  문자열 내의 특정 문자열을 다른 문자열로 바꿈
+  
+- translate()
+  
+  문자열 내의 문자를 치환합니다.
+  
+  ```python
+  table = str.maketrans('aeiou', 'AEIOU')
+  a = 'i like an apple'.translate(table) # I lIkE An ApplE
+  ```
+  
+- split()
+  
+  문자열을 특정 구분자를 기준으로 나누어 리스트로 반환. 기본적으로, 공백을 기준으로 문자열을 분리합니다.
+  
+  ```python
+  a = 'apple,orange,mango,banana'.split(',')
+  ```
+  
+- join(리스트)
+  
+  리스트의 요소들을 하나의 문자열로 합침
+  
+  ```python
+  '-'.join(['apple','orange','mango','banana'])
+  ```
+  
+- upper(), lower(), capitalize(), casefold(), swapcase()
+  
+  문자열을 대문자 또는 소문자로 변환
+  
+- strip(), lstrip(), rstrip()
+  
+  문자열의 왼쪽, 오른쪽, 또는 양쪽의 공백을 제거합니다. 매개변수에 제거할 문자목록 지정할 수도 있습니다.
+  
+  ```python
+  '...hello'.strip('.')
+  ```
+  
+- endswith(), startswith()
+
+- ljust(길이), rjust(길이), center(길이)
+  
+  정렬
+  
+  ```python
+  'apple'.ljust(10) # 'apple     '
+  ```
+  
+- zfill(길이)
+  
+  지정된 길이 맞춰서 0으로 채웁니다.
+  
+- find(찾을문자열), rfind()
+  
+  문자열 내에서 특정 문자열의 위치를 찾음. 주어진 문자열이 처음 나타나는 인덱스를 반환하며, 찾는 문자열이 없으면 -1을 반환합니다.
+  
+- index(), rindex()
+  
+  `find()`와 마찬가지로 찾는 문자열의 인덱스를 반환하지만, 문자열을 찾지 목한 떄에는 오류가 발생됩니다.
+  
+- count(문자열)
+  
+  주어진 문자열의 갯수를 셉니다.
+
+- encode(), decode()
+  
+- isalpha(), isdigit(), isnumeric(), isupper(), islower()
+
+## 형식화 문자열
+
+```python
+name = 'Charlie'
+a = 'Hello, %s.' % name
+
+age = 14
+b = "I'm %d years old." % age
+
+value = 3.3
+c = 'The price is %f dollars.' % value
+c = 'The price is %.2f dollars.' % value # 소수점 이하 자릿수를 지정
+
+d = '%s is %d years old.' % (name, age) # 여러 개일 떄에는 괄호로 묶습니다.
+```
+
+## format()
+
+format 함수는 파이썬에서 문자열 내에 변수나 값을 삽입하여 다양한 형식의 문자열을 생성하는 데 사용됩니다. 즉, 미리 정의된 틀에 값을 채워 넣는다고 생각하면 됩니다.
+
+```python
+문자열 = "안녕하세요, {}입니다. 저는 {}살입니다.".format(이름, 나이)
+```
+위 예시에서 {} 부분에 format() 함수의 인수가 차례대로 대입됩니다.
+
+{} 안에 숫자를 넣어 인수의 순서를 지정할 수 있습니다.
+
+```python
+print("{1} {0}".format("world", "Hello"))  # Hello world 출력
+```
+{} 안에 키워드를 넣어 인수를 지정할 수 있습니다.
+
+```python
+print("이름: {name}, 나이: {age}".format(name="홍길동", age=30))
+```
+숫자를 특정 형식으로 출력할 수 있습니다.
+
+```python
+print("원주율은 {:.2f}입니다.".format(3.141592))  # 원주율은 3.14입니다.
+```
+
+## f-string
+Python 3.6이상에서는 format 함수와 비슷한 기능을 더 간결하게 사용할 수 있는 방법이 있습니다.
+
+문자열 앞에 포맷 지시자('f')를 붙여주면 됩니다.
+
+```python
+name = "홍길동"
+age = 30
+print(f"안녕하세요, {name}입니다. 저는 {age}살입니다.")
+```
+```python
+# 상품 정보 출력
+product = {"name": "아이폰 14", "price": 1500000, "stock": 100}
+print(f"상품명: {product['name']}, 가격: {product['price']}원, 재고: {product['stock']}개")
+```
+
+```python
+import datetime
+today = datetime.datetime.now()
+print(f"오늘은 {today:%Y년 %m월 %d일}입니다.")
+```
+
+## 문자열은 불변(immutable)
+한번 생성된 문자열은 변경할 수 없습니다. 문자열을 수정하려면 새로운 문자열을 생성해야 합니다.

doc/03_04_sequence_type.md

@@ -0,0 +1,305 @@
+# 시퀀스 자료형
+시퀀스 자료형은 데이터를 순서대로 나열하여 저장하는 자료형입니다. 파이썬에서 가장 많이 사용되는 시퀀스 자료형으로는 리스트(list), 튜플(tuple), 문자열(string), range 등이 있습니다.
+
+## 리스트
+  
+리스트는 각 항목을 콤마로 구분하고, 대괄호(`[`, `]`)로 묶어서 표현합니다.
+  
+요소 추가, 삭제, 수정이 자유롭습니다.
+
+```python
+a = [1, 2, 3]
+b = [10, 'Hello', True] # 여러 자료형을 혼용해도 됩니다.
+c = [] # 빈 리스트 자료형을 반듭니다. 또는,
+d = list() # list() 함수를 사용해서 빈 리스트 자료형을 만듭니다.
+e = list('Hello') # 문자열을 리스트로 변환하면 ['H', 'e', 'l', 'l', 'o']
+```
+
+## 튜플
+  
+튜플은 괄호(`(`, `)`)로 묶어서 표현합니다. 튜플은 리스트와 비슷하지만 항목을 추가, 변경, 삭제할 수 없습니다.
+  
+```python
+a = (1, 2, 3)
+# 또는, 괄호를 생략해도 됩니다.
+b = 1, 2, 3
+```
+  
+```python
+a = (10) # 10 => 튜플의 아이템이 하나인 경우, 튜플이 아니라 그냥 숫자값이 됩니다.
+# 아이템이 하나인 튜플을 만들려면 끝에 콤마를 붙여야 합니다.
+b = (10,) # (10,) 
+c = 10, # 또는, 튜플은 괄호를 생략할 수 있으므로
+```
+
+## 레인지
+
+`range()`는 일련의 숫자를 만드는데 사용되며, Python3에서는 `range` 타입이 반환됩니다.
+
+- `range(끝값)` : 시작 값이 주어지지 않으면 0부터 시작하며, 끝값은 포함되지 않습니다.
+- `range(시작값, 끝값)`
+- `range(시작값, 끝값, 증분)`
+  
+
+```python
+a = list(range(10)) # [0,1,2,3,4,5,6,7,8,9] 
+b = list(range(5, 10)) # [5,6,7,8,9]
+c = list(range(1, 10, 2)) # [1,3,5,7,9]
+d = list(range(5, -5, -2)) # [5,3,1,-1,-3]
+```
+
+## 공통점 
+리스트, 튜플, 레인지, 그리고 문자열은 모두 어떤 값들의 연속체라는 공통점이 있습니다. 이들을 시퀀스 자료형이라고 부릅니다. 그 외에 `bytes`, `bytearray`라는 자료형도 있습니다.
+
+### 인덱싱
+각 요소에 고유한 인덱스(0부터 시작)를 가지며, 인덱스를 사용하여 특정 요소에 접근할 수 있습니다.
+```python
+my_list = [10, 20, 30]
+print(my_list[0])  # 10 출력
+```
+
+### 슬라이싱
+일부분을 추출할 수 있습니다.
+```python
+my_string = "hello"
+print(my_string[1:4])  # "ell" 출력
+```
+
+### 연결
+`+` 연산자로 연결할 수 있습니다. 단, `range`는 안됩니다.
+```python
+a = [1, 3, 5, 7, 9] + [2, 4, 6, 8, 10] # [1,3,5,7,9,2,4,6,8,10]
+```
+
+```python
+a = 'Hello, ' str(100) # 문자열에 숫자를 연결할 때에는 숫자를 문자열로 변환해 주어야 합니다.
+```
+
+### 반복
+`*` 연산자로 반복할 수 있습니다. 단, `range`는 안됩니다.
+```python
+a = [1, 2, 3] * 3 # [1,2,3,1,2,3,1,2,3]
+```
+
+## 특정 아이템 포함 여부
+in/not in 연산자를 사용해서 특정 아이템을 포함하고 있는지 여부를 확인할 수 있습니다.
+```python
+a = [1, 3, 5, 7, 9]
+b = 2 in a # False
+c = 2 not in a # True
+```
+
+## 길이 확인
+
+```python
+a = len([1, 2, 3]) # 3
+```
+
+```python
+hello = '안녕하시오!'
+a = len(hello) # 문자열의 길이는 6입니다. Python2에서는 문자열의 바이트 길이를 반환합니다.
+b = len(hello.encode('utf-8')) # 문자열의 바이트 길이는 16
+```
+
+## 인덱스를 통한 접근
+
+다른 프로그래밍 언어들과 마찬가지로 인덱스는 대괄호를 사용해서 표현하며, 인덱스는 0부터 시작합니다.
+
+```python
+a = [1, 2, 3]
+print(a[0]) # 1
+# 내부적으로는 객체의 __getitem__() 메서드를 호출합니다. 따라서,
+print(a.__getitem__(0))
+# 음수 인덱스를 사용하면 맨 마지막 항목부터 셉니다.
+print(a[-1]) # 3
+```
+
+## 인덱스를 통한 항목 값의 변경
+
+튜플, 문자열, 레인지의 경우에는 값을 변경할 수 없는 타입이므로 오류가 발생합니다.
+
+```python
+a = [1, 2, 3]
+a[1] = 4 # [1,4,3]
+a[5] = 5 # Error. 리스트의 범위를 벗어났으므로 오류입니다.
+```
+
+## 항목의 삭제
+
+`del`을 사용해서 항목을 삭제합니다. 튜플, 문자열, 레인지의 경우에는 값을 변경할 수 없는 타입이므로 오류가 발생합니다.
+
+```python
+a = [1, 2, 3]
+del a[1] # [1,3]
+```
+
+## 부분 시퀀스
+
+시작 인덱스와 끝 인덱스를 사용해서 어떤 시퀀스의 부분을 가져올 수 있습니다. 끝 인덱스는 포함되지 않습니다.
+
+```python
+a = [1, 2, 3, 4, 5]
+b = a[0:2] # [1,2]
+c = a[0:5:2] # [1,3,5] => 시작과 끝 인덱스에 덧붙여 증분도 사용할 수 있습니다.
+d = a[:5] # 시작 인덱스를 생략하면 0번 인덱스부터 가져옵니다.
+e = a[2:] # 끝 인덱스가 생략되면 마지막 요소까지 가져옵니다.
+```
+
+## 반전
+
+```python
+reversed(range(5)) 
+```
+
+## 슬라이스 객체 (slice)
+
+`slice()`는 `range()`와 사용법이 같으며, `slice` 타입이 반환됩니다.
+
+- slice(끝값)
+  
+  시작 값이 주어지지 않으면 0부터 시작하며, 끝값은 포함되지 않습니다.
+  
+- slice(시작값, 끝값)
+  
+- slice(시작값, 끝값, 증분)
+  
+
+```python
+a = [1, 2, 3, 4, 5]
+s = slice(0, 2)
+a[s] # [1,2] 대괄호 안에 슬라이스 객체를 넣어서 사용합니다.
+```
+
+### 슬라이스 객체를 이용한 할당
+
+```python
+a = [1, 2, 3, 4, 5]
+a[0:2] = ['a', 'b'] # ['a', 'b', 3, 4, 5]
+```
+
+만약 슬라이스의 범위와 할당할 값의 길이가 서로 다르다면
+
+```python
+a = [1, 2, 3, 4, 5]
+a[0:2] = ['a'] # ['a', 3, 4, 5] => a[0]은 할당되고, a[1]은 사라집니다.
+
+a = [1, 2, 3, 4, 5]
+a[0:2] = ['a', 'b', 'c'] # ['a', 'b', 'c', 3, 4, 5]
+```
+
+## 리스트의 해체
+```python
+tuple1 = (10,20,30)
+x, y, z = tuple1
+print ("x: ", x, "y: ", "z: ",z)
+```
+
+## 리스트의 메서드
+
+- append()
+  
+  리스트의 맨 뒤에 아이템을 하나 추가합니다.
+  
+- extend()
+  
+  리스트를 연결해서 확장합니다.
+  
+- insert()
+  
+  특정 인덱스에 아이템을 추가합니다.
+  
+
+```python
+a = [1, 2, 3]
+a.append(4)    # [1,2,3,4]
+a.extend([5, 6]) # [1,2,3,4,5,6]
+a.insert(2, 'a') # [1,2,'a',3,4,5,6]
+```
+
+- pop()
+  
+  마지막 아이템 또는 특정 아이템을 반환하며 리스트에서 제거합니다.
+  
+- remove()
+  
+  특정 값을 삭제합니다. `pop()`이 인덱스를 사용하는 반면 `remove()`는 리스트에서 특정 값을 제거합니다. 만일, 리스트에 같은 값이 여러 개인 경우에는 처음 찾은 값이 제거됩니다.
+  
+
+```python
+a = [1, 2, 3, 4, 5]
+b = a.pop() # b=5 a=[1,2,3,4]
+b= a.pop(2) # b=3 a=[1,2,4]
+a.remove(4) # a=[1,2]
+```
+
+- index()
+  
+  특정 값의 인덱스를 반환합니다.
+  
+- count()
+  
+  특정 값의 갯수를 반환합니다.
+  
+- reverse()
+  
+  아이템의 순서를 반대로 뒤집습니다.
+  
+- sort(reverse=False)
+  
+  아이템을 정렬합니다.
+  
+- sorted()
+  
+  `sort()`와 비슷하지만, 리스트를 수정하지 않고 새로운 리스트를 반환합니다.
+  
+- clear()
+  
+  리스트의 모든 아이템을 삭제합니다.
+  
+- copy()
+  
+  리스트를 복제합니다.
+  
+
+## 리스트 컴프리핸션
+
+리스트 구문 안에 반복문이나 조건문을 사용할 수 있습니다.
+
+이 방식으로 튜플을 만들 때에는 `tuple()`을 사용해야 합니다. 괄호를 사용하면 튜플이 아니라 제너레이터가 만들어집니다.
+
+```python
+a = [i for i in range(5)] # [0,1,2,3,4]
+b = [i * 2 for i in range(5)] # [0,2,4,6,8]
+
+# 반복문 뒤에 조건문을 이어 붙일 수 있습니다.
+c = [i for i in range(5) if i % 2 == 0] # [0,2,4]
+
+# 반복문을 여러 개 사용할 수도 있습니다. 이 때 처리 순서는 뒤에서부터 앞으로 처리됩니다.
+d = [i * J for j in range(2,10) for i in range(1,10)]
+```
+
+
+## 다차원 리스트
+
+리스트 안에 리스트를 넣으면 다차원 리스트가 됩니다. 튜플도 마찬가지입니다.
+
+```python
+a = [[1,2], [3,4], [5,6]]
+```
+
+다차원 리스트를 복제하려면 `deepcopy()`를 사용해야 합니다.
+
+```python
+import copy
+b = copy.deepcopy(a)
+```
+
+
+
+
+## 시퀀스 자료형 선택 가이드
+* 변경 가능성: 요소를 추가하거나 삭제해야 할 경우 리스트를 사용합니다.
+* 불변성: 데이터를 보호해야 할 경우 튜플을 사용합니다.
+* 문자열 처리: 문자열 연산이 필요할 경우 문자열을 사용합니다.
+* 숫자 연속: 숫자의 연속된 값이 필요할 경우 range를 사용합니다.
+

doc/03_05_dict.md

@@ -0,0 +1,136 @@
+# 딕셔너리
+딕셔너리는 파이썬에서 **키(key)**와 **값(value)** 쌍으로 이루어진 데이터를 저장하는 자료형입니다. 마치 사전처럼 키를 통해 값을 찾아볼 수 있어 연관 배열이라고도 불립니다. 딕셔너리는 순서가 없고, 키는 중복될 수 없다는 특징이 있습니다.
+  
+- dict
+  
+  딕셔너리는 키/값 형식의 자료형입니다. 중괄호(`{`, `}`)를 사용해서 표현합니다.
+  
+## 특징
+### 딕셔너리의 장점
+* 빠른 검색: 키를 이용하여 값을 빠르게 찾을 수 있습니다.
+* 유연성: 다양한 자료형을 키와 값으로 사용할 수 있습니다.
+* 동적: 실행 중에 키-값 쌍을 추가, 수정, 삭제할 수 있습니다.
+### 딕셔너리의 단점
+* 순서 보장 X: 딕셔너리는 순서가 없기 때문에 요소를 순서대로 접근하기 어렵습니다. 단, Python 3.6 이상에서는 순서가 유지됩니다.
+
+## 딕셔너리 생성
+```python
+a = {'name': 'Charlie', 'age': 14}
+b = dict(name='Steve', age=37) # dict()를 사용할 때에는 키를 따옴표로 묶지 않습니다.
+
+c = {} # 빈 딕셔너리를 만듭니다. 또는,
+d = dict()
+
+e = dict(zip(['name', 'age'], ['Jane', 24])) # zip()을 사용해서 키와 값을 묶을 수도 있습니다.
+f = dict([('name', 'Olaf'), ('age', 7)]) # 리스트 안에 튜플을 사용해서 생성할 수도 있습니다.
+g = dict({'name': 'Charlie', 'age': 14}) # dict() 안에 중괄호를 한 번 더 사용해도 됩니다.
+```
+
+## 딕셔너리 요소 접근
+딕셔너리의 키에 대괄호를 사용해서 아이템에 접근하거나 변경할 수 있습니다.
+
+```python
+person = {'name': 'Charlie', 'age': 14}
+person['name'] # 'Charlie'
+
+person.get('name') # get() 메서드를 사용할 수도 있습니다.
+```
+
+`in` 연산자를 사용해서 딕셔너리에 해당 키가 존재하는지 확인할 수 있습니다.
+
+```python
+person = {'name': 'Charlie', 'age': 14}
+if 'name' in person:
+    print(person['name'])
+else:
+    print("정보가 없습니다.")
+```
+
+키의 갯수를 알고 싶으면 `len()`을 사용합니다.
+
+```python
+len({'name': 'Charlie', 'age': 14}) # 2
+```
+
+## 딕셔너리 요소 추가, 수정, 삭제
+
+```python
+# 새로운 키-값 쌍 추가
+student['address'] = '서울시'
+
+# 값 수정
+student['age'] = 21
+
+# 키 삭제
+del student['score'] # 키를 제거하려면 `del`을 사용합니다.
+```
+
+딕셔너리를 복제하려면 `deepcopy()`를 사용해야 합니다.
+
+```python
+import copy
+y = deepcopy(a)
+```
+
+## 딕셔너리의 메서드
+
+- setdefault(키, 값)
+  
+  키에 대한 기본값을 지정합니다. `update()`와 달리 해당 키가 이미 정의되어 있다면 값이 변경되지 않습니다.
+  
+- update(키, 값)
+  
+  키에 대한 값을 변경합니다. 키가 정의되어 있지 않다면 새로운 키가 등록됩니다.
+  
+- pop(키, 기본값)
+  
+  키에 대한 값을 반환하며, 딕셔너리에서는 제거됩니다. 매개변수에 기본값을 주면 해당 키가 없을 때에 그 값을 반환합니다.
+  
+- popitem()
+  
+  마지막 키/값 쌍을 튜플로 반환하고 삭제합니다. Python 3.5 이하에서는 임의의 키/값 쌍을 반환합니다.
+  
+- clear()
+  
+  모든 키/값 쌍을 삭제합니다.
+  
+- get(키) : 키에 해당하는 값을 반환하고, 키가 없으면 기본값을 반환합니다.
+  
+- items() : 키-값 쌍을 튜플 형태로 반환합니다.
+  
+- keys() : 모든 키를 반환합니다.
+  
+- values() : 모든 값을 반환합니다.
+  
+
+```python
+for key, value in {'a':100, 'b':200, 'c':300}.items():
+    print(key, value)
+```
+
+```python
+# 학생들의 점수 저장
+scores = {'수학': 90, '영어': 85, '과학': 95}
+
+# 모든 과목의 점수 출력
+for subject, score in scores.items():
+    print(f"{subject}: {score}점")
+
+# 평균 점수 계산
+total = sum(scores.values())
+average = total / len(scores)
+print(f"평균 점수: {average}점")
+```
+
+## 멀티 레벨 딕셔너리
+
+딕셔너리 안에 딕셔너리를 넣으면 계층형 데이터 구조를 만들 수 있습니다.
+
+```python
+a = {
+    'charlie': {'name': 'Charlie', 'age': 14},
+    'steve': {'name': 'Steve', 'age': 37},
+    'jane': {'name': 'Jane', 'age': 22}
+}
+```
+

doc/03_06_set.md

@@ -0,0 +1,100 @@
+# Set
+파이썬의 set 자료형은 수학에서의 집합 개념을 그대로 가져온 자료형입니다. 즉, 중복되는 요소를 허용하지 않고 순서가 없는 자료형입니다.
+
+- set
+  
+  세트의 아이템은 중복될 수 없으며, 순서도 없습니다. 중괄호(`{`, `}`)를 사용해서 표현합니다.
+  
+## 특징
+* 중복 허용 X: 같은 값을 여러 번 넣어도 하나의 값만 유지됩니다.
+* 순서 없음: 요소들이 특정 순서로 저장되지 않습니다. 따라서 인덱싱을 통해 요소에 접근할 수 없습니다.
+* 변경 가능: 요소를 추가하거나 삭제할 수 있습니다.
+
+## set 자료형 생성하기
+```python
+a = {'apple', 'orange', 'banana'}
+b = set('apple', 'orange', 'banana')
+empty_set = set()
+
+my_set = {1, 2, 3, 2}  # 중복된 2는 하나만 포함
+```
+
+불변 세트를 만들려면 frozenset()를 사용합니다. Immutable 세트는 값을 수정할 수 없습니다.
+```python
+c = frozenset('apple', 'orange', 'banana') 
+```
+
+리스트와 달리 순서가 없으므로, `my_set[0]`과 같이 대괄호 안에 인덱스를 사용해서 요소에 접근할 수 없습니다.
+
+세트 안에 중첩된 세트를 넣을 수도 없습니다.
+
+## 아이템의 추가 / 삭제
+add() 메서드를 사용하여 요소를 추가합니다.
+```python
+my_set.add(4)
+```
+
+remove() 메서드를 사용하여 요소를 삭제합니다. 없는 요소를 삭제하려고 하면 KeyError가 발생합니다. discard() 메서드는 요소가 없어도 에러 없이 무시합니다.
+```python
+my_set.remove(2)
+my_set.discard(5)  # 5가 없어도 에러 발생하지 않음
+```
+## 아이템 포함 여부
+세트 안에 어떤 값이 있는지 확인하려면 `in`을 사용합니다.
+
+```python
+a = {'apple', 'orange', 'banana'}
+'orange' in a # True
+```
+## 집합 연산
+논리 연산자 또는 set의 메서드를 사용해서 집합 연산을 할 수 있습니다.
+
+```python
+a = {1, 2, 3}
+b = {3, 4, 5, 6}
+
+a | b # 합집합 {1,2,3,4,5,6}
+set.union(a, b)
+a & b # 교집합 {3}
+set.intersection(a, b)
+a - b # 차집합 {1,2}
+set.difference(a, b)
+a ^ b # 대칭 차집합
+set.symmetric_difference(a, b)
+```
+
+- `set.union()`, `|` : 합집합
+  
+- `set.intersection()`, `&` : 교집합
+  
+- `set.difference()`, `-` : 차집합
+  
+- `set.symmetric_difference()`
+  
+- `update(세트)`, `|=`
+  
+- `intersection_update(세트)`, `&=`
+  
+- `difference_update(세트)`, `-=`
+  
+- `symmetric_update(세트)`, `^=`
+  
+
+비교 연산자를 사용해서 포함 관계를 확인할 수 있습니다.
+
+```python
+{1,2,3} <= {1,2,3,4,5} # 다른 집합의 부분집합인지 여부
+{1,2,3}.issubset({1,2,3,4,5})
+
+{1,2,3} < {1,2,3,4,5} # 다른 집합의 진부분집합인지 여부
+
+{1,2,3} >= {1,2,3,4,5} # 다른 집합의 상위집합인지 여부
+{1,2,3}.issuperset({1,2,3,4,5})
+
+{1,2,3} > {1,2,3,4,5} # 다른 집합의 진상위집합인지 여부
+
+{1,2,3} == {1,2,3,4,5} # 서로 같은지 여부
+{1,2,3} != {1,2,3,4,5}
+
+{1,2,3}.isdisjoint({1,2,3,4,5}) # 서로 겹치는 요소가 없으면 True가 반환됩니다.
+```

doc/03_07_binary_type.md

@@ -0,0 +1,24 @@
+# 이진 데이터
+
+파이썬에서 이진 데이터를 다룰 때 자주 사용되는 자료형으로 `bytes`와 `bytearray`가 있습니다. 둘 다 1바이트 단위의 값을 연속적으로 저장하는 시퀀스 자료형이지만, 각각 고유한 특징을 가지고 있습니다.
+
+  - bytes
+    * 불변(immutable) 시퀀스이므로, 한번 생성된 후에는 값을 변경할 수 없습니다.
+    * 파일에서 읽어온 바이너리 데이터, 네트워크 통신에서 받은 데이터 등 주로 읽기 전용 데이터를 저장하는 데 적합합니다.
+
+  - bytearray
+
+    * `bytes`와 달리 가변(mutable) 시퀀스이므로, 요소를 변경할 수 있습니다.
+
+```python
+b1 = b'Hello' # 문자열에 b를 붙여 생성
+b2 = bytes([65, 66, 67, 68, 69]) # 바이트 객체를 직접 생성
+
+b3 = bytearray(10) # 길이가 10인 바이트 배열 생성
+b4 = bytearray(b'hello') # bytes 객체를 변환
+b5 = bytearray([72, 101, 108, 108, 111])
+```
+
+> bytes와 str은 서로 다른 자료형입니다. 문자열을 바이트로 변환하려면 `encode()` 메서드를 사용하고, 바이트를 문자열로 변환하려면 `decode()` 메서드를 사용합니다.
+
+> 바이트 값은 0 ~ 255 사이의 정수 값입니다.

doc/03_data_types.md

@@ -1,224 +0,0 @@
-# 자료형
-
-## 변수
-
-### 변수의 선언 및 할당
-파이썬에서 변수는 할당과 함께 선언됩니다.
-
-```python
-a = 100
-b = 'Hello'
-
-c = None # 할당없이 선언만 하려면 None을 사용합니다. None은 다른 프로그래밍 언어의 null에 해당합니다.
-
-x, y, z = 100, 200, 300 # x=100, y=200, z=300
-i = j = k = 10 # i=10, j=10, k=10
-```
-
-할당된 변수의 메모리 상 번지를 확인하려면, `id()`를 사용합니다.
-```python
-a = 123
-id(a)
-```
-
-### 객체의 자료형 확인
-
-```python
-type(a) # type() 함수는 자료형을 반환합니다.
-```
-
-### 형변환
-
-자료형을 함수명으로 사용하면 형변환을 할 수 있습니다.
-
-```python
-int(3.3) # 3
-int('100') # 100
-float(3) # 3.0
-```
-
-그 외에 `chr()`, `unichr()`, `hex()`등의 형변환 함수도 있습니다.
-
-### 변수 삭제
-할당된 변수를 제거하려면 `del`을 사용합니다.
-
-```python
-x = 100
-del x
-```
-### 상수
-파이썬에는 상수가 없습니다. 관례적으로 대문자 이름을 사용합니다.
-
-### 스왑
-
-```python
-x, y = 10, 20
-x, y = y, z
-```
-
-## 자료형
-* int, float, complex
-* str
-* list, tuple, range
-* bytes, bytearray, memoryview
-* dict
-* set, frozenset
-* bool
-* None
-
-### 숫자
-
-- int
-  
-  정수형
-  
-- float
-  
-  부동소수형
-  
-- complex
-  
-  복소수형. 허수부 뒤에 j를 붙입니다(`1.2+1.3j`).
-  
-
-```python
-a = 100
-b = 3.14
-c = 0o34
-d = 0xff
-e = 1.28e-10
-```
-
-#### 숫자의 연산
-
-```python
-print(1 + 1) # 2
-print(1 - 2) # -1
-print(3 * 7) # 21
-print(4 / 2) # 2.0
-print(4 // 2) # 2
-print(4 % 3) # 1
-print(2 ** 4) # 16
-```
-
-- Python3 에서는 다른 프로그래밍 언어와는 달리, 정수 끼리의 나눗셈 결과가 실수(float)로 반환됩니다. 나눗셈의 결과를 정수로 받으려면 버림 나눗셈 연산자(`//`)를 사용해야 합니다.
-  
-  나눗셈의 몫과 나머지를 함께 구하려면 `divmod()` 함수를 사용하면 됩니다.
-  
-- `**`는 거듭제곱 연산자입니다.
-  
-
-### 부울
-
-- bool
-  
-  `True` 또는 `False`값을 가질 수 있습니다. True와 False는 대문자로 시작합니다.
-  
-
-#### 형변환
-
-`0`과 `0.0` 이외의 모든 숫자는 `True`입니다. 또 빈 문자열 이외의 모든 문자열은 `True`입니다.
-
-```python
-bool(0.0) # False
-bool('False') # True
-```
-
-#### 비교 연산
-
-```python
-1 == 1.0 # True
-1 is 1.0 # False
-1 is not 1.0 # True
-```
-
-- 객체를 비교할 때에는 `is`와 `is not` 연산자를 사용합니다.
-
-#### 논리 연산
-
-- `and`, `or`, `not` 연산자를 사용합니다.
-
-### 문자
-
-- str
-  
-  문자열은 홑따옴표 또는 쌍따옴표로 묶어서 표현합니다. 삼중 따옴표(홑따옴표 또는 쌍따옴표)로 여러 줄 문자열을 표현할 수 있습니다.
-  
-
-```python
-a = 'Hello'
-b = "Hello"
-c = '''Hello,
-여러 줄 문자열.'''
-d = "It's me."
-```
-
-### 집합
-
-- list
-  
-  리스트는 각 항목을 콤마로 구분하고, 대괄호(`[`, `]`)로 묶어서 표현합니다.
-  
-  ```python
-  a = [1, 2, 3]
-  b = [10, 'Hello', True] # 여러 자료형을 혼용해도 됩니다.
-  c = [] # 빈 리스트 자료형을 반듭니다. 또는,
-  d = list() # list() 함수를 사용해서 빈 리스트 자료형을 만듭니다.
-  e = list('Hello') # 문자열을 리스트로 변환하면 ['H', 'e', 'l', 'l', 'o']
-  ```
-  
-- tuple
-  
-  튜플은 괄호(`(`, `)`)로 묶어서 표현합니다. 튜플은 리스트와 비슷하지만 항목을 추가, 변경, 삭제할 수 없습니다.
-  
-  ```python
-  a = (1, 2, 3)
-  # 또는, 괄호를 생략해도 됩니다.
-  b = 1, 2, 3
-  ```
-  
-  ```python
-  a = (10) # 10 => 튜플의 아이템이 하나인 경우, 튜플이 아니라 그냥 숫자값이 됩니다.
-  # 아이템이 하나인 튜플을 만들려면 끝에 콤마를 붙여야 합니다.
-  b = (10,) # (10,) 
-  c = 10, # 또는, 튜플은 괄호를 생략할 수 있으므로
-  ```
-  
-- dict
-  
-  딕셔너리는 키/값 형식의 자료형입니다. 중괄호(`{`, `}`)를 사용해서 표현합니다.
-  
-  ```python
-  a = {'name': 'Charlie', 'age': 14}
-  b = dict(name='Steve', age=37) # dict()를 사용할 때에는 키를 따옴표로 묶지 않습니다.
-  
-  c = {} # 빈 딕셔너리를 만듭니다. 또는,
-  d = dict()
-  
-  e = dict(zip(['name', 'age'], ['Jane', 24])) # zip()을 사용해서 키와 값을 묶을 수도 있습니다.
-  f = dict([('name', 'Olaf'), ('age', 7)]) # 리스트 안에 튜플을 사용해서 생성할 수도 있습니다.
-  g = dict({'name': 'Charlie', 'age': 14}) # dict() 안에 중괄호를 한 번 더 사용해도 됩니다.
-  ```
-  
-- set
-  
-  세트의 아이템은 중복될 수 없으며, 순서도 없습니다. 중괄호(`{`, `}`)를 사용해서 표현합니다.
-  
-  ```python
-  a = {'apple', 'orange', 'banana'}
-  b = set('apple', 'orange', 'banana')
-  
-  # 불변 세트를 만들려면 frozenset()를 사용합니다.
-  c = frozenset('apple', 'orange', 'banana') # Immutable 세트는 값을 수정할 수 없습니다.
-  ```
-
-  ### 이진 데이터
-  - bytes
-    각 아이템은 0~255 사이의 정수값을 갖습니다.
-  - bytearray
-    `bytes`와 달리 가변 데이터입니다.
-
-  ```python
-  b1 = bytes([65, 66, 67, 68, 69])
-  b2 = bytearray([72, 101, 108, 108, 111])
-  ```

doc/04_sequence_types.md

@@ -1,518 +0,0 @@
-# ㅁㅁㅁ
-
-## 시퀀스 자료형
-
-리스트, 튜플, 레인지, 그리고 문자열은 모두 어떤 값들의 연속체라는 공통점이 있습니다. 이들을 시퀀스 자료형이라고 부릅니다. 그 외에 `bytes`, `bytearray`라는 자료형도 있습니다.
-
-### 레인지 객체 (range)
-
-`range()`는 일련의 숫자를 만드는데 사용되며, Python3에서는 `range` 타입이 반환됩니다.
-
-- range(끝값)
-  
-  시작 값이 주어지지 않으면 0부터 시작하며, 끝값은 포함되지 않습니다.
-  
-- range(시작값, 끝값)
-  
-- range(시작값, 끝값, 증분)
-  
-
-```python
-a = list(range(10)) # [0,1,2,3,4,5,6,7,8,9] 
-b = list(range(5, 10)) # [5,6,7,8,9]
-c = list(range(1, 10, 2)) # [1,3,5,7,9]
-d = list(range(5, -5, -2)) # [5,3,1,-1,-3]
-```
-
-### 특정 아이템을 포함하고 있는지 확인
-
-```python
-a = [1, 3, 5, 7, 9]
-b = 2 in a # False
-c = 2 not in a # True
-```
-
-### 연결
-
-시퀀스 자료형은 `+` 연산자를 사용해서 이어 붙일 수 있습니다. 단, `range`는 안됩니다.
-
-```python
-a = [1, 3, 5, 7, 9] + [2, 4, 6, 8, 10] # [1,3,5,7,9,2,4,6,8,10]
-```
-
-```python
-a = 'Hello, ' str(100) # 문자열에 숫자를 연결할 때에는 숫자를 문자열로 변환해 주어야 합니다.
-```
-
-### 반복
-
-`*` 연산자는 반복에 사용됩니다. 단, `range`는 안됩니다.
-
-```python
-a = [1, 2, 3] * 3 # [1,2,3,1,2,3,1,2,3]
-```
-
-### 갯수
-
-```python
-a = len([1, 2, 3]) # 3
-```
-
-```python
-hello = '안녕하시오!'
-a = len(hello) # 문자열의 길이는 6입니다. Python2에서는 문자열의 바이트 길이를 반환합니다.
-b = len(hello.encode('utf-8')) # 문자열의 바이트 길이는 16
-```
-
-### 인덱스를 통한 접근
-
-다른 프로그래밍 언어들과 마찬가지로 인덱스는 대괄호를 사용해서 표현하며, 인덱스는 0부터 시작합니다.
-
-```python
-a = [1, 2, 3]
-print(a[0]) # 1
-# 내부적으로는 객체의 __getitem__() 메서드를 호출합니다. 따라서,
-print(a.__getitem__(0))
-# 음수 인덱스를 사용하면 맨 마지막 항목부터 셉니다.
-print(a[-1]) # 3
-```
-
-### 인덱스를 통한 항목 값의 변경
-
-튜플, 문자열, 레인지의 경우에는 값을 변경할 수 없는 타입이므로 오류가 발생합니다.
-
-```python
-a = [1, 2, 3]
-a[1] = 4 # [1,4,3]
-a[5] = 5 # Error. 리스트의 범위를 벗어났으므로 오류입니다.
-```
-
-### 항목의 삭제
-
-`del`을 사용해서 항목을 삭제합니다. 튜플, 문자열, 레인지의 경우에는 값을 변경할 수 없는 타입이므로 오류가 발생합니다.
-
-```python
-a = [1, 2, 3]
-del a[1] # [1,3]
-```
-
-### 부분 시퀀스
-
-시작 인덱스와 끝 인덱스를 사용해서 어떤 시퀀스의 부분을 가져올 수 있습니다. 끝 인덱스는 포함되지 않습니다.
-
-```python
-a = [1, 2, 3, 4, 5]
-b = a[0:2] # [1,2]
-c = a[0:5:2] # [1,3,5] => 시작과 끝 인덱스에 덧붙여 증분도 사용할 수 있습니다.
-d = a[:5] # 시작 인덱스를 생략하면 0번 인덱스부터 가져옵니다.
-e = a[2:] # 끝 인덱스가 생략되면 마지막 요소까지 가져옵니다.
-```
-
-### 반전
-
-```python
-reversed(range(5)) 
-```
-
-### 슬라이스 객체 (slice)
-
-`slice()`는 `range()`와 사용법이 같으며, `slice` 타입이 반환됩니다.
-
-- slice(끝값)
-  
-  시작 값이 주어지지 않으면 0부터 시작하며, 끝값은 포함되지 않습니다.
-  
-- slice(시작값, 끝값)
-  
-- slice(시작값, 끝값, 증분)
-  
-
-```python
-a = [1, 2, 3, 4, 5]
-s = slice(0, 2)
-a[s] # [1,2] 대괄호 안에 슬라이스 객체를 넣어서 사용합니다.
-```
-
-### 슬라이스 객체를 이용한 할당
-
-```python
-a = [1, 2, 3, 4, 5]
-a[0:2] = ['a', 'b'] # ['a', 'b', 3, 4, 5]
-```
-
-만약 슬라이스의 범위와 할당할 값의 길이가 서로 다르다면
-
-```python
-a = [1, 2, 3, 4, 5]
-a[0:2] = ['a'] # ['a', 3, 4, 5] => a[0]은 할당되고, a[1]은 사라집니다.
-
-a = [1, 2, 3, 4, 5]
-a[0:2] = ['a', 'b', 'c'] # ['a', 'b', 'c', 3, 4, 5]
-```
-
-## 리스트의 메서드
-
-- append()
-  
-  리스트의 맨 뒤에 아이템을 하나 추가합니다.
-  
-- extend()
-  
-  리스트를 연결해서 확장합니다.
-  
-- insert()
-  
-  특정 인덱스에 아이템을 추가합니다.
-  
-
-```python
-a = [1, 2, 3]
-a.append(4)    # [1,2,3,4]
-a.extend([5, 6]) # [1,2,3,4,5,6]
-a.insert(2, 'a') # [1,2,'a',3,4,5,6]
-```
-
-- pop()
-  
-  마지막 아이템 또는 특정 아이템을 반환하며 리스트에서 제거합니다.
-  
-- remove()
-  
-  특정 값을 삭제합니다. `pop()`이 인덱스를 사용하는 반면 `remove()`는 리스트에서 특정 값을 제거합니다. 만일, 리스트에 같은 값이 여러 개인 경우에는 처음 찾은 값이 제거됩니다.
-  
-
-```python
-a = [1, 2, 3, 4, 5]
-b = a.pop() # b=5 a=[1,2,3,4]
-b= a.pop(2) # b=3 a=[1,2,4]
-a.remove(4) # a=[1,2]
-```
-
-- index()
-  
-  특정 값의 인덱스를 반환합니다.
-  
-- count()
-  
-  특정 값의 갯수를 반환합니다.
-  
-- reverse()
-  
-  아이템의 순서를 반대로 뒤집습니다.
-  
-- sort(reverse=False)
-  
-  아이템을 정렬합니다.
-  
-- sorted()
-  
-  `sort()`와 비슷하지만, 리스트를 수정하지 않고 새로운 리스트를 반환합니다.
-  
-- clear()
-  
-  리스트의 모든 아이템을 삭제합니다.
-  
-- copy()
-  
-  리스트를 복제합니다.
-  
-
-## 리스트 컴프리핸션
-
-리스트 구문 안에 반복문이나 조건문을 사용할 수 있습니다.
-
-이 방식으로 튜플을 만들 때에는 `tuple()`을 사용해야 합니다. 괄호를 사용하면 튜플이 아니라 제너레이터가 만들어집니다.
-
-```python
-a = [i for i in range(5)] # [0,1,2,3,4]
-b = [i * 2 for i in range(5)] # [0,2,4,6,8]
-
-# 반복문 뒤에 조건문을 이어 붙일 수 있습니다.
-c = [i for i in range(5) if i % 2 == 0] # [0,2,4]
-
-# 반복문을 여러 개 사용할 수도 있습니다. 이 때 처리 순서는 뒤에서부터 앞으로 처리됩니다.
-d = [i * J for j in range(2,10) for i in range(1,10)]
-```
-
-## 맵
-
-- map(함수, 리스트)
-  
-  리스트 또는 튜플 등 반복 가능한 객체의 아이템을 지정된 함수로 처리한 다음 새로운 리스트 또는 튜플을 생성할 떄 사용됩니다.
-  
-
-```python
-a = ['1', '2', '3']
-b = list(map(int, a))
-```
-
-## 다차원 리스트
-
-리스트 안에 리스트를 넣으면 다차원 리스트가 됩니다. 튜플도 마찬가지입니다.
-
-```python
-a = [[1,2], [3,4], [5,6]]
-```
-
-다차원 리스트를 복제하려면 `deepcopy()`를 사용해야 합니다.
-
-```python
-import copy
-b = copy.deepcopy(a)
-```
-
-## 문자열 메서드
-
-- replace(바꿀문자열, 새문자열)
-  
-- translate()
-  
-  문자열 내의 문자를 치환합니다.
-  
-  ```python
-  table = str.maketrans('aeiou', 'AEIOU')
-  a = 'i like an apple'.translate(table) # I lIkE An ApplE
-  ```
-  
-- split()
-  
-  공백을 기준으로 문자열을 분리합니다. 구분 문자열을 지정할 수도 있습니다.
-  
-  ```python
-  a = 'apple,orange,mango,banana'.split(',')
-  ```
-  
-- join(리스트)
-  
-  리스트를 결합하여 문자열을 만듭니다.
-  
-  ```python
-  '-'.join(['apple','orange','mango','banana'])
-  ```
-  
-- upper(), lower()
-  
-  대소문자 변환
-  
-- strip(), lstrip(), rstrip()
-  
-  문자열의 왼쪽, 오른쪽, 또는 양쪽의 공백을 제거합니다. 매개변수에 제거할 문자목록 지정할 수도 있습니다.
-  
-  ```python
-  '...hello'.strip('.')
-  ```
-  
-- ljust(길이), rjust(길이), center(길이)
-  
-  정렬
-  
-  ```python
-  'apple'.ljust(10) # 'apple     '
-  ```
-  
-- zfill(길이)
-  
-  지정된 길이 맞춰서 0으로 채웁니다.
-  
-- find(찾을문자열), rfind()
-  
-  주어진 문자열이 처음 나타나는 인덱스를 반환하며, 찾는 문자열이 없으면 -1을 반환합니다.
-  
-- index(), rindex()
-  
-  `find()`와 마찬가지로 찾는 문자열의 인덱스를 반환하지만, 문자열을 찾지 목한 떄에는 오류가 발생됩니다.
-  
-- count(문자열)
-  
-  주어진 문자열의 갯수를 셉니다.
-  
-
-## 형식화 문자열
-
-```python
-name = 'Charlie'
-a = 'Hello, %s.' % name
-
-age = 14
-b = "I'm %d years old." % age
-
-value = 3.3
-c = 'The price is %f dollars.' % value
-c = 'The price is %.2f dollars.' % value # 소수점 이하 자릿수를 지정
-
-d = '%s is %d years old.' % (name, age) # 여러 개일 떄에는 괄호로 묶습니다.
-```
-
-문자열의 `format()` 메서드를 사용하면 더 쉽습니다.
-
-```python
-'Hello, {0}.'.format('Charlie')
-'{1} is {0} years old.'.format(14, 'Charlie')
-
-'{} is {} years old.'.format('Charlie', 14) # 인덱스가 생략되면 순서대로 삽입됩니다.
-
-'{name} is {age} years old.'.format(name='Charlie', age=14) # 숫자 인덱스 대신 이름을 지정할 수도 있습니다.
-
-# Python 3.6이상에서는 변수명을 그대로 사용할 수 있으며, 문자열 앞에 포맷 지시자('f')를 붙여주면 됩니다.
-name = 'Charlie'
-age = 14
-s = f'{name} is {age} years old.'
-```
-
-## 딕셔너리
-
-딕셔너리의 키에 대괄호를 사용해서 아이템에 접근하거나 변경할 수 있습니다.
-
-```python
-a = {'name': 'Charlie', 'age': 14}
-a['name'] # 'Charlie'
-
-a.get('name') # get() 메서드를 사용할 수도 있습니다.
-```
-
-`in` 연산자를 사용해서 딕셔너리에 해당 키가 존재하는지 확인할 수 있습니다.
-
-```python
-a = {'name': 'Charlie', 'age': 14}
-b = 'name' in a # True
-```
-
-키의 갯수를 알고 싶으면 `len()`을 사용합니다.
-
-```python
-len({'name': 'Charlie', 'age': 14}) # 2
-```
-
-키를 제거하려면 `del`을 사용합니다.
-
-```python
-del a['name']
-```
-
-딕셔너리를 복제하려면 `deepcopy()`를 사용해야 합니다.
-
-```python
-import copy
-y = deepcopy(a)
-```
-
-## 딕셔너리의 메서드
-
-- setdefault(키, 값)
-  
-  키에 대한 기본값을 지정합니다. `update()`와 달리 해당 키가 이미 정의되어 있다면 값이 변경되지 않습니다.
-  
-- update(키, 값)
-  
-  키에 대한 값을 변경합니다. 키가 정의되어 있지 않다면 새로운 키가 등록됩니다.
-  
-- pop(키, 기본값)
-  
-  키에 대한 값을 반환하며, 딕셔너리에서는 제거됩니다. 매개변수에 기본값을 주면 해당 키가 없을 때에 그 값을 반환합니다.
-  
-- popitem()
-  
-  마지막 키/값 쌍을 튜플로 반환하고 삭제합니다. Python 3.5 이하에서는 임의의 키/값 쌍을 반환합니다.
-  
-- clear()
-  
-  모든 키/값 쌍을 삭제합니다.
-  
-- get(키)
-  
-- items()
-  
-- keys()
-  
-- values()
-  
-
-```python
-for key, value in {'a':100, 'b':200, 'c':300}.items():
-    print(key, value)
-```
-
-## 멀티 레벨 딕셔너리
-
-딕셔너리 안에 딕셔너리를 넣으면 계층형 데이터 구조를 만들 수 있습니다.
-
-```python
-a = {
-    'charlie': {'name': 'Charlie', 'age': 14},
-    'steve': {'name': 'Steve', 'age': 37},
-    'jane': {'name': 'Jane', 'age': 22}
-}
-```
-
-## 세트
-
-리스트와 달리 순서가 없으므로 대괄호 안에 인덱스를 사용해서 요소에 접근할 수 없습니다.
-
-세트 안에 중첩된 세트를 넣을 수도 없습니다.
-
-세트 안에 어떤 값이 있는지 확인하려면 `in`을 사용합니다.
-
-```python
-a = {'apple', 'orange', 'banana'}
-'orange' in a # True
-```
-
-논리 연산자 또는 set의 메서드를 사용해서 집합 연산을 할 수 있습니다.
-
-```python
-a = {1, 2, 3}
-b = {3, 4, 5, 6}
-
-a | b # 합집합 {1,2,3,4,5,6}
-set.union(a, b)
-a & b # 교집합 {3}
-set.intersection(a, b)
-a - b # 차집합 {1,2}
-set.difference(a, b)
-a ^ b # 대칭 차집합
-set.symmetric_difference(a, b)
-```
-
-- set,union()
-  
-- set,intersection()
-  
-- set,difference()
-  
-- set,symmetric_difference()
-  
-- update(세트)
-  
-  `|=`
-  
-- intersection_update(세트)
-  
-  `&=`
-  
-- difference_update(세트)
-  
-  `-=`
-  
-- symmetric_update(세트)
-  
-  `^=`
-  
-
-비교 연산자를 사용해서 포함 관계를 확인할 수 있습니다.
-
-```python
-{1,2,3} <= {1,2,3,4,5} # 다른 집합의 부분집합인지 여부
-{1,2,3}.issubset({1,2,3,4,5})
-
-{1,2,3} < {1,2,3,4,5} # 다른 집합의 진부분집합인지 여부
-
-{1,2,3} >= {1,2,3,4,5} # 다른 집합의 상위집합인지 여부
-{1,2,3}.issuperset({1,2,3,4,5})
-
-{1,2,3} > {1,2,3,4,5} # 다른 집합의 진상위집합인지 여부
-
-{1,2,3} == {1,2,3,4,5} # 서로 같은지 여부
-{1,2,3} != {1,2,3,4,5}
-
-{1,2,3}.isdisjoint({1,2,3,4,5}) # 서로 겹치는 요소가 없으면 True가 반환됩니다.
-```

doc/04_std_io.md

@@ -0,0 +1,60 @@
+# 표준 입출력
+파이썬에서 프로그램과 사용자 간의 데이터 교환을 위해 사용되는 함수들을 표준 입출력 함수라고 합니다. 즉, 프로그램에서 데이터를 입력받거나 결과를 출력하는 데 사용되는 함수들이죠.
+
+## print() : 표준 출력 함수
+
+화면에 데이터를 출력합니다.
+
+```python
+print(값1, 값2, ..., sep=' ', end='\n')
+```
+* 값1, 값2: 출력할 값들을 콤마(,)로 구분하여 여러 개를 지정할 수 있습니다.
+* sep: 각 값 사이에 삽입할 문자열입니다. 기본값은 공백(' ')입니다.
+* end: 출력 후에 이어붙일 문자열입니다. 기본값은 줄바꿈 문자('\n')입니다.
+
+```python
+print("Hello,", "world!")  # Hello, world!
+print(1, 2, 3, sep=', ')  # 1, 2, 3
+print("Hello", end='')
+print("World!")  # HelloWorld!
+```
+
+## input() : 표준 입력 함수
+
+사용자로부터 입력을 받습니다.
+
+```python
+변수 = input("입력 메시지: ")
+```
+
+```python
+name = input("이름을 입력하세요: ")
+print("안녕하세요,", name, "님!")
+```
+
+```python
+a, b = input().split() # 공백을 기준으로 분리합니다.
+a, b = input().split(',') # 콤마를 기준으로 분리합니다.
+```
+
+입력받은 값을 숫자 형태로 바꾸려면, `int()` 또는 `float()`을 사용해야 합니다.
+
+```python
+a = int(input('A? '))
+b = int(input('B? '))
+
+print(a + a)
+```
+
+또는, `map()`함수를 사용할 수도 있습니다.
+
+```python
+a, b = map(int, input().split())
+```
+
+## 표준 입출력 스트림
+* 표준 입력 스트림 (stdin): 키보드로부터 입력을 받는 스트림입니다. `sys.stdin`을 통해 접근할 수 있습니다.
+* 표준 출력 스트림 (stdout): 화면에 출력하는 스트림입니다. `sys.stdout`을 통해 접근할 수 있습니다.
+* 표준 오류 스트림 (stderr): 오류 메시지를 출력하는 스트림입니다. `sys.stderr`을 통해 접근할 수 있습니다.
+
+표준 입출력은 파일 입출력과 유사한 개념입니다. open() 함수를 사용하여 파일을 열고, read(), write() 등의 메서드를 사용하여 파일에서 데이터를 읽거나 쓰는 것처럼, 표준 입출력도 특정 스트림(stdin, stdout, stderr)을 통해 데이터를 주고받습니다.

doc/05_flow_controls.md

@@ -0,0 +1,224 @@
+# 흐름 제어
+파이썬의 흐름 제어: 조건문과 반복문
+파이썬의 흐름 제어는 프로그램의 실행 순서를 조절하여 다양한 작업을 수행할 수 있도록 해줍니다. 주로 조건문과 반복문을 사용하여 프로그램의 흐름을 제어합니다.
+
+## 조건문
+
+### if, elif, else
+
+* if 문: 특정 조건이 참일 때만 코드 블록을 실행합니다.
+* elif 문: 여러 개의 조건을 검사할 때 사용하며, 앞선 if나 elif 조건이 거짓일 때만 실행됩니다.
+* else 문: 모든 조건이 거짓일 때 실행됩니다.
+
+`if`문의 조건식 뒤에 콜론(`:`)을 붙이고 `if` 블록은 들여쓰기를 합니다.
+
+```python
+if 조건식:
+    실행문
+```
+
+```python
+if 조건식:
+    실행문
+else:
+    실행문
+```
+
+```python
+if 조건식:
+    실행문
+elif 조건식:
+    실행문
+else:
+    실행문
+```
+
+```python
+age = 20
+
+if age >= 18:
+    print("성인입니다.")
+elif age >= 13:
+    print("청소년입니다.")
+else:
+    print("어린이입니다.")
+```
+
+### match case
+
+파이썬 3.10 버전부터 도입된 match-case 문은 if-elif-else 문을 더욱 간결하고 가독성 있게 만들어주는 새로운 패턴 매칭 문법입니다. 다양한 값이나 패턴과 비교하여 코드 블록을 실행할 수 있으며, 특히 데이터 타입에 따른 분기 처리를 효율적으로 수행할 수 있습니다.
+
+```python
+match value:
+    case pattern1:
+        # pattern1에 일치할 때 실행되는 코드
+    case pattern2:
+        # pattern2에 일치할 때 실행되는 코드
+    case _:  # 기본 케이스
+        # 위의 모든 패턴에 일치하지 않을 때 실행되는 코드
+```
+* value: 비교할 값
+* pattern: 패턴 (리터럴, 변수, 가드(guard)를 포함할 수 있음)
+* _: 와일드카드 패턴 (모든 경우에 일치)
+
+```python
+match (n):
+    case 1: return 'One'
+    case 2: return 'Two'
+    case _: return 'Many'
+```
+
+```python
+case "a" | "b" : return "A or B"
+```
+
+```python
+case [time, name] : 
+    return f"{time}, {name}!\n"
+case [time, *names] : 
+    msg = ''
+    for name in names:
+        msg += f"{time}, {name}!\n"
+    return msg
+```
+
+```python
+case [item, amount] if amount < 1000:
+    return amount * 1.2
+case [item, amount] if amount >=1000:
+    return amount * 1.5
+```
+
+```python
+def get_grade(score):
+    match score:
+        case 90 | 100:
+            return "A"
+        case 80 if score >= 85:
+            return "B+"
+        case 80:
+            return "B"
+        case _:
+            return "C 이하"
+```
+
+* 순서: 패턴은 위에서부터 아래로 순차적으로 검사되므로, 일반적으로 더 구체적인 패턴을 먼저 작성해야 합니다.
+* 가드: 가드는 패턴이 일치한 후에 추가적인 조건을 검사하는 역할을 합니다.
+* 와일드카드: 모든 경우에 일치하지만, 너무 남용하면 코드의 가독성이 떨어질 수 있습니다.
+
+## 반복문
+
+### for in
+시퀀스(리스트, 튜플, 문자열 등)의 요소를 순서대로 반복합니다.
+
+```python
+for 변수 in range(횟수):
+    실행문
+```
+
+```python
+fruits = ["apple", "banana", "cherry"]
+for fruit in fruits:
+    print(fruit)
+```
+
+`range`외에 리스트, 튜플, 문자열 등의 시퀀스 타입을 사용해도 됩니다.
+
+```python
+a = [1, 2, 3, 4, 5]
+for i in a:
+    print(i)
+
+for i in range(len(a)):
+    print(a[i])
+
+# 리스트의 인덱스도 필요한 때에는 enumerate()를 사용하면 됩니다.
+for idx, val in enumerate(a):
+    print(idx, val)
+```
+
+#### 리스트 내포
+for 문을 이용하여 간결하게 리스트를 생성하는 방법입니다.
+```python
+numbers = [x**2 for x in range(10)]  # 0부터 9까지의 제곱수 리스트 생성
+```
+
+### while
+특정 조건이 참인 동안 반복합니다.
+
+```python
+while 조건식:
+    실행문
+```
+
+```python
+count = 0
+while count < 5:
+    print(count)
+    count += 1
+```
+
+### 반복문에서의 else
+파이썬의 반복문(for, while)에서 else 문은 일반적인 조건문의 else 문과는 다르게 동작합니다.
+
+for 문에서 모든 요소를 순회했는지 확인하는 데 사용됩니다. 예를 들어, 리스트에서 특정 값을 찾는 경우, 찾지 못하면 else 블록에서 해당 메시지를 출력할 수 있습니다.
+
+while 문에서는 조건이 만족되어 반복이 종료되었는지 확인하는 데 사용됩니다. 예를 들어, 파일에서 특정 데이터를 찾는 경우, 파일의 끝까지 검색했지만 찾지 못했다면 else 블록에서 에러 메시지를 출력할 수 있습니다.
+
+#### 반복문의 else가 실행되는 조건
+* for 문: for 문이 정상적으로 모든 요소를 순회한 후에 실행됩니다. 즉, break 문에 의해 중단되지 않고 모든 반복이 완료되어야 else 블록이 실행됩니다.
+* while 문: while 문의 조건이 거짓이 되어 반복이 자연스럽게 종료될 때 실행됩니다. 마찬가지로, break 문에 의해 중단되지 않아야 합니다.
+
+```python
+numbers = [1, 2, 3, 4, 5]
+for num in numbers:
+    if num == 6:
+        print("숫자 6을 찾았습니다.")
+        break
+else:
+    print("숫자 6을 찾지 못했습니다.")
+```
+
+```python
+i = 0
+while i < 5:
+    print(i)
+    i += 1
+else:
+    print("반복이 끝났습니다.")
+```
+
+> break 문이 실행되면 else 블록은 실행되지 않습니다.
+
+> for 문이나 while 문이 정상적으로 종료될 때만 else 블록이 실행됩니다.
+
+## 그 외
+
+### break
+반복문을 즉시 종료합니다.
+```python
+for i in range(10):
+    if i == 5:
+        break
+    print(i)
+```
+
+### continue
+현재 반복을 건너뛰고 다음 반복으로 이동합니다.
+```python
+for i in range(10):
+    if i % 2 == 0:
+        continue
+    print(i)
+```
+
+### pass
+아무런 동작을 하지 않는 문장으로,
+조건문이나 반복문에서 코드 블록이 필요하지만 아직 구현하지 않았을 때 사용합니다. Python의 들여쓰기 문법 때문에 사용되는 키워드입니다.
+파이썬 3.x부터는 `...`을 사용해도 됩니다.
+
+```python
+for i in range(10):
+    pass # 아무 것도 실행되지 않습니다.
+```
+

doc/05_std_io.md

@@ -1,40 +0,0 @@
-# 표준 입출력
-
-## input()
-
-표준 입력으로부터 한 줄을 입력 받습니다.
-
-```python
-x = input() # 표준 입력으로부터 한 줄을 입력 받습니다.
-y = input('문자열을 입력하시오: ')
-
-a, b = input().split() # 공백을 기준으로 분리합니다.
-a, b = input().split(',') # 콤마를 기준으로 분리합니다.
-```
-
-입력받은 값을 숫자 형태로 바꾸려면, `int()` 또는 `float()`을 사용해야 합니다.
-
-```python
-a = int(input('A? '))
-b = int(input('B? '))
-
-print(a + a)
-```
-
-또는, `map()`함수를 사용할 수도 있습니다.
-
-```python
-a, b = map(int, input().split())
-```
-
-## print()
-
-표준 출력으로 한 줄을 출력합니다.
-
-```python
-print('Hello')
-
-print(1, 2, 3) # 나열된 값이 공백으로 구분되어 출력됩니다.
-print(1, 2, 3, sep=',') # sep으로 구분자를 지정할 수 있습니다. 기본값은 ' '입니다.
-print(1, 2, 3, end='') # end로 줄 끝 문자를 지정할 수 있습니다. 기본값은 '\n'입니다.
-```

doc/06_flow_controls.md

@@ -1,128 +0,0 @@
-# 흐름 제어
-
-## 조건문
-
-### if
-
-`if`문의 조건식 뒤에 콜론(`:`)을 붙이고 `if` 블록은 들여쓰기를 합니다.
-
-```python
-if 조건식:
-    실행문
-```
-
-```python
-if 조건식:
-    실행문
-else:
-    실행문
-```
-
-```python
-if 조건식:
-    실행문
-elif 조건식:
-    실행문
-else:
-    실행문
-```
-### match case
-
-Python 3.10에서 추가된 문법입니다.
-
-```python
-match (n):
-    case 1: return 'One'
-    case 2: return 'Two'
-    case _: return 'Many'
-```
-
-```python
-case "a" | "b" : return "A or B"
-```
-
-```python
-case [time, name] : 
-    return f"{time}, {name}!\n"
-case [time, *names] : 
-    msg = ''
-    for name in names:
-        msg += f"{time}, {name}!\n"
-    return msg
-```
-
-```python
-case [item, amount] if amount < 1000:
-    return amount * 1.2
-case [item, amount] if amount >=1000:
-    return amount * 1.5
-```
-
-## 반복문
-
-### for in
-
-```python
-for 변수 in range(횟수):
-    실행문
-```
-
-`range`외에 리스트, 튜플, 문자열 등의 시퀀스 타입을 사용해도 됩니다.
-
-```python
-a = [1, 2, 3, 4, 5]
-for i in a:
-    print(i)
-
-for i in range(len(a)):
-    print(a[i])
-
-# 리스트의 인덱스도 필요한 때에는 enumerate()를 사용하면 됩니다.
-for idx, val in enumerate(a):
-    print(idx, val)
-```
-
-```python
-for i in a:
-    # 반복적으로 처리.
-else:
-    # 반복문이 정상적으로 종료될 떄 한 번만 수행됩니다.
-    # break 등으로 반복이 종료되면 이 블록은 실행되지 않습니다.
-```
-
-### while
-
-```python
-while 조건식:
-    실행문
-```
-
-```python
-i = 0
-while i <= len(a):
-    print(a[i])
-    i += 1
-```
-
-```python
-while i<10:
-    # ...
-else:
-    # ...
-```
-
-## 그 외
-
-### break
-
-### continue
-
-### pass
-
-써 넣을 실행문이 없을 경우에 사용합니다. Python의 들여쓰기 문법 때문에 사용되는 키워드입니다.
-파이썬 3.x부터는 `...`을 사용해도 됩니다.
-
-```python
-for i in range(10):
-    pass # 아무 것도 실행되지 않습니다.
-```

doc/06_function.md

@@ -0,0 +1,310 @@
+# 함수
+
+파이썬 함수는 특정 작업을 수행하는 코드 블록으로, 코드의 재사용성을 높이고 가독성을 향상시키는 데 중요한 역할을 합니다. 함수를 사용하면 복잡한 문제를 작은 단위의 함수로 나누어 해결할 수 있으며, 코드의 유지보수성도 높일 수 있습니다.
+
+## 함수의 특징
+* 재사용성: 한 번 정의된 함수를 여러 번 호출하여 사용할 수 있습니다.
+* 모듈화: 복잡한 프로그램을 작은 함수 단위로 나누어 관리하기 쉽습니다.
+* 가독성: 코드의 가독성을 높여 유지보수를 용이하게 합니다.
+
+## 함수의 종류
+* 일반 함수: 특정 작업을 수행하는 일반적인 함수
+* 람다 함수: 한 줄로 간결하게 표현되는 익명 함수
+* 재귀 함수: 자기 자신을 호출하는 함수
+
+## 함수의 정의
+```python
+def 함수명(매개변수1, 매개변수2, ...):
+    # 함수의 실행 코드
+    return 반환값
+```
+* def 키워드: 함수를 정의하는 시작
+* 함수명: 함수를 호출할 때 사용하는 이름
+* 매개변수: 함수에 전달되는 값을 받는 변수
+* return: 함수의 결과값을 반환합니다. return 문이 없으면 None을 반환합니다.
+
+## 함수의 호출
+```python
+함수명(인수1, 인수2, ...)
+```
+* 함수명: 정의된 함수의 이름
+* 인수: 함수에 전달되는 실제 값
+
+```python
+def greet(name):
+    print(f"안녕하세요, {name}님!")
+
+greet("홍길동")  # 안녕하세요, 홍길동님! 출력
+```
+
+## 매개변수
+
+### 기본값을 가지는 매개변수
+```python
+def greet(name, greeting="안녕하세요"):
+    print(f"{greeting}, {name}님!")
+
+greet("홍길동")  # 안녕하세요, 홍길동님! 출력
+greet("이순신", "반갑습니다")  # 반갑습니다, 이순신님! 출력
+```
+### 가변 인수
+```python
+def sum_numbers(*args):
+    total = 0
+    for num in args:
+        total += num
+    return total
+
+result = sum_numbers(1, 2, 3, 4, 5)
+print(result)  # 15 출력
+```
+
+### 키워드 인수
+```python
+def print_info(name, age):
+    print(f"이름: {name}, 나이: {age}")
+
+print_info(age=30, name="홍길동")
+```
+### 함수의 반환값
+return 문을 사용하여 함수의 결과값을 반환합니다.
+
+여러 값을 반환하려면 튜플을 사용합니다.
+
+
+```python
+def sum(arg1, arg2 = 0, *var_args):
+    s = arg1 + arg2
+    for i in var_args:
+        s += i
+    return s
+
+sum(1, 2)
+sum(arg1=1, arg2=2)
+sum(1)
+sum(1, 2, 3, 4, 5)
+```
+
+```python
+# "/" 앞에 정의된 매개변수는 키워드 매개변수로 사용될 수 없습니다.
+def func(arg1, arg2, "/", arg3):
+    return
+```
+
+```python
+# 임의 길이 매개변수
+def func(arg1, arg2, *varargs):
+    for v in varargs:
+        print(v)
+    return
+```
+
+```python
+# 임의 길이 디워드 매개변수
+def func(arg1, arg2, **kwargs):
+    for k,v in kwargs.items():
+        print ("{}:{}".format(k,v))
+    return
+```
+
+## 람다 함수
+람다 함수는 파이썬에서 한 줄로 간결하게 정의할 수 있는 익명 함수입니다. 이름이 없기 때문에 람다 함수라고 불리며, 주로 간단한 연산이나 조건문을 표현할 때 사용됩니다.
+
+특히, map, filter, sorted 등의 함수와 함께 사용하여 데이터를 처리하는 작업을 효율적으로 수행할 수 있습니다. 
+
+```python
+lambda 매개변수1, 매개변수2, ... : 표현식
+```
+* lambda: 람다 함수를 정의하는 키워드입니다.
+* 매개변수: 함수에 전달되는 값을 받는 변수입니다. 여러 개의 매개변수를 콤마로 구분하여 사용할 수 있습니다.
+* 표현식: 함수가 반환할 값을 계산하는 표현식입니다. return 키워드를 생략하고 표현식만 작성합니다.
+
+```python
+square = lambda x: x**2
+print(square(5))  # 25 출력
+```
+
+```python
+# 두 수를 더하는 람다 함수
+add = lambda x, y: x + y
+result = add(3, 4)
+print(result)  # 출력: 7
+```
+
+```python
+# 리스트의 각 요소를 제곱하는 람다 함수
+numbers = [1, 2, 3, 4]
+squares = list(map(lambda x: x**2, numbers))
+print(squares)  # 출력: [1, 4, 9, 16]
+```
+
+## 변수의 범위
+* 전역 변수 : 함수 또는 블록의 외부에서 선언된 변수로써, 모든 곳에서 참조할 수 있습니다.
+* 지역 변수 : 함수 또는 블록의 내부에서 선언된 변수로써, 함수 또는 블록의 내부에서만 유효합니다.
+* nonlocal 변수 : 중첩된 함수에서 사용됩니다.
+
+동일한 이름으로 선언된 전역 변수와 로컬 변수가 있을 때에는 로컬 변수가 우선합니다.
+
+함수 내에서 전역 변수를 수정하려면 global 키워드를 사용해야 합니다. 하지만 전역 변수의 사용은 가급적 지양하고, 함수의 인자와 반환값을 통해 데이터를 주고받는 것이 좋습니다.
+
+```python
+x = 10
+
+def change_global():
+    global x
+    x = 20
+```
+
+```python
+def func1():
+    a = 1
+    def func2():
+        nonlocal a
+        a += 1
+        print(a)
+    print(a)
+```
+
+`globals()`와 `locals()` 함수를 사용해서 선언된 변수를 조회할 수 있습니다.
+
+```python
+print(globals())
+```
+
+## 어노테이션
+함수 어노테이션은 파이썬 함수의 매개변수와 반환값의 형태를 명시하는 기능입니다. 이는 코드의 가독성을 높이고, 개발자가 함수의 사용법을 더 쉽게 이해하도록 도와줍니다. 또한, 정적 타입 체커와 같은 도구를 사용하여 코드의 오류를 미리 발견하는 데 도움이 됩니다.
+
+```python
+def 함수명(매개변수1: 타입, 매개변수2: 타입, ...) -> 반환값의 타입:
+    # 함수의 본문
+```
+* 매개변수: 타입: 각 매개변수의 예상되는 타입을 지정합니다.
+* -> 반환값의 타입: 함수가 반환할 값의 예상되는 타입을 지정합니다.
+
+```python
+def my_function_1(a: int, b: int):
+    c = a + b
+    return c
+
+def my_function_2(a: int, b: int) -> int:
+    c = a + b
+    return c
+
+def my_function_3(a: "A number", b: "Another number"):
+    c = a + b
+    return c
+
+print(my_function_1.__annotations__)
+```
+
+### 어노테이션의 종류
+* 기본 타입: int, float, str, bool 등
+* 컨테이너 타입: list, tuple, dict 등
+* 사용자 정의 타입: 클래스
+* None: 반환값이 없음을 나타냄
+* Any: 모든 타입 허용 (타입 검사를 생략하고 싶을 때 사용)
+
+## 빌트인 함수
+파이썬은 다양한 작업을 수행하기 위한 내장 함수를 풍부하게 제공합니다. 빌트인 함수는 별도의 모듈을 임포트하지 않고도 바로 사용할 수 있어 편리합니다. 이러한 함수들은 파이썬 프로그래밍의 기본적인 구성 요소이며, 효율적인 코드 작성에 필수적입니다.
+
+### 데이터 형 변환
+* bool : 값을 불리언 값(True 또는 False)으로 변환
+* bytearray
+* bytes
+* complex
+* dict
+* float : 문자열 등을 실수로 변환
+* frozenset
+* int : 문자열 등을 정수로 변환
+* list
+* set
+* str : 다른 자료형을 문자열로 변환
+* tuple
+
+* ascii
+* bin
+* chr, unichr
+* hex
+* oct
+* ord
+### 수학 연산
+* abs : 절댓값
+* divmod
+* max : 최댓값
+* min : 최솟값
+* pow
+* round : 반올림
+* sum : 리스트나 튜플 요소의 합
+### 반복
+* enumerate : 시퀀스(문자열, 리스트, 튜플 등)의 인덱스와 값을 함께 반복
+* iter, aiter
+* next, anext
+* range : 숫자의 연속된 시퀀스 생성
+### 시퀀스
+* filter
+* len : 시퀀스(문자열, 리스트, 튜플 등)의 길이를 반환
+* map
+* reversed : 시퀀스의 요소 순서를 반대로 반환
+* slice
+* sorted : 시퀀스를 정렬하여 새로운 리스트를 반환
+### 입출력
+* input
+* open
+* print : 화면에 출력
+### 객체
+* classmethod
+* dir : 객체가 가지고 있는 속성과 메서드를 리스트로 반환
+* delattr
+* getattr
+* hasattr
+* setattr
+* property
+* staticmethod
+* super
+* issubclass
+### 그 외
+* all
+* any
+* breakpoint
+* callable
+* compile
+* eval
+* exec
+* format
+* globals
+* hash
+* help : 함수나 모듈에 대한 도움말을 제공
+* id : 객체의 고유 식별자
+* isinstance : 인스턴스 확인
+* locals
+* memoryview
+* object
+* repr
+* type : 자료형 확인
+* vars
+* zip
+* \_\_import__
+
+
+
+```python
+# 데이터 형 변환
+number_str = "123"
+number = int(number_str)  # number는 정수 123
+print(type(number))  # <class 'int'>
+
+# 수학 연산
+numbers = [1, 2, 3, 4, 5]
+print(sum(numbers))  # 15
+
+# 반복
+for i, value in enumerate(numbers):
+    print(i, value)
+
+# 문자열 처리
+text = "Hello, World!"
+print(len(text))  # 13
+print(text.upper())  # HELLO, WORLD!
+```
+
+

doc/07_function.md

@@ -1,34 +0,0 @@
-# 함수
-
-```python
-def function_name(parameter):
-    "This is a Doc string."
-    print("Hello")
-    return parameter + 1
-
-function_name(3)
-```
-
-## 매개변수
-* 필수 (위치) 매개변수
-* 키워드 매개변수
-* 디폴트 매개변수
-* 임의 길이 매개변수
-* 임의 길이 키워드 매개변수
-
-```python
-def sum(arg1, arg2 = 0, *var_args):
-    s = arg1 + arg2
-    for i in var_args:
-        s += i
-    return s
-
-sum(1, 2)
-sum(arg1=1, arg2=2)
-sum(1)
-sum(1, 2, 3, 4, 5)
-```
-## 람다 함수
-```python
-sum = lambda a, b : a + b
-```

doc/07_module.md

@@ -0,0 +1,121 @@
+# 모듈
+
+모듈은 파이썬 코드를 논리적으로 분리하고 재사용하기 위한 기본 단위입니다. 하나의 파이썬 파일(.py)이 하나의 모듈에 해당하며, 함수, 변수, 클래스 등을 정의하여 다른 파이썬 파일에서 불러와 사용할 수 있습니다.
+
+* 코드 재사용: 한 번 작성한 코드를 여러 곳에서 반복적으로 사용할 수 있습니다.
+* 코드 관리: 복잡한 프로그램을 작은 단위로 나누어 관리하기 쉽습니다.
+* 명명 공간 관리: 다른 모듈과의 변수 이름 충돌을 방지할 수 있습니다.
+* 코드 공유: 다른 사람들과 코드를 공유하거나 오픈 소스 프로젝트에 참여할 수 있습니다.
+
+### 모듈 파일 생성
+새로운 파이썬 파일을 만들고, 원하는 함수, 변수, 클래스 등을 정의합니다.
+파일 이름이 모듈 이름이 됩니다.
+
+### 모듈 가져오기
+```python
+import 모듈명
+from 모듈명 import 함수명, 변수명 # 특정 함수나 변수만 가져오려는 경우
+```
+
+모듈 파일은 먼저 현재 디렉토리에서 찾습니다. 모듈을 찾지 못한 경우에는 `PYTHONPATH` 환경 변수에 지정된 경로에서 찾고, 그 다음에는 `/usr/local/lib/python/` 경로에서 찾습니다.
+
+
+```python
+# module1.py
+def greet(name):
+    print("Hello,", name)
+
+# main.py
+import module1
+module1.greet("Alice")
+```
+
+```python
+import math
+
+from math import sqrt, sin
+
+from math import *
+
+import math as x
+```
+
+## 내장 모듈과 외부 모듈
+* 내장 모듈: 파이썬 설치 시 기본적으로 제공되는 모듈입니다. math, random, os 등이 있습니다.
+* 외부 모듈: 별도로 설치해야 하는 모듈입니다. pip 명령어를 사용하여 설치합니다. 예를 들어, numpy, pandas, matplotlib 등이 있습니다.
+
+### 내장 모듈
+* os : 운영 체제와 상호 작용하는 기능 제공 (파일 시스템, 환경 변수 등)
+    - `os.getcwd()`: 현재 작업 디렉토리 반환
+    - `os.listdir()`: 디렉토리 내 파일 목록 반환
+* string : 문자열 처리 관련 함수
+* re : 정규 표현식을 사용하여 문자열 처리
+    - `re.search()`: 문자열에서 패턴 검색
+    - `re.sub()`: 문자열에서 일치하는 부분을 다른 문자열로 치환
+* math : 수학 관련 함수 제공
+    - `math.sqrt(x)`: x의 제곱근 반환
+    - `math.sin(x)`: x의 사인 값 반환
+* cmath
+* datetime : 날짜와 시간 관련 기능 제공
+    - `datetime.datetime.now()`: 현재 날짜와 시간 가져오기
+    - `datetime.timedelta`: 두 날짜 간의 차이 계산
+* time : 시간 관련 함수
+* gc
+* asyncio
+* collections : 다양한 컨테이너 자료형 제공 (Counter, defaultdict 등)
+* functools
+* operator
+* pickle : 파이썬 객체 직렬화
+* socket
+* sqlite3
+* statistics
+* typing
+* venv
+* json : JSON 데이터를 파싱하고 생성하는 기능 제공
+    - `json.loads()`: JSON 문자열을 파이썬 객체로 변환
+    - `json.dumps()`: 파이썬 객체를 JSON 문자열로 변환
+* csv: CSV 파일 처리
+* wsgiref
+* unittest
+* random : 난수 생성 함수 제공
+    - `random.randint(a, b)`: a 이상 b 이하의 임의의 정수 반환
+    - `random.random()`: 0.0 이상 1.0 미만의 임의의 실수 반환
+* sys : 파이썬 인터프리터와 관련된 변수와 함수 제공
+    - `sys.argv`: 명령줄 인수 리스트
+    - `sys.exit()`: 프로그램 종료
+* requests
+* itertools : 반복 가능한 객체를 위한 유용한 함수 제공 (combinations, permutations 등)
+* urllib : 웹 페이지를 다운로드하고 URL을 처리하는 기능 제공
+
+
+## 패키지
+여러 개의 관련된 모듈을 하나의 디렉토리에 모아 놓은 것을 패키지라고 합니다. 패키지는 점(.)으로 구분된 계층 구조를 가질 수 있습니다.
+
+```
+mypackage/
+    __init__.py
+    module1.py
+    module2.py
+```
+
+```python
+# main.py
+import mypackage.module1
+mypackage.module1.greet("Alice")
+```
+위 예시에서 mypackage는 패키지 이름이고, module1은 모듈 이름입니다.
+
+### 패키지 생성
+원하는 디렉토리에 `__init__.py` 파일을 생성해서 패키지를 정의합니다. `__init__.py` 파일은 이 디렉토리가 패키지임을 나타내는 역할을 합니다.
+
+해당 디렉토리에 모듈 파일들을 추가합니다.
+
+```python
+# phone/__init__.py
+from Pots import Pots
+from Isdn import Isdn
+from G3 import G3
+```
+```python
+import phone
+```

doc/08_01_file_io.md

@@ -0,0 +1,80 @@
+# 파일 입출력
+
+파이썬에서 파일 입출력은 프로그램 실행 중 데이터를 파일 시스템에 저장하거나 파일에서 데이터를 읽어오는 것을 의미합니다. 이를 통해 프로그램의 데이터를 영구히 저장하고 필요할 때 다시 사용할 수 있습니다.
+
+## 파일 열기
+
+파이썬에서는 open() 함수를 사용하여 파일을 엽니다.
+
+```python
+f = open("파일 이름", "모드")
+```
+* 파일 이름: 열고자 하는 파일의 경로를 지정합니다.
+* 모드: 파일을 어떤 방식으로 열 것인지 지정합니다.
+    - r: 읽기 모드 (기본값)
+    - w: 쓰기 모드 (파일이 존재하면 내용을 덮어씀)
+    - a: 추가 모드 (파일 끝에 내용을 추가)
+    - x: 파일이 존재하지 않을 때만 생성
+    - b: 바이너리 모드 (이진 데이터 처리)
+    - t: 텍스트 모드 (기본값)
+
+ 
+> - r+: 읽기와 쓰기를 동시에 수행합니다.
+> - a+: 파일 끝에 내용을 추가하고 읽기 작업도 수행합니다.
+> - rb, wb, ab: 바이너리 모드로 파일을 열 때 사용합니다.
+
+
+## 파일 읽기
+```python
+f = open("data.txt", "r")
+contents = f.read()  # 파일 전체 내용 읽기
+lines = f.readlines()  # 파일을 줄 단위로 읽어 리스트에 저장
+```
+
+## 파일 쓰기
+```python
+f = open("output.txt", "w")
+f.write("Hello, world!\n")
+```
+
+## 파일 닫기
+```python
+f.close()
+```
+
+## with 문을 사용한 안전한 파일 처리
+with 문을 사용하면 파일 객체를 생성하고, 블록이 끝날 때 자동으로 파일을 닫아줍니다. 따라서 파일을 닫는 것을 잊어버릴 염려가 없습니다.
+```python
+with open("data.txt", "r") as f:
+    contents = f.read()
+```
+> 파일을 열 때는 항상 close() 메서드를 사용하여 파일을 닫아주는 것이 좋습니다.
+> 파일을 쓰기 모드로 열면 기존 내용이 모두 삭제될 수 있습니다.
+> 바이너리 파일을 다룰 때는 b 옵션을 사용해야 합니다.
+
+```python
+# 파일 읽기
+with open("input.txt", "r") as f:
+    for line in f:
+        print(line, end="")
+
+# 파일 쓰기
+with open("output.txt", "w") as f:
+    f.write("Hello, world!\n")
+    f.write("This is a new line.")
+```
+
+
+# 파일 메서드
+* file.read()
+* file.readline()
+* file.readlines()
+* file.next()
+* file.seek()
+* file.tell()
+* file.truncate()
+* file.write()
+* file.writelines()
+* file.flush()
+* file.close()
+

doc/08_02_os_module.md

@@ -0,0 +1,59 @@
+# OS 모듈
+os 모듈은 파이썬에서 운영 체제와 직접 상호 작용할 수 있도록 해주는 표준 라이브러리입니다. 파일, 디렉토리, 프로세스 등 운영 체제의 다양한 기능을 파이썬 코드에서 활용할 수 있도록 지원합니다.
+
+## 파일 시스템 조작
+파일 생성, 삭제, 이동, 복사, 이름 변경 등
+* `os.rename(src, dst)`: 파일 또는 디렉토리의 이름을 변경합니다.
+* `os.remove(path)`, `os.unlink(path)`: 파일을 삭제합니다.
+* `os.link(src, dst)`
+
+## 디렉토리 관리
+디렉토리 생성, 삭제, 목록 조회 등
+* `os.getcwd()`: 현재 작업 디렉토리의 경로를 반환합니다.
+* `os.chdir(path)`: 작업 디렉토리를 변경합니다.
+* `os.listdir(path)`, `os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])`, `os.path.walk(path, visit, arg)`: 지정된 디렉토리 내의 파일과 디렉토리 목록을 반환합니다.
+* `os.mkdir(path)`: 새로운 디렉토리를 생성합니다.
+* `os.makedirs(path)`: 중첩된 디렉토리를 생성합니다.
+* `os.rmdir(path)`, `os.removedirs(path)`, `shutil.rmtree(path)`: 빈 디렉토리를 삭제합니다.
+
+## 파일 정보
+파일 크기, 수정 시간, 권한 등을 조회
+* `os.path.abspath(path)`, `os.path.realpath(path)`
+* `os.path.dirname(path)`
+* `os.path.exists(path)`: 파일 또는 디렉토리가 존재하는지 확인합니다.
+* `os.path.isfile(path)`: 주어진 경로가 파일인지 확인합니다.
+* `os.path.isdir(path)`: 주어진 경로가 디렉토리인지 확인합니다.
+* `os.chmod(path, mode)`
+* `os.chown(path, uid, gid)`
+* `os.path.getatime(path)`, `	os.path.getmtime(path)`, `	os.path.getctime(path)`
+* `os.path.getsize(path)`
+* `os.path.samefile(path1, path2)`
+
+## 환경 변수
+시스템 환경 변수에 접근
+* `os.environ`: 환경 변수를 딕셔너리 형태로 제공합니다.
+## 프로세스 관리 
+프로세스 실행, 종료 등
+
+```python
+import os
+
+# 현재 작업 디렉토리 출력
+print(os.getcwd())
+
+# 새로운 디렉토리 생성
+os.mkdir("new_directory")
+
+# 파일 목록 출력
+for file in os.listdir():
+    print(file)
+
+# 파일 복사 (shutil 모듈 활용)
+import shutil
+shutil.copy("source.txt", "destination.txt")
+```
+
+## 주의할 점
+* 파일 시스템 조작: 파일 시스템을 조작할 때는 주의해야 합니다. 잘못된 사용으로 데이터가 손실될 수 있습니다.
+* 경로 구분: 운영 체제에 따라 경로 구분자가 다릅니다. (윈도우: \, 리눅스/맥: /)
+* 권한: 파일 시스템에 접근하기 위한 충분한 권한이 필요합니다.

doc/09_exception.md

@@ -0,0 +1,65 @@
+# 예외 처리
+예외란 프로그램 실행 중 예상치 못한 상황이나 오류를 의미합니다. 예를 들어, 존재하지 않는 파일을 열려고 하거나, 0으로 나누는 연산을 시도하는 경우 등이 있습니다. 파이썬에서는 이러한 예외 상황을 처리하기 위해 try-except 블록을 사용합니다.
+
+* 프로그램 안정성: 예상치 못한 상황에 대해 미리 대비하여 프로그램이 비정상적으로 종료되는 것을 방지합니다.
+* 오류 메시지 제공: 사용자에게 발생한 문제에 대한 정보를 제공하여 문제 해결을 돕습니다.
+* 코드 가독성 향상: try-except 블록을 사용하면 코드의 흐름을 명확하게 나타낼 수 있습니다.
+
+## 예외의 종류
+* ZeroDivisionError: 0으로 나누는 경우
+* TypeError: 자료형이 맞지 않을 때
+* ValueError: 올바르지 않은 값이 사용될 때
+* IndexError: 리스트 인덱스가 범위를 벗어났을 때
+* FileNotFoundError: 파일이 존재하지 않을 때
+
+그 외 다양한 예외가 있습니다.
+
+## try except
+```python
+try:
+    # 예외가 발생할 가능성이 있는 코드
+except 예외 종류:
+    # 예외가 발생했을 때 실행할 코드
+```
+* try 블록: 예외가 발생할 가능성이 있는 코드를 작성합니다.
+* except 블록: try 블록에서 예외가 발생하면 실행됩니다. 예외 종류 부분에 특정 예외를 지정하거나 모든 예외를 처리할 수 있습니다.
+
+```python
+try:
+    num1 = int(input("첫 번째 숫자를 입력하세요: "))
+    num2 = int(input("두 번째 숫자를 입력하세요: "))
+    result = num1 / num2
+    print(result)
+except ZeroDivisionError:
+    print("0으로 나눌 수 없습니다.")
+except ValueError:
+    print("숫자를 입력하세요.")
+```
+
+## try except finally
+finally 블록은 예외 발생 여부와 상관없이 항상 실행되는 코드 블록입니다. 주로 파일 닫기, 자원 해제 등의 작업을 수행합니다.
+```python
+try:
+    f = open("data.txt", "r")
+    # 파일 읽기 작업
+except FileNotFoundError:
+    print("파일이 없습니다.")
+finally:
+    f.close()  # 파일 닫기
+```
+
+## 예외 발생시키기
+raise 키워드를 사용하여 직접 예외를 발생시킬 수 있습니다.
+
+```python
+raise ValueError("잘못된 값입니다.")
+```
+
+## 사용자 정의 예외
+```python
+class MyError(Exception):
+    pass
+
+raise MyError("사용자 정의 예외 발생")
+```
+

doc/10_00_object_oriented_programming.md

@@ -0,0 +1,41 @@
+# 객체 지향 프로그래밍
+**객체 지향 프로그래밍(OOP)**은 실제 세계의 개념을 프로그램 안에 모델링하여 복잡한 문제를 해결하는 데 효과적인 프로그래밍 패러다임입니다. 파이썬은 객체 지향 프로그래밍을 강력하게 지원하는 언어 중 하나입니다.
+
+* 객체(Object): 실제 세계의 사물이나 개념을 프로그램 안에서 표현한 것입니다. 각 객체는 고유한 속성(attribute)과 행동(method)을 가지고 있습니다.
+* 클래스(Class): 객체를 생성하기 위한 템플릿입니다. 클래스는 객체가 가질 속성과 행동을 정의합니다.
+* 인스턴스(Instance): 클래스를 바탕으로 생성된 실제 객체를 의미합니다.
+
+## 클래스 정의
+```python
+class MyClass:
+    # 클래스 변수
+    class_variable = "This is a class variable"
+
+    # 생성자
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    # 파괴자
+    def __del__(self):
+        ...
+
+    # 메소드
+    def greet(self):
+        print(f"안녕하세요, 저는 {self.name}입니다.")
+```
+* `__init__` 메소드: 객체가 생성될 때 자동으로 호출되는 메소드로, 인스턴스 변수를 초기화하는 데 사용됩니다.
+* `self`: 메소드 내에서 자신을 가리키는 참조 변수입니다.
+
+## 객체 생성 및 사용
+```python
+# 객체 생성
+person = MyClass("홍길동", 30)
+
+# 속성 접근
+print(person.name)  # 홍길동
+
+# 메소드 호출
+person.greet()  # 안녕하세요, 저는 홍길동입니다.
+```
+

doc/10_01_attribute.md

@@ -0,0 +1,51 @@
+# 클래스 변수와 인스턴스 변수
+
+## 클래스 변수 (Class Variable)
+
+클래스 자체에 속하는 변수로, 클래스의 모든 인스턴스가 공유하는 값을 가집니다. 즉, 클래스가 메모리에 로딩될 때 단 한 번 생성되며, 모든 인스턴스가 동일한 클래스 변수를 참조합니다.
+
+클래스에 속한 모든 객체가 공통적으로 사용하는 값을 저장할 때 사용합니다. 예를 들어, 모든 학생 객체가 속한 학교 이름과 같은 정보를 저장할 수 있습니다.
+
+클래스 내부에서 일반 변수처럼 선언하지만, 주로 클래스 이름과 함께 사용합니다.
+
+```python
+class Student:
+    school_name = "BIT"  # 클래스 변수
+
+    def __init__(self, name, age):
+        self.name = name  # 인스턴스 변수
+        self.age = age  # 인스턴스 변수
+```
+
+## 인스턴스 변수 (Instance Variable)
+
+각 인스턴스(객체)마다 고유하게 가지는 변수입니다. 즉, 각 인스턴스는 자신만의 인스턴스 변수를 가지고 있으며, 다른 인스턴스의 인스턴스 변수 값에 영향을 받지 않습니다.
+
+각 객체의 고유한 상태를 나타내는 값을 저장할 때 사용합니다. 예를 들어, 각 학생의 이름과 나이를 저장할 수 있습니다.
+
+생성자 `__init__` 메소드 내에서 `self.변수명` 형태로 선언합니다.
+
+```python
+class Car:
+    # 클래스 변수: 모든 자동차의 바퀴 개수
+    wheels = 4
+
+    def __init__(self, color, max_speed):
+        # 인스턴스 변수: 각 자동차의 고유한 속성
+        self.color = color
+        self.max_speed = max_speed
+
+car1 = Car("빨간색", 200)
+car2 = Car("파란색", 180)
+
+print(car1.wheels)  # 4 (모든 자동차의 바퀴 개수는 4)
+print(car2.color)  # 파란색
+```
+
+## 접근제한자
+파이썬은 다른 언어들처럼 엄격한 접근 제한자(public, private, protected)를 제공하지 않습니다. 하지만 파이썬은 언더바(`_`)를 사용하여 변수나 메서드의 접근성을 제한하는 관습을 가지고 있습니다. 이러한 관습을 통해 정보 은닉을 구현하고, 객체 지향 프로그래밍의 중요한 원칙인 캡슐화를 실현할 수 있습니다.
+
+* public: 변수나 메서드 이름 앞에 아무런 언더바도 붙이지 않습니다. 어디에서든 자유롭게 접근할 수 있습니다.
+* protected: 변수나 메서드 이름 앞에 하나의 언더바(`_`)를 붙입니다. 같은 패키지 내의 클래스나 자식 클래스에서 접근할 수 있습니다.
+* private: 변수나 메서드 이름 앞에 두 개의 언더바(`__`)를 붙입니다. 클래스 내부에서만 접근할 수 있으며, 외부에서는 `_클래스명.__변수명`과 같은 형식으로 접근할 수 있지만 권장하지 않습니다.
+

doc/10_02_methos.md

@@ -0,0 +1,58 @@
+# 메서드
+파이썬 클래스 내에는 인스턴스 메서드, 클래스 메서드, 정적 메서드라는 다양한 종류의 메서드가 존재합니다. 각 메서드는 다른 용도와 특징을 가지고 있으며, 어떤 상황에서 어떤 메서드를 사용해야 할지 이해하는 것이 중요합니다.
+
+* 인스턴스 메서드: 개별 객체의 상태를 변경하거나, 객체 고유의 기능을 구현할 때 사용합니다.
+* 클래스 메서드: 클래스 레벨에서 공통적으로 사용되는 기능을 구현하거나, 클래스 변수에 접근할 때 사용합니다.
+* 정적 메서드: 클래스와 인스턴스 상태와 무관한 일반적인 기능을 구현할 때 사용합니다.
+
+## 인스턴스 메서드 (Instance Method)
+객체(인스턴스)의 속성에 접근하고 변경할 수 있는 메서드입니다.
+
+항상 `self`를 첫 번째 인자로 받아 자신을 가리킵니다.
+
+개별 객체의 상태를 변경하거나, 객체의 고유한 기능을 구현할 때 사용합니다.
+
+```python
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def greet(self):
+        print(f"안녕하세요, 저는 {self.name}입니다.")
+```
+위 예시에서 `greet` 메서드는 인스턴스 메서드이며, `self.name`에 접근하여 개별 객체의 이름을 출력합니다.
+
+## 클래스 메서드 (Class Method)
+클래스 자체에 속하며, 클래스 변수에 접근하거나 클래스 레벨의 작업을 수행하는 메서드입니다.
+
+`cls`를 첫 번째 인자로 받아 클래스 자신을 가리킵니다.
+
+클래스 메서드임을 나타내기 위해 `@classmethod` 데코레이터를 사용합니다.
+
+클래스 레벨에서 공통적으로 사용되는 기능을 구현하거나, 서로 다른 클래스 간의 관계를 정의할 때 사용합니다.
+
+```python
+class MyClass:
+    x = 10  # 클래스 변수
+
+    @classmethod
+    def class_method(cls):
+        print(cls.x)
+```
+
+## 정적 메서드 (Static Method)
+클래스와 인스턴스 상태에 의존하지 않는, 일반 함수처럼 동작하는 메서드입니다.
+
+특별한 인자를 받지 않습니다.
+
+정적 메서드임을 나타내기 위해 `@staticmethod` 데코레이터를 사용합니다.
+
+클래스와 관련된 유틸리티 함수를 정의할 때 사용합니다.
+
+```python
+class MyClass:
+    @staticmethod
+    def greet(name):
+        print(f"Hello, {name}!")
+```

doc/10_03_property.md

@@ -0,0 +1,40 @@
+# 프로퍼티
+getter와 setter는 객체 지향 프로그래밍에서 객체의 데이터를 안전하게 관리하고, 코드의 유연성을 높이는 데 중요한 역할을 합니다. 특히, 대규모 프로젝트에서 여러 개발자가 함께 작업할 때 데이터 일관성을 유지하고 예기치 않은 오류를 방지하는 데 큰 도움이 됩니다.
+
+파이썬의 `@property` 데코레이터는 객체의 속성을 마치 메서드처럼 접근하고 설정할 수 있도록 해주는 강력한 기능입니다. 이를 통해 우리는 객체의 내부 상태를 좀 더 안전하게 관리하고, 코드의 가독성을 높일 수 있습니다.
+
+`@property` 데코레이터를 사용하여 getter와 setter를 정의합니다.
+
+* getter 메서드 자동 생성: `@property` 데코레이터가 붙은 메서드는 자동으로 getter 메서드가 됩니다. 즉, 객체의 속성 값을 가져올 때 마치 변수에 접근하듯이 사용할 수 있습니다.
+* setter 메서드 생성: `@변수명.setter` 데코레이터를 사용하여 setter 메서드를 정의할 수 있습니다. setter 메서드는 속성 값을 설정할 때 호출됩니다.
+* 속성 값에 대한 유효성 검사: setter 메서드에서 값의 유효성을 검사하여 부적절한 값이 설정되는 것을 방지할 수 있습니다.
+
+```python
+class Person:
+    def __init__(self, name, age):
+        self._name = name
+        self._age = age
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if not isinstance(value, str):
+            raise TypeError("Name must be a string")
+        self._name = value
+
+    @property
+    def age(self):
+        return self._age
+
+    @age.setter
+    def age(self, value):
+        if not isinstance(value, int):
+            raise TypeError("Age must be an integer")
+        if value < 0:
+            raise ValueError("Age cannot be negative")
+        self._age = value
+```
+위 예시에서 _name과 _age는 private 변수로, 외부에서 직접 접근할 수 없습니다. 대신 name과 age라는 property를 사용하여 값을 읽고 설정합니다. `@property` 데코레이터는 getter 메서드를, `@변수명.setter` 데코레이터는 setter 메서드를 정의하는 데 사용됩니다.

doc/10_04_inheritance.md

@@ -0,0 +1,133 @@
+# 상속 (Inheritance)
+상속은 기존 클래스(부모 클래스)의 속성과 메소드를 그대로 물려받아 새로운 클래스(자식 클래스)를 생성하는 것을 의미합니다. 이를 통해 코드 재사용성을 높이고, 계층적인 클래스 구조를 만들 수 있습니다.
+
+```python
+class Animal:
+    def __init__(self, name):
+        self.name = name
+
+    def sound(self):
+        print("소리를 냅니다.")
+
+class Dog(Animal):
+    def sound(self):
+        print("멍멍")
+
+class Cat(Animal):
+    def sound(self):
+        print("야옹")
+```
+위 예시에서 Dog 클래스와 Cat 클래스는 Animal 클래스를 상속받아 name 속성과 sound 메서드를 물려받습니다. 동물의 공통적인 특징은 Animal 클래스에서 정의하고, 각 동물의 특징은 자식 클래스에서 오버라이딩하여 구현합니다.
+
+## 다형성 (Polymorphism)
+다형성은 같은 메시지에 대해 서로 다른 객체가 다르게 반응하는 것을 의미합니다. 상속을 통해 구현되며, 하나의 변수나 참조로 다양한 타입의 객체를 가리킬 수 있게 해줍니다.
+
+## 추상 클래스 (Abstract Class)
+추상 클래스는 일부 또는 모든 메서드가 구현되지 않은 클래스입니다. 즉, 추상 클래스는 자체적으로 객체를 생성할 수 없으며, 다른 클래스의 상위 클래스로 사용되어 하위 클래스에서 구체적인 기능을 구현하도록 강제합니다. 추상 클래스는 공통적인 속성과 메서드를 정의하여 코드의 재사용성을 높이고, 클래스 간의 관계를 명확하게 나타내는 데 사용됩니다.
+
+* 추상 메서드: 구현이 생략된 메서드로, 자식 클래스에서 반드시 구현해야 합니다. abc 모듈의 `@abstractmethod` 데코레이터를 사용하여 선언합니다.
+* 일반 메서드: 구체적인 구현이 있는 메서드로, 자식 클래스에서 오버라이딩하거나 그대로 사용할 수 있습니다.
+
+```python
+from abc import ABC, abstractmethod
+
+class Animal(ABC):
+    @abstractmethod
+    def sound(self):
+        pass
+
+class Dog(Animal):
+    def sound(self):
+        print("멍멍")
+
+class Cat(Animal):
+    def sound(self):
+        print("야옹")
+```
+위 예시에서 Animal 클래스는 sound 메서드를 추상 메서드로 선언하여, Dog 클래스와 Cat 클래스에서 반드시 sound 메서드를 구현하도록 강제합니다.
+
+## 인터페이스
+인터페이스는 클래스가 갖춰야 할 메서드의 집합을 정의한 것입니다. 즉, 인터페이스는 클래스가 어떤 기능을 제공해야 하는지에 대한 규약을 정의하는 역할을 합니다. 파이썬에서는 인터페이스라는 개념이 명시적으로 존재하지 않지만, 추상 클래스를 이용하여 인터페이스와 유사하게 사용할 수 있습니다.
+
+```python
+class IPerson():
+    @abstractmethod
+    def hello(self):
+        pass
+
+class Person(IPerson):
+    def hello(self):
+        print("Hello")
+```
+
+## 다중 상속
+다중 상속이란, 하나의 클래스가 두 개 이상의 부모 클래스로부터 속성과 메서드를 상속받는 것을 의미합니다. 이를 통해 더욱 복잡하고 다양한 기능을 가진 클래스를 만들 수 있습니다.
+### 장점
+* 코드 재사용성 증가: 여러 클래스에 공통적으로 사용되는 기능을 하나의 부모 클래스에 정의하고, 이를 여러 자식 클래스에서 상속받아 사용할 수 있습니다.
+* 유연성 향상: 다양한 특성을 가진 클래스를 조합하여 새로운 클래스를 만들 수 있습니다.
+### 단점
+* 복잡성 증가: 클래스 간의 관계가 복잡해져 코드를 이해하기 어려울 수 있습니다.
+* 모호성: 여러 부모 클래스에 동일한 이름의 메서드가 있을 경우, 어떤 메서드가 호출될지 명확하지 않을 수 있습니다. 이를 해결하기 위해 MRO(Method Resolution Order)가 사용됩니다.
+* 다이아몬드 문제: 여러 상속 경로를 통해 같은 조상 클래스에 도달할 경우 발생하는 문제입니다.
+
+```python
+class Flyer:
+    def fly(self):
+        print("날아다닙니다.")
+
+class Swimmer:
+    def swim(self):
+        print("헤엄칩니다.")
+
+class FlyingFish(Flyer, Swimmer):
+    pass
+
+fish = FlyingFish()
+fish.fly()  # 날아다닙니다.
+fish.swim()  # 헤엄칩니다.
+```
+위 예시에서 FlyingFish 클래스는 Flyer와 Swimmer 두 클래스를 상속받아 날 수 있고 헤엄칠 수 있는 기능을 모두 가지게 됩니다.
+
+### MRO(Method Resolution Order)
+MRO(Method Resolution Order)는 파이썬에서 다중 상속 시 메서드 호출 순서를 결정하는 규칙입니다. 즉, 어떤 클래스의 메서드를 호출할 때, 파이썬 인터프리터가 어떤 순서로 상위 클래스들을 검색하여 메서드를 찾는지를 정의합니다.
+
+#### 파이썬의 MRO 알고리즘: C3 알고리즘
+파이썬은 C3 알고리즘이라는 복잡한 알고리즘을 사용하여 MRO를 계산합니다. 이 알고리즘은 다음과 같은 조건을 만족하는 MRO를 생성합니다.
+
+* 선형화: MRO는 선형 순서를 가지며, 각 클래스는 한 번만 나타납니다.
+* 상속 관계 유지: 부모 클래스는 항상 자식 클래스보다 먼저 나타납니다.
+* 깊이 우선 검색: 왼쪽에서 오른쪽으로 깊이 우선 검색을 수행합니다.
+
+```python
+class A: pass
+class B(A): pass
+class C(A): pass
+class D(B, C): pass
+
+print(D.__mro__)
+# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
+```
+D 클래스의 MRO는 D -> B -> C -> A -> object 순으로 구성됩니다. 즉, D 클래스의 메서드를 호출할 때, 먼저 D 클래스 내에서 메서드를 찾고, 없으면 B 클래스, C 클래스, A 클래스 순으로 검색합니다.
+
+super() 함수는 MRO를 따라 다음에 검색해야 할 클래스의 메서드를 호출하는 데 사용됩니다.
+
+```python
+class A:
+    def foo(self):
+        print("A")
+
+class B(A):
+    def foo(self):
+        print("B")
+        super().foo()
+
+class C(B):
+    def foo(self):
+        print("C")
+        super().foo()
+
+c = C()
+c.foo()  # 출력: C B A
+```
+위 예시에서 super() 함수는 현재 클래스의 MRO에서 다음 클래스의 메서드를 호출합니다.
+

doc/10_05_method_overriding.md

@@ -0,0 +1,76 @@
+# 메소드 오버로딩(Method Overloading)과 오버라이딩(Method Overriding)
+
+* 메소드 오버라이딩: 부모 클래스의 메소드를 자식 클래스에서 재정의하는 것을 의미합니다. 상속 관계에서 사용됩니다.
+* 메소드 오버로딩: 동일한 클래스 내에서 같은 이름의 메소드를 여러 개 정의하는 것을 의미합니다. 메소드 오버로딩의 핵심은 매개변수의 차이입니다. 매개변수의 개수, 타입, 순서가 달라야 합니다.
+
+## 메소드 오버로딩
+메소드 오버로딩은 동일한 이름의 메소드를 여러 개 정의하여, 전달되는 매개변수의 개수나 타입에 따라 다른 동작을 수행하도록 하는 것을 의미합니다. 즉, 같은 이름의 메소드지만 매개변수의 조합이 다르면 다른 기능을 수행할 수 있도록 하는 것입니다.
+
+* 코드 가독성 향상: 동일한 작업을 수행하는 메소드라도 입력값에 따라 다른 방식으로 처리해야 할 때, 메소드 오버로딩을 사용하면 코드가 더 직관적이고 이해하기 쉽습니다.
+* 유연성 증가: 다양한 입력값에 대해 동일한 메소드 이름을 사용하여 코드를 간결하게 작성할 수 있습니다.
+* 코드 재사용: 기존 메소드를 확장하여 새로운 기능을 추가할 수 있습니다.
+* 같은 이름: 오버로딩되는 메소드는 반드시 같은 이름을 가져야 합니다.
+* 다른 매개변수: 매개변수의 개수, 타입, 순서가 달라야 합니다.
+* 반환값: 반환값의 타입은 달라도 상관없습니다.
+
+아래 예시에서 add 메소드는 매개변수의 개수와 타입에 따라 다른 동작을 수행합니다.
+```python
+public class Calculator {
+    public int add(int a, int b) {
+        return a + b;
+    }
+
+    public double add(double a, double b) {
+        return a + b;
+    }
+
+    public int add(int a, int b, int c) {
+        return a + b + c;
+    }
+}
+```
+
+
+## 메소드 오버라이딩
+메소드 오버라이딩은 부모 클래스에서 상속받은 메서드를 자식 클래스에서 재정의하는 것을 의미합니다. 즉, 부모 클래스의 메서드와 동일한 이름을 가진 메서드를 자식 클래스에서 다시 작성하여, 자식 클래스에 맞는 기능을 수행하도록 하는 것입니다.
+
+* 다형성 구현: 같은 메시지에 대해 서로 다른 객체가 다르게 반응하도록 만들 수 있습니다.
+* 상속 관계에서 특정 기능 재정의: 부모 클래스의 기능을 유지하면서 자식 클래스에 맞게 기능을 확장하거나 변경할 수 있습니다.
+* 코드 재사용: 부모 클래스에서 공통적인 기능을 구현하고, 자식 클래스에서 필요한 부분만 재정의하여 코드 재사용성을 높일 수 있습니다.
+
+* 상속 관계: 메서드 오버라이딩은 상속 관계에서만 가능합니다.
+* 같은 메서드 이름: 부모 클래스와 자식 클래스에서 메서드 이름이 같아야 합니다.
+* 메서드 서명 일치: 오버라이딩하는 메서드의 매개변수 개수와 타입이 부모 클래스의 메서드와 일치해야 합니다.
+* return 값: 오버라이딩된 메서드의 반환 값의 타입이 부모 클래스의 메서드와 일치하거나 호환되어야 합니다.
+* 다른 기능: 메서드의 내용이 달라져야 합니다.
+
+
+```python
+class Animal:
+    def sound(self):
+        print("동물의 소리")
+
+class Dog(Animal):
+    def sound(self):
+        print("멍멍")
+
+class Cat(Animal):
+    def sound(self):
+        print("야옹")
+
+dog = Dog()
+cat = Cat()
+dog.sound()  # 멍멍
+cat.sound()  # 야옹
+```
+위 예시에서 Animal 클래스는 sound 메서드를 가지고 있고, Dog 클래스와 Cat 클래스는 이 메서드를 오버라이딩하여 각각 다른 소리를 내도록 구현했습니다.
+
+## super()
+자식 클래스에서 부모 클래스의 메서드를 호출하고 싶을 때 super() 함수를 사용합니다.
+
+```python
+class ChildClass(ParentClass):
+    def some_method(self, arg):
+        super().some_method(arg)  # 부모 클래스의 some_method 호출
+        # 추가적인 작업
+```

doc/10_06_magic_method.md

@@ -0,0 +1,40 @@
+# 매직 메서드
+매직 메서드는 파이썬에서 `__` (더블 언더스코어)로 시작하고 끝나는 특별한 메서드입니다. 이러한 메서드들은 파이썬 인터프리터가 객체에 대한 특정 연산을 수행할 때 자동으로 호출되어, 우리가 원하는 방식으로 객체를 동작하게 만들 수 있도록 해줍니다.
+
+* 사용자 정의 클래스를 내장 자료형처럼 사용: 리스트, 딕셔너리처럼 자연스러운 연산을 수행할 수 있도록 합니다.
+* 연산자 오버로딩: +, -, * 등의 연산자를 우리가 정의한 클래스에 맞게 재정의할 수 있습니다.
+* 객체의 표현 방식 커스터마이징: print() 함수에서 객체를 출력할 때 어떤 형태로 보여줄지 정의할 수 있습니다.
+
+## 주요 메서드
+* `__init__`	: 객체 생성 시 호출되는 생성자 메서드입니다.
+* `__del__`	: 객체가 메모리에서 삭제되기 직전에 자동으로 호출되는 소멸자 메서드입니다.
+* `__str__`	: 객체를 문자열로 변환할 때 호출되어, 사용자에게 보여줄 문자열을 반환합니다.
+* `__repr__`	: 객체의 공식적인 문자열 표현을 반환합니다. 개발자가 디버깅이나 로그를 위해 사용합니다.
+* `__len__`	: 객체의 길이를 반환합니다. (len() 함수 호출 시 내부적으로 호출)
+* `__getitem__`	: 객체의 요소를 인덱싱하여 접근할 때 호출됩니다. (리스트, 딕셔너리처럼)
+* `__setitem__`	: 객체의 요소를 할당할 때 호출됩니다.
+* `__delitem__`	: 객체의 요소를 삭제할 때 호출됩니다.
+* `__add__`	: 더하기 연산자(+)를 사용할 때 호출됩니다.
+* `__sub__`	: 빼기 연산자(-)를 사용할 때 호출됩니다.
+* `__mul__`	: 곱하기 연산자(*)를 사용할 때 호출됩니다.
+* `__eq__`	: 두 객체가 같은지 비교할 때 호출됩니다.
+* `__ne__`	: 두 객체가 다른지 비교할 때 호출됩니다.
+
+
+```python
+class Vector:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def __repr__(self):
+        return f'Vector({self.x}, {self.y})'
+
+    # __add__ 메서드를 통해 벡터의 덧셈을 정의했습니다.
+    def __add__(self, other):
+        return Vector(self.x + other.x, self.y + other.y)
+
+v1 = Vector(2, 3)
+v2 = Vector(1, 2)
+print(v1 + v2)  # Vector(3, 5)
+```

doc/10_07_metaclass.md

@@ -0,0 +1,64 @@
+# 메타클래스
+메타클래스는 파이썬에서 클래스를 생성하는 데 사용되는 클래스입니다. 즉, 클래스의 클래스라고 할 수 있습니다. 일반적인 클래스가 객체를 생성하는 틀이라면, 메타클래스는 그러한 클래스 자체를 생성하는 틀이라고 생각하면 됩니다.
+
+* 클래스 생성 과정 제어: 클래스가 생성되는 시점에 특정 작업을 수행하거나, 클래스의 속성을 동적으로 변경할 수 있습니다.
+* 클래스 레벨의 로깅: 클래스 생성 시 로그를 남기거나, 프로파일링 정보를 수집할 수 있습니다.
+* 싱글톤 패턴 구현: 특정 클래스의 인스턴스가 단 하나만 존재하도록 제한할 수 있습니다.
+* 데코레이터를 클래스 레벨로 확장: 클래스 전체에 적용되는 데코레이터를 만들 수 있습니다.
+
+```python
+class Meta(type):
+    def __new__(cls, name, bases, namespace, **kwargs):
+        print(f"Creating class: {name}")
+        return super().__new__(cls, name, bases, namespace, **kwargs)
+
+class MyClass(metaclass=Meta):
+    pass
+
+# MyClass 생성 시 Meta.__new__ 메서드가 호출됨
+```
+위 예시에서 Meta는 메타클래스이고, MyClass는 Meta 메타클래스를 사용하여 생성된 클래스입니다. `__new__` 메서드는 새로운 클래스가 생성될 때 호출되며, 클래스 생성 과정에 개입하여 추가적인 작업을 수행할 수 있습니다.
+
+### 메타클래스의 주요 메서드
+
+* `__new__`: 새로운 인스턴스를 생성합니다. 클래스를 생성할 때 호출됩니다.
+* `__init__`: 생성된 인스턴스를 초기화합니다. 클래스가 생성된 후 호출됩니다.
+* `__call__`: 클래스를 함수처럼 호출할 때 실행됩니다.
+
+## 싱글턴 패턴의 구현
+싱글턴 패턴은 하나의 클래스에 대해 오직 하나의 인스턴스만 생성하고, 이 인스턴스에 대한 전역적인 접근점을 제공하는 디자인 패턴입니다. 즉, 싱글톤 클래스는 프로그램 전체에서 단 한 번만 생성되고, 그 인스턴스를 여러 곳에서 공유하여 사용할 수 있습니다.
+
+* 전역 상태 관리: 프로그램 전체에서 공유해야 하는 상태를 관리하는 데 유용합니다. 예를 들어, 로그 파일, 설정 정보 등을 관리하는 클래스를 싱글톤으로 만들 수 있습니다.
+* 자원 공유: 단 하나의 인스턴스만 사용하기 때문에 자원 낭비를 줄이고, 자원 공유를 효율적으로 할 수 있습니다.
+* 모듈 간 통신: 서로 다른 모듈 간에 데이터를 주고받을 때, 싱글톤을 통해 중앙 집중식으로 관리할 수 있습니다.
+
+```python
+class Singleton:
+    __instance = None
+
+    def __new__(cls):
+        if cls.__instance is None:
+            cls.__instance = super().__new__(cls)
+        return cls.__instance
+```
+* `__new__` 메서드: 클래스의 인스턴스를 생성하는 메서드입니다.
+* `__instance` 클래스 변수: 생성된 인스턴스를 저장합니다.
+* 처음 인스턴스를 생성할 때 `__instance`에 저장하고, 이후에는 이미 생성된 인스턴스를 반환합니다.
+
+## 상속 제한
+파이썬에서 클래스를 상속 불가능하게 만드는 가장 일반적인 방법은 metaclass를 사용하는 것입니다. metaclass는 클래스를 생성하는 클래스로, 클래스 생성 과정에 개입하여 다양한 기능을 구현할 수 있습니다.
+
+```python
+class NonInheritableMeta(type):
+    def __new__(cls, name, bases, namespace, **kwargs):
+        if bases:
+            raise TypeError("이 클래스는 상속될 수 없습니다.")
+        return super().__new__(cls, name, bases, namespace, **kwargs)
+
+class BaseClass(metaclass=NonInheritableMeta):
+    pass
+
+class DerivedClass(BaseClass):  # TypeError 발생
+    pass
+```
+위 코드에서 `NonInheritableMeta`는 상속을 불가능하게 만드는 metaclass입니다. `__new__` 메서드에서 `bases`가 비어있지 않으면 (즉, 상속을 시도하면) `TypeError`를 발생시켜 상속을 막습니다.

doc/10_08_reflection.md

@@ -0,0 +1,46 @@
+# 리플렉션
+
+**리플렉션(Reflection)**이란 실행 중인 프로그램이 자기 자신이나 다른 객체의 구조, 속성, 메서드 등을 동적으로 조사하고 조작하는 것을 의미합니다. 파이썬은 동적 언어이기 때문에 런타임 시에 객체의 정보에 접근하고 변경하는 것이 가능하며, 이를 통해 매우 유연하고 강력한 프로그래밍을 할 수 있습니다.
+
+## 파이썬에서 리플렉션을 사용하는 방법
+* type() 함수: 객체의 타입을 확인합니다.
+* isinstance() 함수: 객체가 특정 클래스의 인스턴스인지 확인합니다.
+* dir() 함수: 객체가 가지고 있는 속성과 메서드의 목록을 반환합니다.
+* getattr() 함수: 객체의 속성에 접근합니다.
+* setattr() 함수: 객체의 속성 값을 설정합니다.
+* hasattr() 함수: 객체가 특정 속성을 가지고 있는지 확인합니다.
+* delattr() 함수: 객체의 속성을 삭제합니다.
+* inspect 모듈: 클래스, 함수, 모듈 등에 대한 상세한 정보를 제공합니다.
+
+```python
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+person = Person("Alice", 30)
+
+# 객체의 타입 확인
+print(type(person))  # <class '__main__.Person'>
+
+# 객체가 가지고 있는 속성과 메서드 확인
+print(dir(person))
+
+# 속성 값 가져오기
+print(person.name)
+
+# 속성 값 변경하기
+setattr(person, 'age', 31)
+print(person.age)
+
+# 새로운 속성 추가
+person.city = 'Seoul'
+print(person.city)
+```
+
+## 리플렉션의 활용
+* 데이터 직렬화/역직렬화: 객체를 JSON이나 XML 형식으로 변환하거나, 이러한 형식의 데이터를 다시 객체로 변환할 때 사용됩니다.
+* ORM (Object-Relational Mapping): 데이터베이스 테이블과 객체를 매핑할 때 사용됩니다.
+* 플러그인 시스템: 다양한 플러그인을 동적으로 로드하고 실행할 때 사용됩니다.
+* 메타 프로그래밍: 코드를 생성하거나 수정하는 프로그램을 작성할 때 사용됩니다.
+

doc/10_09_enum.md

@@ -0,0 +1,29 @@
+# Enum
+
+Enum은 파이썬에서 특정 값을 나타내는 이름을 정의하여 코드의 가독성을 높이고, 실수로 잘못된 값을 사용하는 것을 방지하는 데 사용되는 자료형입니다. 쉽게 말해, 일련의 관련된 이름들을 상수처럼 정의하는 것이라고 할 수 있습니다.
+
+* 코드 가독성 향상: 숫자나 문자열 상수 대신 의미 있는 이름을 사용하여 코드를 더욱 명확하게 만들 수 있습니다.
+* 오류 방지: 허용된 값의 범위를 명확히 정의하여 잘못된 값이 입력되는 것을 방지할 수 있습니다.
+* 타입 안전성: Enum 멤버는 일반적인 값과 다르게 취급되어, 예기치 않은 값이 할당되는 것을 막을 수 있습니다.
+* 자동 완성 기능: IDE에서 Enum 멤버를 자동 완성 기능을 통해 쉽게 찾아볼 수 있습니다.
+
+```python
+from enum import Enum
+
+class Color(Enum):
+    RED = 1
+    GREEN = 2
+    BLUE = 3
+
+color = Color.RED
+print(color)  # 출력: Color.RED
+print(color.value)  # 출력: 1
+```
+위 예시에서 Color라는 Enum을 정의하고, RED, GREEN, BLUE라는 멤버를 각각 1, 2, 3 값과 연결했습니다. 이후 color 변수에 Color.RED를 할당하여 사용할 수 있습니다.
+
+* 멤버 접근: Enum의 멤버는 마치 클래스의 속성처럼 접근할 수 있습니다.
+* 값: 각 멤버는 고유한 값을 가지며, 이 값은 정수, 문자열 등 다양한 타입이 될 수 있습니다.
+* 비교: Enum 멤버는 == 연산자를 사용하여 비교할 수 있습니다.
+* 반복: for 문을 사용하여 Enum 멤버를 순회할 수 있습니다.
+* 멤버의 속성: name 속성을 통해 멤버의 이름을, value 속성을 통해 값을 얻을 수 있습니다.
+

doc/10_10_inner_class.md

@@ -0,0 +1,28 @@
+# 내부 클래스
+내부 클래스는 다른 클래스 내부에 정의되는 클래스를 의미합니다. 마치 함수가 다른 함수 내부에 정의될 수 있듯이, 클래스도 다른 클래스 내부에 정의될 수 있습니다. 내부 클래스는 외부 클래스와 긴밀하게 연결되어 있으며, 외부 클래스의 인스턴스에 종속적인 경우가 많습니다.
+
+* 코드의 모듈화: 관련된 클래스들을 하나의 외부 클래스 안에 묶어서 코드의 가독성을 높이고, 유지보수를 쉽게 만들 수 있습니다.
+* 데이터 은닉: 외부 클래스의 내부 구현을 숨기고, 특정 기능에 대한 접근을 제한할 수 있습니다.
+* 객체 연결: 외부 클래스의 인스턴스에 종속적인 객체를 만들어, 두 객체 간의 관계를 명확하게 나타낼 수 있습니다.
+
+```python
+class Outer:
+    class Inner:
+        def __init__(self, data):
+            self.data = data
+
+    def __init__(self):
+        self.inner_obj = self.Inner(42)
+
+outer_obj = Outer()
+inner_obj = outer_obj.inner_obj
+print(inner_obj.data)  # 출력: 42
+```
+
+## 내부 클래스의 종류
+* 인스턴스 내부 클래스: 외부 클래스의 인스턴스 메서드 내부에 정의되는 클래스입니다. 외부 클래스의 인스턴스에 종속적이며, 외부 클래스의 인스턴스 변수에 접근할 수 있습니다.
+* 정적 내부 클래스: 외부 클래스의 외부에 정의되며, 외부 클래스의 인스턴스와 독립적으로 사용될 수 있습니다.
+* 지역 내부 클래스: 외부 클래스의 메서드 내부에 정의되며, 해당 메서드의 지역 범위 내에서만 사용될 수 있습니다.
+
+## 익명 클래스
+

doc/17_functional_programming.md

@@ -0,0 +1,69 @@
+# 함수형 프로그래밍(Functional Programming)
+함수형 프로그래밍은 데이터를 처리하는 것을 수학적 함수의 계산으로 취급하고, 상태와 가변 데이터를 멀리하는 프로그래밍 패러다임입니다. 즉, 함수를 하나의 값으로 취급하고, 함수의 입력값에 따라 항상 같은 출력값을 내는 순수 함수를 지향합니다.
+
+## 함수형 프로그래밍의 핵심 개념
+* 순수 함수:
+ - 함수 외부의 상태를 변경하지 않습니다.
+ - 같은 입력값에 대해 항상 같은 출력값을 반환합니다.
+ - 부수 효과가 없습니다.
+* 불변성: 데이터를 변경하는 대신 새로운 데이터를 생성합니다.
+* 고차 함수: 함수를 인자로 받거나 함수를 반환하는 함수입니다.
+* 일급 시민: 함수를 변수에 할당하고, 다른 함수의 인자로 전달하고, 반환값으로 사용할 수 있습니다.
+
+## 함수형 프로그래밍의 장점
+* 코드의 가독성 향상: 순수 함수를 사용하여 코드를 간결하고 명확하게 작성할 수 있습니다.
+* 테스트 용이성: 순수 함수는 입력값에 대한 출력값이 항상 일정하기 때문에 테스트하기 쉽습니다.
+* 병렬 처리: 순수 함수는 부수 효과가 없기 때문에 병렬 처리에 적합합니다.
+* 재사용성: 잘 정의된 함수를 재사용하여 코드를 효율적으로 작성할 수 있습니다.
+
+## 함수형 프로그래밍과 연관된 함수
+### map
+주어진 함수를 반복 가능한 객체(리스트, 튜플 등)의 모든 요소에 적용하여 새로운 이터레이터를 반환합니다.
+```python
+map(function, iterable)
+```
+
+```python
+numbers = [1, 2, 3, 4, 5]
+squared = list(map(lambda x: x**2, numbers))  # [1, 4, 9, 16, 25]
+```
+위 예시에서 map 함수는 각 숫자를 제곱하는 람다 함수를 numbers 리스트의 모든 요소에 적용하여 새로운 리스트 squared를 생성합니다.
+
+### filter
+주어진 함수를 사용하여 반복 가능한 객체의 요소를 필터링합니다. 함수가 True를 반환하는 요소만 새로운 이터레이터에 포함됩니다.
+```python
+filter(function, iterable)
+```
+```python
+numbers = [1, 2, 3, 4, 5]
+even_numbers = list(filter(lambda x: x % 2 == 0, numbers))  # [2, 4]
+```
+위 예시에서 filter 함수는 numbers 리스트에서 짝수만 필터링하여 새로운 리스트 even_numbers를 생성합니다.
+
+### reduce
+시퀀스의 요소들을 누적적으로 처리하여 단일 값을 반환합니다. functools 모듈에서 제공됩니다.
+```python
+functools.reduce(function, iterable, initializer=None)
+```
+```python
+from functools import reduce
+numbers = [1, 2, 3, 4]
+product = reduce(lambda x, y: x * y, numbers)  # 1 * 2 * 3 * 4 = 24
+```
+
+> map, filter 함수는 파이썬 2와 3에서 동작 방식이 약간 다릅니다. 파이썬 3에서는 결과가 바로 리스트로 반환되지 않고 이터레이터를 반환하므로, 리스트로 변환하여 사용해야 합니다.
+
+### 람다 함수와의 조합
+map, filter 함수는 람다 함수와 함께 자주 사용됩니다. 람다 함수는 간결하게 함수를 정의할 수 있기 때문에 이러한 고차 함수와의 조합이 매우 효율적입니다.
+
+```python
+numbers = [1, 2, 3, 4, 5]
+
+# 숫자를 제곱하는 함수
+def square(x):
+    return x * x
+
+# map 함수를 사용하여 각 숫자를 제곱
+squared_numbers = list(map(square, numbers))
+print(squared_numbers)  # [1, 4, 9, 16, 25]
+```

doc/19_thread.md

@@ -0,0 +1 @@
+# 멀티스레드

doc/20_00_network.md

@@ -0,0 +1,194 @@
+# 네트워크
+파이썬은 다양한 네트워크 통신 모듈을 제공하여, 웹 서버 구축, 클라이언트 개발, 데이터 전송 등 다양한 네트워크 관련 작업을 수행할 수 있도록 지원합니다.
+
+- socket
+
+    가장 기본적인 네트워크 통신 모듈입니다.
+    TCP/IP 프로토콜을 직접 사용하여 소켓을 생성하고 데이터를 주고받을 수 있습니다.
+    저수준 통신을 구현하기 위한 유연성을 제공하지만, 직접 소켓을 관리해야 하는 번거로움이 있습니다
+
+- urllib
+
+    URL을 다루는 모듈로, 웹 페이지를 다운로드하거나 웹 서버에 데이터를 전송하는 기능을 제공합니다.
+    requests 모듈보다 기능이 제한적이지만, 표준 라이브러리에 포함되어 있어 별도의 설치 없이 사용할 수 있습니다.
+
+- requests
+
+    HTTP 요청을 간편하게 보내고 응답을 받을 수 있는 모듈입니다.
+    웹 API를 호출하거나 웹 페이지를 스크래핑하는 등 다양한 작업에 사용됩니다.
+    사용법이 간단하여 초보자도 쉽게 사용할 수 있습니다.
+
+- asyncio
+
+    비동기 I/O를 지원하는 모듈로, 많은 수의 연결을 동시에 처리해야 할 때 유용합니다.
+    코루틴을 사용하여 비동기 프로그래밍을 구현할 수 있습니다.
+    웹 서버, 채팅 서버 등 대규모 네트워크 애플리케이션 개발에 적합합니다.
+
+- aiohttp
+
+    asyncio 기반의 HTTP 클라이언트/서버 라이브러리입니다.
+    비동기 방식으로 HTTP 요청을 보내고 응답을 받을 수 있습니다.
+    웹 크롤링, REST API 개발 등에 사용됩니다.
+
+- Twisted
+
+    이벤트 기반 네트워킹 프레임워크로, 대규모 네트워크 서비스 개발에 사용됩니다.
+    다양한 프로토콜을 지원하며, 확장성이 뛰어납니다.
+
+## socket
+socket 모듈은 파이썬에서 네트워크 통신을 구현하기 위한 가장 기본적인 모듈입니다. TCP/IP 프로토콜을 직접 다루면서, 클라이언트와 서버 간의 데이터 송수신을 가능하게 합니다.
+
+* 소켓 생성: 다양한 프로토콜(TCP, UDP 등)과 주소 체계(IPv4, IPv6)를 사용하여 소켓을 생성할 수 있습니다.
+* 소켓 바인딩: 생성된 소켓을 특정 IP 주소와 포트에 바인딩합니다.
+* 소켓 연결: 서버 소켓은 클라이언트의 연결 요청을 수락하고, 클라이언트 소켓은 서버에 연결합니다.
+* 데이터 송수신: 소켓을 통해 데이터를 주고받습니다.
+
+### 소켓 프로그래밍의 기본 단계
+1. 소켓 생성: `socket.socket()` 함수를 사용하여 소켓 객체를 생성합니다.
+2. 소켓 바인딩: 서버의 경우 `bind()` 메서드를 사용하여 IP 주소와 포트를 지정합니다.
+3. 리스닝: 서버의 경우 `listen()` 메서드를 사용하여 클라이언트의 연결 요청을 대기합니다.
+4. 접속 수락: 서버의 경우 `accept()` 메서드를 사용하여 클라이언트의 연결을 수락합니다.
+5. 데이터 송수신: `send()` 메서드로 데이터를 보내고, `recv()` 메서드로 데이터를 받습니다.
+6. 소켓 닫기: `close()` 메서드를 사용하여 소켓을 닫습니다.
+
+```python
+# 소켓 서버
+import socket
+
+HOST = '127.0.0.1'  # Standard loopback interface address (localhost)
+PORT = 65432        # Port to listen on (non-privileged ports are > 1023)
+
+with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+    s.bind((HOST, PORT))
+    s.listen()
+    conn, addr = s.accept()
+    with conn:
+        print('Connected by', addr)
+        while True:
+            data = conn.recv(1024)
+            if not data:
+                break
+            conn.sendall(data)
+```
+
+```python
+# 소켓 클라이언트
+import socket
+
+HOST = '127.0.0.1'  # The server's hostname or IP address
+PORT = 65432        # The port used by the server
+
+with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+    s.connect((HOST, PORT))
+    s.sendall(b'Hello, world')
+    data = s.recv(1024)
+
+print('Received', repr(data))
+```
+
+* socket.socket(family, type): 소켓 객체를 생성합니다.
+* family: AF_INET(IPv4), AF_INET6(IPv6) 등
+* type: SOCK_STREAM(TCP), SOCK_DGRAM(UDP) 등
+* bind(address): 소켓을 특정 주소와 포트에 바인딩합니다.
+* listen(backlog): 연결 요청 대기열의 크기를 설정합니다.
+* accept(): 클라이언트의 연결 요청을 수락합니다.
+* connect(address): 서버에 연결합니다.
+* sendall(data): 모든 데이터를 전송합니다.
+* recv(bufsize): 최대 bufsize 바이트의 데이터를 수신합니다.
+* close(): 소켓을 닫습니다.
+
+socket 모듈은 네트워크 프로그래밍의 기본을 제공하지만, 직접 소켓을 관리해야 하므로 복잡한 부분이 많습니다. 실제 개발에서는 requests, aiohttp 등 더 상위 레벨의 라이브러리를 사용하여 간편하게 네트워크 통신을 수행하는 경우가 많습니다.
+
+## urllib
+urllib 모듈은 파이썬에서 웹 페이지를 다운로드하거나 웹 서버에 데이터를 전송하는 등 웹 관련 작업을 수행하는 데 사용됩니다. 특히, 웹 페이지를 스크래핑하거나 API를 호출하여 데이터를 가져올 때 많이 사용됩니다.
+
+* 웹 페이지 다운로드: urlopen() 함수를 사용하여 웹 페이지의 내용을 가져올 수 있습니다.
+* URL 파싱: urlparse 모듈을 사용하여 URL을 구성 요소별로 분해할 수 있습니다.
+* HTTP 요청: request 모듈을 사용하여 다양한 HTTP 메서드(GET, POST 등)를 지원하는 요청을 보낼 수 있습니다.
+* 쿠키 처리: cookielib 모듈을 사용하여 쿠키를 관리할 수 있습니다.
+
+```python
+import urllib.request
+
+# URL 지정
+url = 'https://www.example.com'
+
+# URL 열기
+response = urllib.request.urlopen(url)
+
+# HTTP 상태 코드 확인
+print(response.status)
+
+# 웹 페이지 내용 읽기
+html = response.read()
+print(html)
+```
+
+```python
+import urllib.request
+
+url = 'https://api.example.com/data'
+headers = {'User-Agent': 'My Python Script', 'Content-Type': 'application/json'}
+data = b'{"key": "value"}'  # 바이트 형태로 데이터 전달
+
+req = urllib.request.Request(url, data=data, headers=headers, method='POST')
+
+with urllib.request.urlopen(req) as response:
+    html = response.read()
+    print(html)
+```
+
+### urllib.request 모듈의 주요 함수
+* urlopen(url): 지정된 URL을 열고 HTTPResponse 객체를 반환합니다.
+* Request(url, data=None, headers={}): HTTP 요청 객체를 생성합니다.
+* urlretrieve(url, filename): URL의 내용을 로컬 파일로 저장합니다.
+
+```python
+import urllib.parse
+
+# URL 분해
+url = 'https://www.example.com/search?q=python'
+parsed_url = urllib.parse.urlparse(url)
+
+print(parsed_url.scheme)  # 출력: https
+print(parsed_url.netloc)  # 출력: www.example.com
+print(parsed_url.query)  # 출력: q=python
+```
+
+urllib 모듈보다 더욱 강력하고 사용하기 편리한 requests 모듈이 있습니다. requests 모듈은 쿠키 처리, 인증, 다양한 HTTP 메서드 지원 등 더 많은 기능을 제공합니다.
+
+## requests
+requests 모듈은 파이썬에서 웹 요청을 보내고 응답을 받는 작업을 매우 간편하게 처리할 수 있도록 해주는 강력한 HTTP 라이브러리입니다. urllib 모듈에 비해 더욱 직관적이고 다양한 기능을 제공하여, 웹 스크래핑, API 호출 등 다양한 분야에서 널리 사용됩니다.
+
+* 간편한 사용: 직관적인 인터페이스를 제공하여 복잡한 HTTP 요청을 간단하게 처리할 수 있습니다.
+* 다양한 HTTP 메서드 지원: GET, POST, PUT, DELETE 등 다양한 HTTP 메서드를 지원합니다.
+* 자동 추적: 리디렉션을 자동으로 따라가고, 쿠키를 자동으로 처리합니다.
+* JSON 응답 처리: JSON 형식의 응답을 파이썬 객체로 직접 변환해줍니다.
+* 바이너리 데이터 처리: 이미지, 파일 등 바이너리 데이터를 다룰 수 있습니다.
+* 인증: 기본 인증, 다이제스트 인증 등 다양한 인증 방식을 지원합니다.
+
+```python
+import requests
+
+# GET 요청
+response = requests.get('https://api.example.com/data')
+
+# JSON 응답 파싱
+data = response.json()
+
+# POST 요청
+response = requests.post('https://api.example.com/data', json={'key': 'value'})
+
+# 응답 상태 코드 확인
+print(response.status_code)
+
+# 응답 내용 출력
+print(response.text)
+```
+
+### 주요 함수
+* requests.get(url, params=None, kwargs): GET 요청을 보냅니다.
+* requests.post(url, data=None, json=None, kwargs): POST 요청을 보냅니다.
+* requests.put(url, data=None, kwargs): PUT 요청을 보냅니다.
+* requests.delete(url, kwargs): DELETE 요청을 보냅니다.
+

doc/20_01_html_parser.md

@@ -0,0 +1,25 @@
+# HTML 응답 파싱
+
+- Beautiful Soup
+
+    * HTML 파싱: requests로 가져온 HTML 콘텐츠를 파싱하여 특정 요소를 추출하는 데 사용됩니다.
+    * 예시: 웹 페이지에서 특정 태그의 내용을 추출하거나, CSS 선택자를 이용하여 원하는 데이터를 찾아낼 수 있습니다.
+
+- lxml
+
+    * XML/HTML 파싱: Beautiful Soup보다 빠르고 강력한 성능을 제공합니다. XPath를 사용하여 복잡한 구조의 문서를 효율적으로 파싱할 수 있습니다.
+    * 예시: XML 형식의 데이터를 처리하거나, 대규모 HTML 문서를 빠르게 파싱할 때 사용합니다.
+
+- pandas
+
+    * 데이터 분석: requests로 가져온 JSON 또는 CSV 형식의 데이터를 pandas DataFrame으로 변환하여 데이터 분석을 수행할 수 있습니다.
+    * 예시: 웹 API에서 가져온 데이터를 분석하고 시각화하는 데 사용합니다.
+
+- scrapy
+
+    * 웹 크롤링: 웹 사이트를 크롤링하여 데이터를 추출하고 저장하는 데 특화된 프레임워크입니다.
+    * 예시: 대규모 웹 사이트를 크롤링하여 데이터를 수집하고 분석할 때 사용합니다.
+
+- Parsel
+
+    * CSS 선택자 기반의 HTML/XML 파싱 라이브러리: Beautiful Soup과 유사하지만 더욱 강력한 기능을 제공합니다.

doc/21_date_time.md

@@ -0,0 +1,142 @@
+# 날짜와 시간
+파이썬에서 날짜와 시간을 다루기 위해 주로 datetime 모듈을 사용합니다. 이 모듈은 날짜와 시간 관련 다양한 클래스와 메서드를 제공하여 날짜 계산, 시간 차이 계산, 포맷팅 등 다양한 작업을 수행할 수 있도록 합니다.
+
+## datetime 모듈의 주요 클래스
+* datetime: 날짜와 시간을 함께 나타내는 클래스입니다.
+* date: 날짜만 나타내는 클래스입니다.
+* time: 시간만 나타내는 클래스입니다.
+* timedelta: 두 날짜 또는 시간 사이의 차이를 나타내는 클래스입니다.
+
+```python
+import datetime
+
+# 현재 시간 가져오기
+now = datetime.datetime.now()
+print(now)  # 출력 예: 2023-11-22 14:34:27.123456
+
+# 특정 날짜 생성
+birthday = datetime.date(1990, 12, 25)
+print(birthday)  # 출력 예: 1990-12-25
+
+# 날짜와 시간 계산
+time_difference = datetime.datetime.now() - birthday
+print(time_difference)  # 출력 예: 12186 days, 14:34:27.123456
+
+# 하루를 더한 날짜
+today = datetime.date.today()
+tomorrow = today + datetime.timedelta(days=1)
+print(tomorrow)  # 예: 2023-11-23
+
+# 날짜 포맷팅
+formatted_date = birthday.strftime("%Y년 %m월 %d일")
+print(formatted_date)  # 출력 예: 1990년 12월 25일
+```
+
+## 주요 메서드 및 속성
+* now(): 현재 시각을 반환합니다.
+* today(): 오늘 날짜를 반환합니다.
+* strftime(): 날짜와 시간을 지정된 형식의 문자열로 변환합니다.
+* strptime(): 문자열을 datetime 객체로 변환합니다.
+* year, month, day, hour, minute, second: 각각 연도, 월, 일, 시, 분, 초를 나타내는 속성입니다.
+* weekday(): 요일을 숫자로 반환합니다 (0: 월요일, 1: 화요일, ...).
+* timedelta: 두 datetime 객체의 차이를 나타내며, 일, 시간, 분, 초 등을 계산할 수 있습니다.
+
+## 날짜와 시간 포맷팅
+strftime 메서드를 사용하여 다양한 형식으로 날짜와 시간을 표현할 수 있습니다.
+
+* %Y	4자리 연도
+* %m	월 (01-12)
+* %d	일 (01-31)
+* %H	24시간 형식 시 (00-23)
+* %M	분 (00-59)
+* %S	초 (00-59)
+* %A	요일 (Monday, Tuesday, ...)
+* %B	월 (January, February, ...)
+
+## 시간대 
+pytz 모듈은 파이썬에서 다양한 시간대를 정확하게 처리하기 위한 필수적인 도구입니다. 특히, 서머타임과 같은 복잡한 시간대 변화를 정확하게 반영하여 시간 계산을 수행할 수 있도록 지원합니다.
+
+* 정확한 시간대 정보: 전 세계의 다양한 시간대 정보를 제공합니다.
+* 서머타임 처리: 서머타임 시작 및 종료 시점을 정확하게 반영하여 계산합니다.
+* 시간대 변환: 다른 시간대 간의 시간 변환을 쉽게 수행할 수 있습니다.
+
+```bash
+pip install pytz
+```
+
+* Naive datetime: 시간대 정보가 없는 datetime 객체입니다.
+* Aware datetime: 시간대 정보가 포함된 datetime 객체입니다.
+* pytz는 대부분의 경우 Aware datetime을 사용합니다.
+
+```python
+import datetime
+import pytz
+
+# 특정 시간대 설정
+tz = pytz.timezone('Asia/Seoul')
+
+# 현재 시각을 해당 시간대로 변환
+now = datetime.datetime.now(tz)
+print(now)  # 예: 2023-11-22 14:34:27+09:00
+
+# UTC 시간을 특정 시간대로 변환
+utc = datetime.datetime.utcnow()
+local_dt = utc.astimezone(tz)
+print(local_dt)
+
+# 서울 시간을 뉴욕 시간으로 변환
+seoul_tz = pytz.timezone('Asia/Seoul')
+new_york_tz = pytz.timezone('America/New_York')
+seoul_time = datetime.datetime.now(seoul_tz)
+new_york_time = seoul_time.astimezone(new_york_tz)
+print(new_york_time)
+```
+
+* 시간대 객체 생성: `pytz.timezone('시간대 이름')`을 통해 시간대 객체를 생성합니다.
+* 시간대 변환: `astimezone()` 메서드를 사용하여 다른 시간대로 변환합니다.
+* 시간대 목록: `pytz.all_timezones`를 통해 모든 지원되는 시간대 목록을 확인할 수 있습니다.
+
+
+
+## 스케쥴
+schedule 모듈은 파이썬에서 특정 시간이나 주기적으로 함수를 실행하도록 스케줄링하는 데 사용되는 간단하고 직관적인 라이브러리입니다. 별도의 설치가 필요 없이 바로 사용할 수 있으며, 복잡한 설정 없이 간단하게 작업을 예약할 수 있다는 장점이 있습니다.
+
+* 시간 기반 스케줄링: 특정 시간에 함수를 실행하도록 설정할 수 있습니다.
+* 주기적인 스케줄링: 매일, 매주, 매월 등 주기적으로 함수를 실행하도록 설정할 수 있습니다.
+* 일회성 스케줄링: 한 번만 실행되는 작업을 예약할 수 있습니다.
+* 다양한 시간 단위 지원: 초, 분, 시간, 일, 주 등 다양한 시간 단위를 지원합니다.
+* 간단한 API: 직관적인 인터페이스를 제공하여 쉽게 사용할 수 있습니다.
+
+```python
+import schedule
+import time
+
+def job():
+    print("Hello, World!")
+
+# 매일 오전 9시에 job 함수 실행
+schedule.every().day.at("09:00").do(job)
+
+# 무한 루프를 돌면서 스케줄된 작업 실행
+while True:
+    schedule.run_pending()
+    time.sleep(1)
+```
+
+### 주요 메서드
+* every(): 스케줄을 설정하는 시작점입니다.
+* day, hour, minute, second: 각각 일, 시간, 분, 초 단위의 스케줄을 설정합니다.
+* do(job): 실행할 함수를 지정합니다.
+* run_pending(): 현재 시간에 실행해야 할 작업이 있는지 확인하고 실행합니다.
+
+```python
+# 매주 월요일 오후 5시에 작업 실행
+schedule.every().monday.at("17:00").do(my_job)
+
+# 5초마다 작업 실행
+schedule.every(5).seconds.do(another_job)
+```
+
+* 무한 루프: schedule.run_pending()을 무한 루프 안에서 실행해야 스케줄된 작업이 정상적으로 수행됩니다.
+* 시간 정확도: 시스템 시간에 의존하므로 시스템 시간이 정확하지 않으면 스케줄이 제대로 작동하지 않을 수 있습니다.
+* 병렬 처리: schedule 모듈은 단일 스레드 환경에서 사용하기에 적합합니다. 병렬 처리가 필요한 경우 다른 라이브러리를 사용해야 합니다.

doc/22_regexp.md

@@ -0,0 +1,2 @@
+# 정규표현식
+

doc/26_sys_module.md

@@ -0,0 +1,31 @@
+# sys 모듈
+
+sys 모듈은 파이썬 프로그램과 파이썬 인터프리터 사이의 상호 작용을 가능하게 해주는 표준 라이브러리 모듈입니다. 시스템 관련 정보를 얻거나, 프로그램의 실행 환경을 제어하는 데 사용됩니다.
+
+* `sys.version`: 현재 사용 중인 파이썬 버전 정보
+* `sys.platform`: 운영 체제 정보
+* `sys.executable`: 현재 실행 중인 파이썬 인터프리터의 경로
+* `sys.path`: 모듈을 검색하는 경로를 나타내는 리스트
+* `sys.stdin`: 표준 입력 스트림 (키보드)
+* `sys.stdout`: 표준 출력 스트림 (콘솔)
+* `sys.stderr`: 표준 오류 스트림 (콘솔)
+* `sys.argv`: 프로그램 실행 시 전달된 명령줄 인수를 담은 리스트
+* `sys.exit()`: 프로그램을 종료합니다.
+
+```python
+import sys
+
+# 현재 파이썬 버전 출력
+print(sys.version)
+
+# 프로그램 실행 시 전달된 인수 출력
+for arg in sys.argv:
+    print(arg)
+
+# 특정 모듈 검색 경로 추가
+sys.path.append('/path/to/your/modules')
+
+# 프로그램 종료
+sys.exit(0)
+```
+

doc/27_argparse_module.md

@@ -0,0 +1,88 @@
+# 실행시간 명령행 매개변수 전달받기
+
+파이썬 프로그램을 실행할 때 다양한 옵션을 부여하여 프로그램의 동작을 조절하고 싶을 때가 있습니다. 이러한 명령줄 옵션을 처리하기 위한 가장 강력하고 편리한 방법은 argparse 모듈을 사용하는 것입니다.
+
+## argparse
+
+argparse 모듈은 파이썬에서 명령줄 옵션을 처리하기 위한 표준 라이브러리 모듈입니다. getopt 모듈에 비해 더욱 강력하고 사용하기 쉽다는 장점이 있으며, 복잡한 명령줄 인터페이스를 구축하는 데 효과적입니다.
+
+* 명확한 구조: 코드가 명확하고 가독성이 좋습니다.
+* 자동 도움말 생성: -h 또는 --help 옵션을 통해 사용법을 자동으로 출력합니다.
+* 오류 처리: 잘못된 옵션이 입력될 경우 에러 메시지를 출력하고 프로그램을 종료합니다.
+* 유효성 검사: 옵션의 타입, 범위 등을 검사하여 잘못된 입력을 방지할 수 있습니다.
+
+```python
+import argparse
+
+# ArgumentParser 객체 생성
+parser = argparse.ArgumentParser(description='This is a sample program')
+
+# 인수 추가
+parser.add_argument('-i', '--input', type=str, help='input file')
+parser.add_argument('-o', '--output', type=str, help='output file')
+
+# 인수 파싱
+args = parser.parse_args()
+
+# 파싱된 인수 사용
+print(args.input)
+print(args.output)
+```
+
+* ArgumentParser 객체 생성: * ArgumentParser() 함수를 호출하여 ArgumentParser 객체를 생성합니다.
+* add_argument(): 옵션을 추가합니다.
+* parse_args(): 명령줄 인수를 파싱하여 Namespace 객체를 반환합니다.
+* Namespace: 파싱된 인수를 속성으로 가지는 객체입니다.
+
+아래 예시에서는 -i 옵션으로 정수 리스트를 받고, --sum 옵션을 통해 합계 또는 최댓값을 계산하는 기능을 구현했습니다.
+```python
+import argparse
+
+parser = argparse.ArgumentParser(description='Process some integers.')
+parser.add_argument('integers', metavar='N', type=int, nargs='+',
+                   help='an integer for the accumulator')
+parser.add_argument('--sum', dest='accumulate', action='store_const',
+                   const=sum, default=max,
+                   help='sum the integers (default: find the max)')
+
+args = parser.parse_args()
+print(args.accumulate(args.integers))
+```
+
+
+
+## getopt
+getopt 모듈은 파이썬에서 명령줄 옵션을 파싱하는 데 사용되는 표준 라이브러리 모듈입니다. 즉, 프로그램 실행 시 추가되는 옵션들을 분석하여 프로그램의 동작을 조절할 수 있도록 해줍니다. 예를 들어, 프로그램 실행 시 `-h` 옵션을 추가하여 도움말을 출력하거나, `-f` 옵션으로 특정 파일을 지정하는 등의 기능을 구현할 수 있습니다.
+
+```python
+getopt.getopt(argv, options, long_options)
+```
+* argv: sys.argv[1:]처럼 스크립트 이름을 제외한 인수 리스트를 전달합니다.
+* options: 짧은 형식의 옵션 문자열입니다. 예를 들어, ho:v는 -h, -o, -v 옵션을 의미하며, o:는 -o 옵션에 값이 필요하다는 것을 나타냅니다.
+* long_options: 긴 형식의 옵션 목록을 리스트로 전달합니다. 예를 들어, ["help", "output="]는 --help, --output 옵션을 의미합니다.
+
+```python
+import getopt
+import sys
+
+def main(argv):
+    opts, args = getopt.getopt(argv[1:], "ho:v", ["help", "output="])
+
+    for opt, arg in opts:
+        if opt in ("-h", "--help"):
+            print("사용법: program.py -o <outputfile> -v")
+            sys.exit()
+        elif opt in ("-o", "--output"):
+            output = arg
+        elif opt == "-v":
+            verbose = True
+
+    print('output:', output)
+    if verbose:
+        print('verbose mode')
+
+if __name__ == "__main__":
+   main(sys.argv)
+```
+
+getopt 모듈보다 더욱 강력하고 사용하기 편리한 argparse 모듈이 있습니다. argparse 모듈은 명령줄 옵션을 더욱 직관적으로 정의하고 사용할 수 있도록 도와줍니다. 복잡한 옵션 처리에는 argparse 모듈이 더 적합할 수 있습니다.

doc/41_logging.md

@@ -0,0 +1,2 @@
+# 로깅
+

doc/42_unittest.md

@@ -0,0 +1 @@
+# 단위 테스트

doc/50_array.md

@@ -0,0 +1,29 @@
+# 배열
+
+파이썬의 array 모듈은 모든 요소가 동일한 자료형인 배열을 만들기 위한 모듈입니다. 리스트와 비슷해 보이지만, 리스트보다 메모리를 효율적으로 사용하고 특정 자료형의 연산을 더 빠르게 수행할 수 있다는 장점이 있습니다.
+
+* 메모리 효율성: 리스트보다 메모리를 효율적으로 사용합니다. 특히 많은 양의 동일한 자료형 데이터를 다룰 때 유용합니다.
+* 빠른 연산: 동일한 자료형의 데이터만 다루기 때문에 연산 속도가 빠릅니다.
+* C 언어와의 호환성: C 언어의 배열과 유사한 구조를 가지므로 C 언어와의 연동이 용이합니다.
+
+```python
+import array as arr
+
+# 정수형 배열 생성
+numbers = arr.array('i', [1, 2, 3, 4, 5])
+
+# 실수형 배열 생성
+floats = arr.array('d', [1.2, 3.4, 5.6])
+
+# 배열 요소 접근
+print(numbers[0])  # 1
+
+# 배열 요소 변경
+numbers[2] = 10
+
+# 배열 슬라이싱
+print(numbers[1:4])  # [2, 3, 10]
+```
+* 형 코드: 배열에 저장되는 데이터의 자료형을 나타내는 코드입니다. 예를 들어, i는 정수, d는 부동소수점 숫자를 의미합니다.
+* 고정 크기: 생성 시 배열의 크기를 지정해야 하며, 나중에 크기를 변경하려면 새로운 배열을 만들어야 합니다.
+* 동일한 자료형: 배열의 모든 요소는 동일한 자료형이어야 합니다.

src/strings.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+s1 = "Hello, World!"
+s2 = 'Python'
+
+print(s1[0]) # H
+print(s2[2:4]) # th
+
+l1 = [1,2]
+x, y = l1
+
+print(x, y) # 1