파이썬1 강의 === 수업 정보 === 가입 --- * [프로그래머스](https://programmers.co.kr/) * [Replit - 가상 코드](https://replit.com/home) 다운로드 --- * [파이썬3 다운로드](https://www.python.org/downloads/) * Add Python 3.12.4 to PATH 체크하기 : 파이썬이 설치된 경로를 시스템이 인식해야 명령 프롬프트 어느 위치에서나 python 명령을 실행할 수 있다. * [파이참 다운로드](https://www.jetbrains.com/ko-kr/pycharm/download/?section=windows#section=windows) * 파이참이란? : 파이썬 프로그램을 쉽게 개발할 수 있는 통합 개발 환경(IDE) * IDE : 코딩, 디버그, 컴파일, 배포 등 프로그램 개발에 관련된 모든 작업을 하나의 프로그램 안에서 처리하는 환경을 제공하는 소프트웨어 * 모두 체크 후 설치 링크 --- * [영상 - 나도코딩 : 1분 파이썬 - (1) 소개](https://www.youtube.com/watch?v=sj4vexbygKA) * [영상 - 나도코딩 : 파이썬 코딩 무료 강의 (활용편3) - 웹 크롤링? 웹 스크래핑! 제가 가진 모든 비법을 알려드리겠습니다.](https://www.youtube.com/watch?v=yQ20jZwDjTE&list=PLMsa_0kAjjrd8hYYCwbAuDsXZmHpqHvlV&index=5) * [영상 - 나도코딩 : 파이썬 코딩 무료 강의 (활용편4) - 업무자동화(RPA), 이제는 일하는 척(?)만 하세요](https://www.youtube.com/watch?v=exgO1LFl9x8&list=PLMsa_0kAjjrd8hYYCwbAuDsXZmHpqHvlV&index=6) * [code.org 코스 3](https://studio.code.org/s/course3) * [code.org 코스 4](https://studio.code.org/s/course4) * [프로그래머스 - 알고리즘 입문](https://school.programmers.co.kr/learn/challenges/beginner?order=acceptance_desc&page=1&languages=python3) * [코드업, 100제](https://codeup.kr/problemsetsol.php?psid=33) 1일차 === 파이썬이란? === 파이썬의 유래 --- * 파이썬(Python)은 1991년 네덜란드 수학자 '귀도 반 로섬(Guido van Rossum)'에 의해 개발된 프로그래밍 언어 * 그리스어 '피톤(python)'에서 유래, '비단뱀'이라는 뜻을 가지고 있다. * 해당 모습은 파이썬의 로고에서 확인할 수 있다. 파이썬의 특징 --- * 대화식 언어인 인터프리터 언어이다. * 입력한 코드의 실행결과를 곧바로 확인할 수 있음을 의미 * 플랫폼에 독립적 * 어떤 운영체제(OS)를 사용하던 같은 파이썬 코드를 사용할 수 있다. * 객체지향 언어 * 클래스와 객체를 기반으로 하는 객체지향 언어이다. * 객체(Object) : 객체는 어떠한 속성값과 행동을 가지고 있는 데이터 * 동적 타이핑(dynamic typing)언어 * 프로그램이 실행 중인 시점에 처리할 수 있는 작업을 '동적 작업'이라고 합니다. * 파이썬은 프로그램이 실행중인 시점에 자료형(type)을 검사할 수 있는 '동적 타이핑'을 지원 * 이는 미리 자료형을 정해 두고 실행되는 대부분의 다른 언어들과 차별되는 부분입니다. * 개발 속도가 빠르다. * 데이터 분석을 위한 pandas, 수치 연산을 위한 numpy, 데이터 시각화를 위한 matplotlib 등 이미 완성된 다양한 라이브러리들을 사용할 수 있다. ``` 인터프리터(interpreter) 프로그램 실행시 한 번에 한 문장씩 번역한다. 한번에 한문장씩 번역후 실행 시키기 때문에 실행 시간이 느리다. 컴파일러와 같은 오브젝트 코드 생성과정이 없기 때문에 메모리 효율이 좋다. 프로그램을 실행시키고 나서 오류를 발견하면 바로 실행을 중지 시킨다. 실행 후에 오류를 알 수 있다. 대표적인 언어로 Python, Ruby, Javascript 등이 있다. ``` 파이썬 설치 === * 링크에 있는 파이썬3 다운로드 진행해 주세요. * 링크에 있는 파이참 다운로드 진행해 주세요. 파이참 화면 설명 === [![image.png](https://i.postimg.cc/KzFmTK5s/image.png)](https://postimg.cc/KKqXS8wn) 파이참 실행하기 === * 파이참 실행 후 에디터에 아래의 내용 작성 후 실행해보기 ```python print('Hello Python!') ``` 주석 === * 주석(comment)이란 프로그램 소스 코드에 설명을 작성해 둔 부분을 의미 * 주석은 프로그램이 실행될 때 아무런 영향을 끼치지 않는다. * 이해하기 쉽고 의미 전달이 잘 되는 주석을 작성하는 것이 좋다. * 주석으로 나타낼 부분은 #으로 시작하거나, 작은따옴표 3개(''' ''')로 묶어서 표현 * 큰따옴표(""" """)도 작은따옴표 3개와 같은 역할을 수행하지만, 본래 용도는 Docstring을 작성하는 용도이므로 구별하는 것이 좋습니다. * Docstring : 모듈, 함수, 클래스, 메소드를 정의할 때 첫 번째로 작성하는 문자열 * 해당 프로그램의 설명서 역할을 합니다. ```python # 이것은 한 줄 주석입니다. ''' 이것은 블록 주석입니다. ''' ``` 예제 --- * 다음은 반지름을 전달하면 원의 넓이를 변환하는 함수입니다. ```python ''' 파일명 : Ex02-1.py 개요 : 반지름을 전달하면 원의 넓이를 반환하는 get_area()함수 작성자 : 홍길동 최초작성일 : 2020-08-25 ''' # math 모듈 포함 import math # get_area() 함수 정의 def get_area(radius): """반지름을 입력받아 원의 넓이를 반환하는 get_area() 함수""" area = math.pi * math.pow(radius, 2) return area radius = 1.5 # get_area() 함수 호출 결과를 area 변수에 저장 area = get_area(raidus) print(area) print(get_area.__doc__) # Docstring 확인 ``` 문제 --- * 문제 1: 주석을 추가하여 설명하기 * 아래 코드에 주석을 추가하여 각 라인이 무슨 역할을 하는지 설명하세요. ```python x = 10 y = 20 sum = x + y print(sum) ``` * 문제 2: 주석을 이용하여 코드 비활성화하기 * 아래 코드에서 주석을 이용하여 특정 라인을 비활성화하세요. ```python a = 5 b = 3 c = a * b d = a + b print(d) ``` 변수 === * 변수(variable) : 어떤 데이터를 저장하고자 할 때 사용하는 메모리 저장소 * 변수 작성법 : 등호(=) 왼쪽에 변수 이름을 작성하고, 오른쪽에 저장할 값을 작성 ```python score = 100 ``` * 이 코드로 정수 100을 저장하고 있는 score라는 이름의 변수가 생성됩니다. * 저장된 값을 언제든지 꺼내어 사용할 수 있으며 저장된 값을 변경할 수도 있습니다. [![variables-01.png](https://i.postimg.cc/029Qnz07/variables-01.png)](https://postimg.cc/6T1t55SQ) 변수명 --- * 변수명은 다음과 같은 생성 규칙을 따라 만듭니다. ``` 1. 영문, 한글, 숫자, 밑줄(_)로 구성 2. 특수문자는 사용할 수 없다. 3. 대문자와 소문자를 구분 4. 변수명의 첫 글자는 숫자를 사용할 수 없다. 5. 키워드(list,dict, if, for, and 등)는 사용할 수 없다. ``` * 위 규칙을 지킨다면 어떤 변수명을 사용해도 관계없습니다. * 하지만 이해하기 쉬운 프로그램 개발을 위해서 다음과 같은 방식의 변수명 사용을 권장합니다. ``` 1. 가급적 소문자로만 구성 2. 한글 변수명도 가능하지만 가급적 영문 변수명을 사용 3. 변수명을 통해 어떤 것을 저장하고 있는지 파악할 수 있어야 함 ``` 예제 --- ```python name = 'Alice' age = 25 address = '''우편번호 12345 서울시 영등포구 여의도동 서울빌딩 501호''' boyfriend = None height = 168.5 print(name) print(age) print(address) print(boyfriend) print(height) ``` 기본 자료형 === * 기본 자료형(type)에는 int, float, bool, str과 같은 자료형이 있습니다. | 구분 | 자료형 | 변환 함수 | 의미 | | --- | --- | --- | --- | | int | 정수 | int(n) | n을 정수로 변환 | | float | 실수 | float(n) | n을 실수로 변환 | | bool | 논리 | bool(n) | n을 논리로 변환 | | str | 문자열 | str(n) | n을 문자열로 변환 | 정수(int) --- * int는 정수 자료형 * 파이썬 2.x에서는 정수의 크기에 따라 int와 long으로 구분했으나, 파이썬 3.x에서는 모든 정수를 int 자료형으로 통일 * 기본적으로 원하는 값을 크기의 제한 없이 사용할 수 있습니다. ```python int(1.9) int(True) int(False) int('100') ``` * int 자료형은 다음과 같은 방식으로 10진수, 2진수, 8진수, 16진수 표현이 가능합니다. | 구분 | 특징 | 예시 | 의미 | | --- | --- | --- | --- | | 10진수 | 0~9로 시작하는 숫자 | n = 95 | 10진수 95 | | 2진수 | 0b로 시작하는 숫자 | n = 0b1011111 | 2진수 1011111 | | 8진수 | 0o로 시작하는 숫자 | n = 0o137 | 8진수 137 | | 16진수 | 0x로 시작하는 숫자 | n = 0x5f | 16진수 5f | ```python n = 95 bin(n) oct(n) hex(n) ``` 실수(float) --- * float는 실수 자료형 * 기본적으로 소수점이 있는 숫자를 실수라고 합니다. * 지수 형식이나 복소수 형식으로 표현할 수 있습니다. | 구분 | 특징 | 예시 | 의미 | | --- | --- | --- | --- | | 실수 | 소수점이 있는 숫자 | n = 3.14 | 3.14 | | 지수 | e를 포함하는 숫자 | n = 1.5e2 | 1.5 * 10^{2 |
| 복소수 | 실수와 허수(i)를 포함하는 숫자 | n = 1.5 + 2.54j | 허수 i 대신 j나 J를 사용 |
```python
float(1)
float(True)
float(False)
float('3.14')
float('100')
```

논리(bool)
---
* bool은 논리 자료형
* 참과 거짓을 의미하는 True와 False 값을 가질 수 있습니다.

| 구분 | 의미 | 예시 | 특징 |
| --- | --- | --- | --- |
| False | 거짓 | n = False | 0, '', [], (), {} 등 |
| True | 참 | n = True | False 외 모든 값 |
* 파이썬에서 False는 값이 없는 모든 경우를 의미

```python
bool(0)
bool('')
bool([])
```
* False나 True 모두 첫 글자는 반드시 대문자로 작성

문자열(str)
---
* str은 문자열 자료형
* 문자열은 기본적으로 따옴표로 묶어서 데이터를 표현
* 따옴표로 묶인 모든 것들은 문자열("100" 처럼 숫자로 구성되어 있어도 문자열)

문자열 변환
---
* 연산이나 값의 비교를 위해 문자열이 아닌 변수값을 문자열로 변환해야 하는 경우가 있습니다.
* 이때 str() 함수를 이용하면 다른 자료형의 값을 문자열 데이터로 변환할 수 있습니다.
```python
str(100)
str(True)
str(False)
str(3.14)
```

문자열 인덱싱(indexing)
---
* 문자열의 인덱스(index)는 문자열을 구성하는 모든 문자에 부여한 고유 번호
* 인덱스의 시작 번호는 0입니다.

| h | e | l | l | o |
| --- | --- | --- | --- | --- |
| 0 | 1 | 2 | 3 | 4 |

* 인덱스는 해당 인덱스에 있는 특정 문자를 추출하고자 할 때 사용할 수 있습니다.
```python
s = 'hello'
s[1]
```
| h | e | l | l | o |
| --- | --- | --- | --- | --- |
| s[0] | s[1] | s[2] | s[3] | s[4] |

* 파이썬의 문자열 인덱스에는 마이너스(-) 인덱스가 존재
* 마이너스 인덱스는 문자열의 뒤에서부터 부여하는 번호
* 뒤에서부터 인덱스를 부여하기 때문에 마지막 문자의 인덱스는 -1이 됩니다.

| h | e | l | l | o |
| --- | --- | --- | --- | --- |
| s[-5] | s[-4] | s[-3] | s[-2] | s[-1] |

```python
s = 'hello'
s[1] == s[-4]

# == : 양쪽 요소가 같은지 판단하는 비교 연산자
```

문자열 슬라이싱(slicing)
---
* 문자열 슬라이싱은 문자열의 인덱스를 활용하여 한 문자 이상으로 구성된 단어나 문장을 추출할 때 사용
* 추출하고자 하는 단어나 문장의 시작 인덱스와 종료 인덱스를 통해 그 사이 모든 문자들을 추출하는 방법
```python
# s[start:stop:step]
'''
start : 시작 인덱스, 생략하면 처음부터 추출
stop : 종료 인덱스, 생략하면 끝까지 추출
step : 인덱스 증가값, 생략하면 1씩 변화
'''

s = 'banana'
s[0:3]
```

| b | a | n | a | n | a |
| --- | --- | --- | --- | --- | --- |
| 0 | 1 | 2 | 3 | 4 | 5 |

* 얼핏 보기에는 0번부터 3번까지 추출하는 것으로 보여 'bana'까지 예상할 수 있다.
* 하지만 종료 인덱스는 포함하지 않고 종료 인덱스 이전까지만 추출한다.
```python
p = 010-1234-5678
# 1234만 추출하려면?
```

문제
---
* 5자리로 구성된 학번 '31025'를 학년, 반, 번호로 나누어 출력하세요.

컬렉션
===
* '모음'이라는 뜻
* 파이썬에서 컬렉션은 다음과 같은 의미
* "여러 값을 하나의 이름으로 묶어서 관리하는 자료형"
* 컬렉션에는 리스트(list), 튜플(tuple), 세트(set), 딕셔너리(dict)가 있습니다.

| 컬렉션 | 생성 함수 | 특징 | 예시 |
| --- | --- | --- | --- |
| 리스트 | list() | 추가, 수정, 삭제가 언제든 가능 | a = [1, 2] |
| 튜플 | tuple() | 생성되고 하면 변경 불가능 | a = (1, 2) |
| 세트 | set() | 중복된 값의 저장 불가능 | a = {1, 2} |
| 딕셔너리 | dict() | 키+값으로 관리 | a = {'age : 25'} |

* 컬렉션 중에서 저장된 값들의 순서가 있는 컬렉션을 '시퀀스(sequence)'라고 부릅니다. (리스트와 튜플이 대표적 시퀀스)

리스트
---
* 리스트는 여러 값을 저장할 때 가장 많이 사용하는 자료형
* 저장하고자 하는 값들의 자료형(type)이 서로 다르더라도 하나의 리스트에 저장할 수 있습니다.
```python
# 리스트는 대괄호 [] 또는 list()함수를 이용하여 다음과 같은 방식으로 생성
li = [값1, 값2, ...]
li = list(반복가능객체)
```
* 실제로 정수, 실수, 문자열을 각 1개씩 저장하고 있는 리스트 생성해보기
```python
li = [100, 3.14, 'hello']
```
* 하나의 배열(파이썬의 리스트와 비슷한 개념의 구조)에 하나의 자료형만 저장할 수 있는 C나 Java에 비하면 매우 큰 장점

문제
---
* 리스트에 이름, 나이, 전화번호, 키, 몸무게 등의 정보를 담고 print로 출력하여 확인해보세요.

리스트의 인덱싱(indexing)과 슬라이싱(slicing)
---
리스트 인덱싱
---
* 리스트는 문자열과 동일한 방식의 인덱싱을 지원
* 저장된 요소들마다 고유 번호인 인덱스를 부여하여 순서대로 관리할 수 있습니다.
```python
li = [100, 3.14, 'hello']
```

| li = | 100 | 3.14 | 'hello' |
| --- | --- | --- | --- |
| index = | 0 | 1 | 2 |
* 리스트에 저장된 각각의 요소들은 리스트의 이름과 각 요소들의 인덱스를 대괄호([])로 조합하여 구분합니다.
```python
li = [100, 3.14, 'hello']

li[0]
li[1]
li[2]
```

리스트 슬라이싱
---
* 리스트의 일부 요소만 이용하고자 하는 경우 슬라이싱을 활용할 수 있습니다.
* 슬라이싱 사용 방식은 문자열과 동일합니다.
```python
li = [10, 20, 30, 40, 50]
li[0:3]

# 결과 : [10, 20, 30]
```

| li = | 10 | 20 | 30 | 40 | 50 |
| --- | --- | --- | --- | --- | --- |
| index = | 0 | 1 | 2 | 3 | 4 |

문제
---
* 리스트의 값 수정하기 : 주어진 리스트에서 첫 번째 값과 마지막 값을 각각 100과 200으로 수정하세요.
* numbers = [10, 20, 30, 40, 50]

```python
numbers = [10, 20, 30, 40, 50]
numbers[0] = 100
numbers[-1] = 200

print(numbers) # 출력 결과: [100, 20, 30, 40, 200]
```

리스트 요소의 추가와 삭제
---
* 리스트에 새로운 요소를 추가할 때는 append()와 insert() 메소드를 사용할 수 있습니다.
* 기존 요소를 삭제할 때는 pop() 메소드를 사용할 수 있습니다.
```python
scores = [50, 40, 30]
scores.append(100)

scores.insert(0, 90)
```
* append() 메소는 항상 마지막 요소로 추가되며 insert() 메소드는 추가할 인덱스(위치 정보)를 지정할 수 있습니다.
* 삭제 과정도 추가 과정과 유사합니다.
```python
scores.pop() # 마지막 요소 제거
scores.pop(0) # 인덱스가 0인 요소를 제거
```
* pop() 메소드는 인덱스를 전달하지 않으면 마지막 요소를 삭제하고 인덱스를 전달하면 전달된 인덱스의 요소를 삭제합니다.

* TIP
* 파이썬에는 type() 함수가 있습니다. 이 함수는 변수가 가지고 있는 자료형을 확인하고자 하는 경우 사용할 수 있습니다.
* 해당 함수에 변구를 전달하면 해당 변수가 가지고 있는 자료형이 과 같은 형식으로 반환됩니다.

문제
---
* 리스트에 값 추가하기 : 주어진 빈 리스트에 숫자 1, 2, 3을 순서대로 추가하세요.
* numbers = []
* 추가한 값 중에서 2를 제거해주세요.

2일차
===
튜플
---
* 튜플은 한마디로 요약하면 저장된 값을 변경할 수 없는 리스트
* 리스트와 마찬가지로 튜플도 각 요소를 구분하기 위한 인덱스가 부여되고 슬라이싱도 지원됩니다.
* 다만 이미 저당된 값 이외에는 추가, 수정, 삭제가 불가능합니다.
* 튜플은 소괄호(()) 또는 tuple() 함수를 이용하여 다음과 같은 방식으로 생성합니다.
```python
t = (값1, 값2, ...)
t = tuple(반복가능객체)
```
* 소괄호(())나 tuple() 함수를 사용하지 않고 값들을 콤마(,)로 분리하여 전달하면 자동으로 튜플이 생성됩니다.
```python
t = 값1, 값2, ...
```
* 주의할 점 : 값을 1개만 보관하는 튜플을 생성할 경우 다음과 같이 값과 콤마(,)를 반드시 함께 작성해야 합니다.
* 그렇지 않으면 튜플이 아닌 그냥 값으로 인식하기 때문에 튜플이 생성되지 않습니다.
```python
t = (값1,)
t = 값1,
```

세트
---
* 세트(set)는 수학의 집합 개념을 구현한 자료형
* 세트에 저장된 값들은 순서가 없기 때문에 인덱싱과 슬라이싱을 사용할 수 없습니다.
* 대신 중복된 값의 저장이 불가능하다는 특징을 활용해 중복 제거용으로 사용하거나 교집합, 합집합, 차집합과 같은 집합 개념이 필요한 경우 사용할 수 있습니다.

* 세트는 중괄호({}) 또는 set() 함수를 이용하여 다음과 같은 방식으로 생성할 수 있습니다.
```python
s = {값1, 값2, ...}
s = set(반복가능객체)
```
* 빈 세트를 생성할 때는 중괄호를 사용할 수 없습니다.
* s = {}와 같은 코드를 작성하면 빈 딕셔너리(dict)가 생성됩니다.
* 빈 세트를 생성할 때는 set() 함수를 사용해야 합니다.
```python
s = {}
type(s)

s = set()
type(s)
```

세트의 특징
---
* 세트의 2가지 중요한 특징
1. 저장되는 순서가 없습니다.
2. 중복되는 값을 저장할 수 없습니다.
* 이 중 유용하게 사용하는 특징은 중복된 값을 저장할 수 없다는 특징
* 의도적으로 데이터의 중복을 피해야 할 때 세트를 사용하면 자동으로 중복을 회피할 수 있다. (필터 역할)
* 세트를 활용하여 리스트의 중복을 제거하는 과정
```python
li = list(set([1,1,2,2,3,3]))
li

# 리스트의 중복 요소를 제거하기 위해 세트로 변환 : set()
# set()의 결과 = {1,2,3}
# 중복을 제거한 세트를 리스트로 다시 변환 : list()
```
* TIP : 세트는 대괄호([])를 이용한 특정 요소 추출 방법을 제공하지 않습니다.
* 해당 작업을 위해서는 리스트나 튜플로 변환해야 합니다.

세트 요소의 추가와 삭제
---
* 세트에 새로운 요소를 추가 : add() 메소드 사용
* 기존 요소 삭제 : remove() 메소드, discard() 메소드
```python
# 세트에 요소 추가

s = {10, 20, 30}
s.add(40)
# 세트에 저장하는 요소는 순서가 없다.

# 세트의 요소 삭제
s.remove(20)
# 20이 없으면 KeyError 오류 발생

s.discard(30)
# 30이 없어도 오류가 없다.
```

딕셔너리
---
* 사전을 의미
* 사전? : 어떤 단어와 그 단어의 의미로 구성됨
* 파이썬의 딕셔너리도 같은 구성을 지닌다.
* 키(Key)와 값(Value)로 이루어져 있다.
```python
# 딕셔너리의 기본 구조

dict = {키1:값1, 키2:값2, ...}
```
* 딕셔너리는 인덱스가 존재하지 않다.
* 대신 키를 인덱스처럼 사용
```python
d = {'a':'apple', 'b':'banana'}
print(d)
type(d)

print(d['a'])
```
* 파이썬 3.7 버전부터 딕셔너리는 삽입 순서를 유지합니다.
* 이는 딕셔너리의 항목을 반복할 때 항목들이 삽입된 순서대로 나타난다는 의미입니다.
* 하지만 딕셔너리는 리스트와 달리 인덱스로 직접 접근할 수는 없습니다.
* 대신, 삽입된 순서를 기반으로 항목에 접근하려면 리스트로 변환하여 접근해야 합니다.
```python
# 딕셔너리 생성
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 딕셔너리의 키를 리스트로 변환
keys = list(my_dict.keys())

# 딕셔너리의 값을 리스트로 변환
values = list(my_dict.values())

# 인덱스로 키에 접근
print(keys[0]) # 'a'
print(keys[1]) # 'b'
print(keys[2]) # 'c'

# 인덱스로 값에 접근
print(values[0]) # 1
print(values[1]) # 2
print(values[2]) # 3
```
* 키 값의 자료형이 문자열(str)이면 dict() 함수를 이용해 쉽게 생성 가능하다.
```python
d = dict(a='apple', b='banana')
```

딕셔너리 요소의 추가와 삭제
---
* 딕셔너리에 새로운 데이터를 추가하는 방법
```python
dic = {'apple':'사과'}
dic['watermelon'] = '멜론'
```
* 딕셔너리 키를 이용하여 값 수정
```python
dic['watermelon'] = '수박'
```
* 딕셔너리에 새로운 키와 값을 추가하는 방법
```python
# setdefault 메서드 사용

me = {'name':'james'}
me.setdefault('age', 20)
```
* 수정하는 방법
```python
# update 메서드 사용
me.update(age=25)
```
* 기존에 존재하지 않는 키값을 이용애 update() 메소드 사용시 새로운 데이터 추가
* 다만 이 경우에 새로운 키값은 문자열이여야만 합니다.
```python
me.update(address='seoul')
```

* 삭제하는 방법
* pop() 메소드에 삭제하고자 하는 데이터의 키값을 전달
```python
# pop 메서드 사용
me.pop('address')
```

mutable과 immutable
===
* mutable : 생성된 후에도 변경이 가능한 자료형
* immutable : 생성된 후 변경이 불가능한 자료형

| mutable | immutable |
| --- | --- |
| 리스트, 세트, 딕셔너리 | 정수, 실수, 문자열, 튜플 |

* 내용 이해를 위해 id()함수를 사용해 보자.

id() 함수
---
* 전달된 변수나 자료형이 메모리의 어디에 저장되어 있는지 그 정보를 정숫값으로 반환
* 메모리는 1바이트마다 고유 번호가 부여되어 있다.
* 이것이 위치 정보를 나타내는 정숫값이며 일반적으로 '주소(address)'라고 부릅니다.

mutable
---
* 할당받은 메모리에 저장된 값을 다른 값으로 바꿀 수 있다.(대표적 : 리스트)
```python
me = [1,2,3]
id(me)

me.append(4)
id(me)
# 값을 추가한 뒤에도 같은 주소임을 확인할 수 있다.
```

immutable
---
* 한 번 생성하면 최초로 저장된 값을 다른 값으로 바꿀 수 없다.
```python
me = 10
id(me)

me += 1
id(me)
# 메모리 주소가 바뀌게 된다.
# 이 뜻은 최초로 저장된 10은 변경이 불가능하다는 뜻.
# me의 값을 11로 변경하면 새로운 번지에 증가된 11을 저장, 그리고 새로운 주소를 변수 me에 다시 할당
```

표준 출력
===
이스케이프 문자
---
* 확장 문자라는 의미
* 이스케이프 문자들은 \(back slash)로 시작

| 이스케이프 문자 | 의미 |
| --- | --- |
| \\' | 작은따옴표 |
| \\" | 큰따옴표 |
| \n | 줄 바꿈 |
| \r | 캐리지 리턴 |
| \t | 탭 |
| \v | 수직 탭 |
| \\\ | 역슬래시 |
| \a | 벨 |
| \b | 백스페이스 |

예제
---
```python
print('hello \'world\'')
print("hello \"world\"")
print('*\n**\n***')
print('이름\t연락처')
print('제시카\t02-123-4567')
```

형식을 갖춘 문자열
===
% 연산자
---
* 문자열 형식에 따라 사용하는 형식 기호(format symbol)에 값을 전달하는 연산자
* Java, C와 같은 프로그래밍 언어에서도 동일한 형식 기호를 지원

| 형식 기호 | 의미 | 자료형 |
| --- | --- | --- |
| %d | decimal | 정수(10진수) |
| %o | octal | 정수(8진수) |
| %x | hexadecimal | 정수(16진수) |
| %f | floating point | 실수 |
| %s | string | 문자열 |
```python
print('%d' % 10)
print('%o' % 10)
print('%x' % 10)
print('%f' % 3.14)
print('%s' % 'python')
print('%d %d' % (10, 20))
```

format() 메소드
---
[![024006.png](https://i.postimg.cc/5NxpQ6mX/024006.png)](https://postimg.cc/HjhbfWRm)
* 인수로 변수나 값을 표시하고, 해당 값이 표시될 위치를 중괄호({})로 표시하는 방식
```python
zipcode = '06236'
print('우편번호 : {}'.format(zipcode))

address = '''서울특별시 강남구
테헤란로 146'''

print('주소 : {addr}'.format(addr=address))

tel1, tel2, tel3 = '02', '123', '4567'
print('연락처 : {0}-{1}-{2}'.format(tel1, tel2, tel3))
```

f-string
---
```python
who = 'you'
how = 'happy'
print(f'{who} make me {how}')
```
```python
age = 25
print(f'내년엔 {age+1}살')
```

표준 입력
===
input() 함수
---
* 표준 입력 장치(키보드)로부터 입력받을 때 사용
```python
n = input('입력>>>')
print(n)
```

예제
---
* 사용자로부터 이름과 나이를 입력받아 출력하는 프로그램을 작성해주세요.

형 변환
---
* input() 함수를 사용할 때 주의점 : input() 함수는 모든 입력을 '문자열(str)'로 저장합니다.
```python
n = input('정수 입력>>>')
print(type(n))
```

문제
---
* 정수를 입력받고 그 자료형이 정수인지 확인하는 프로그램을 작성해주세요.

예제
---
```python
price = 50000
n = int(input('할부 개월 입력>>>'))
print('매달 내는 돈은 {}원 입니다.'.format(price/n))
```

문제
---
* 사용자로부터 2개의 실수를 입력 받고 합계를 출력
* 수학여행 여행지 조사 : 원하는 장소를 입력받아 동일한 입력은 무시하고 모든 입력을 저장 및 출력
* 학생은 3명으로 가정
* TIP : 중복을 피하려면? > set()
```python
여행지 입력>>>제주
여행지 입력>>>제주
여행지 입력>>>서울
조사한 여행지는 {제주, 서울} 입니다.
```

연산자와 우선순위
===
연산자
---
* 특정한 작업을 수행하기 위해서 사용하는 기호

| 종류 | 연산자 | 의미 |
| --- | --- | --- |
| 산술 | +, -, *, **, /, //, % | 숫자 연산 |
| 대입 | =, +=,-=, *=, **=, /=, //=, %= | 대입 및 복합 대입 |
| 관계 | >, >=, <, <=, ==, != | 크기 비교 |
| 논리 | and, or, not | 하나 이상의 논리적 처리 |
| 비트 | &, \|, ^, ~, <<, >> | 이진 연산 |
| 기타 | 참 if 조건식 else 거짓 | 조건 연산 |
| | in, +, * | 시퀀스 연산 |

연산자 우선순위
---
[![image.png](https://i.postimg.cc/fRWjht8j/image.png)](https://postimg.cc/8j3rR5Qj)
* 외울 필요가 없다.
* 먼저 처리하고 싶은 연산이 있으면 괄호()를 이용하자

기본 연산자
===
산술 연산자
---
[![image.png](https://i.postimg.cc/tgLGfVh2/image.png)](https://postimg.cc/hJbYQvZd)

문제
---
* 사용자에게 두 숫자를 입력받고 사칙연산을 하는 프로그램

대입 연산자
---
* 변수에 값을 저장하기 위해서 사용
* 수학시간에 사용하는 '같다'와 다른 의미

복합 대입 연산자
---
[![images-choi-ss-choco-post-7e519cad-e096-43e8-a0e4-65fc0a56e176-image.png](https://i.postimg.cc/02JWWHtR/images-choi-ss-choco-post-7e519cad-e096-43e8-a0e4-65fc0a56e176-image.png)](https://postimg.cc/VdmW54QD)
```python
piggy_bank = 0

money = 10000
piggy_bank += money
print('저금통에 용돈 {}원을 넣었습니다.'.format(money))
print('저금통에 현재 {}원 있습니다.'.format(piggy_bank))

snack = 2000
piggy_bank -= snack
print('저금통에서 과자 구입비 {}원을 뺐습니다.'.format(snack))
print('저금통에 현재 {}원 있습니다.'.format(piggy_bank))
```

관계 연산자
---
[![images-choi-ss-choco-post-722c9a1a-6851-497b-b745-81f82d724cf3-image.png](https://i.postimg.cc/rmBnM1mY/images-choi-ss-choco-post-722c9a1a-6851-497b-b745-81f82d724cf3-image.png)](https://postimg.cc/tZztzVFh)

논리 연산자
---
| 연산자 | 사용 방법 | 의미 |
| --- | --- | --- |
| and | a and b | a와b가 모두 참이면 True |
| or | a or b | a와 b중 하나라도 참이면 True |
| not | not a | a가 참이면 False, 거짓이면 True |

예제
---
```python
a = 15
print('{} > 10 : {}'.format(a, a>10))
print('{} < 10 : {}'.format(a, a<10))
print('{} >= 10 : {}'.format(a, a>=10))
print('{} <= 10 : {}'.format(a, a<=10))
print('{} == 10 : {}'.format(a, a==10))
print('{} != 10 : {}'.format(a, a!=10))
```

문제
---
* 사용자에게 두 숫자를 입력받고 비교하는 프로그램
* 두 자리 정수를 입력받아 십의자리와 일의 자리로 분리하여 출력하는 프로그램

3일차
===
조건문
===
[![03-1-if3.png](https://i.postimg.cc/xTCJnWwh/03-1-if3.png)](https://postimg.cc/K46v5svD)

if
---
```python
if 조건식:
조건식의 결과가 True일 때 실행문
```
```python
if a > 0:
print('양수')
```
* 파이썬은 코드 블록을 구성하는 중괄호{}가 없기 때문에 들여쓰기를 꼭 지켜야 합니다.

if-else
---
```python
if 조건식:
조건식의 결과가 True일 때 실행문
else:
조건식의 결과가 False일 때 실행문
```
[![flowchart-if-else.png](https://i.postimg.cc/26tpvL54/flowchart-if-else.png)](https://postimg.cc/jwykY5P5)

```python
if a >= 0:
print('양수')
else:
print('음수')
```

문제
---
* 나이를 입력받아 20살 이상이면 성인, 아니면 미성년자를 출력
```python
age = int(input('>>>'))
if age >= 20:
print()
else
print()
```

* 사용자로부터 입력받은 정수가 짝수인지 홀수인지 판별하는 프로그램

if-elif
---
[![image-9.png](https://i.postimg.cc/NFhKDMJH/image-9.png)](https://postimg.cc/k6cMXndJ)
```python
if a > 0:
print('양수')
elif a == 0:
print('0')
else:
print('음수')
```

문제
---
* 사용자로부터 입력받은 나이에 따라 다른 메시지를 출력하는 프로그램
* 나이가 18세 이상이면 "성인입니다.", 13세 이상 17세 이하이면 "청소년입니다.", 그 외에는 "어린이입니다."를 출력
* 사용자로부터 입력받은 세 정수 중 가장 큰 수를 출력하는 프로그램
```python
# 사용자 입력
num1 = int(input("첫 번째 정수를 입력하세요: "))
num2 = int(input("두 번째 정수를 입력하세요: "))
num3 = int(input("세 번째 정수를 입력하세요: "))

# if-else 문을 사용한 최대값 판별
if num1 >= num2 and num1 >= num3:
print("가장 큰 수는", num1, "입니다.")
elif num2 >= num1 and num2 >= num3:
print("가장 큰 수는", num2, "입니다.")
else:
print("가장 큰 수는", num3, "입니다.")
```
* 사용자로부터 연도(year)를 입력받아, 해당 연도가 윤년인지 평년인지 판별하는 프로그램
* 윤년은 4로 나누어 떨어지지만 100으로 나누어 떨어지지 않거나, 400으로 나누어 떨어지는 해
```python
# 사용자 입력
year = int(input("연도를 입력하세요: "))

# 윤년 판별
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
print(year, "년은 윤년입니다.")
else:
print(year, "년은 평년입니다.")
```

응용 예제
---
* 정수를 입력 받아 학점을 출력하는 프로그램
* 점수가 100~90점 A, 89~80점 B, 79~70점 C, 이하는 D
* 입력받은 정수가 3의 배수인지 판별
* 정수 3개를 입력받아 그 중 가장 큰 수를 출력

반복문
===
* 반복문 : 어떤 작업을 한 번이 아닌 계속해서 수행해야 할 때 사용

반목문의 종류
---
* 파이썬에는 2가지 반복문이 있습니다.
1. while
2. for

while
===
* 특정 조건을 만족하는 동안 반복해서 수행
* 기본 구조
```python
while 조건식:
반복실행문
```
* 조건식의 결과가 True면 반복실행문을 실행
* 반복실행문이 종료되면 다시 조건식으로 이동
* 조건식의 결과가 False면 멈춘다.
[![img.png](https://i.postimg.cc/vZqcCT4j/img.png)](https://postimg.cc/Sn9SMy77)
```python
# 무한루프
while True:
print('hello')
```
* while문의 조건식을 True로 하면 무한루프(infinite loop)
* 나중에 배우게 될 break문을 사용하여 해당 루프를 자주 사용한다.
* Tip : 무한반복 종료 = Ctrl + C (파이썬)
* 파이참에서 종료 = Ctrl + F2

* 예시
```python
# 1부터 10 사이의 모든 정수를 출력하는 프로그램
n = 1
while n <= 10:
print(n)
n += 1
```

예제
---
* 1부터 10 사이의 모든 정수를 역순으로 출력하는 프로그램
$$hide
```python
n = 10
while n >= 1:
print(n)
n -= 1

# 01 : 초기값
# 02 : 0이되면 종료
# 03 : 10~1 까지 1씩 감소
```
$$

* 사용자에게 정수를 입력받아 모두 리스트에 보관하는 프로그램
* 0을 입력하면 종료
* 이 때 0은 리스트에 보관하지 않는다.
$$hide
```python
my_list = []

n = int(input('정수 입력(0은 종료)>>>'))

while n != 0:
my_list.append(n)
n = int(input('정수 입력(0은 종료)>>>'))

print(my_list)
```
$$

while문의 중첩
---
* while문 내부에 또 다른 while문이 있는 상태
* 반복 처리해야 하는 대상이 2개 이상일 때 사용
[![7-1-2.jpg](https://i.postimg.cc/kGTLy050/7-1-2.jpg)](https://postimg.cc/1VNWmYwB)

```python
day = 1
while day <= 5:
hour = 1
while hour <= 3:
print('{}일차 {}교시'.format(day, hour))
hour += 1
day += 1
```

예제 문제
---
* 구구단 2단부터 9단까지 출력하는 프로그램
$$hide
```python
dan = 2
while dan <= 9:
n = 1
while n <= 9:
print(f'{dan} * {n} = {dan*n}')
n += 1
dan += 1
```
$$

응용 예제
---
* 1부터 100 사이의 모든 정수 중에서 7의 배수만 출력
* 구구단을 다음과 같이 출력
[![image.png](https://i.postimg.cc/Px3MVTmQ/image.png)](https://postimg.cc/k6S8BrY2)

for
===
* 값의 범위나 횟수가 정해져 있을 때 사용
* 기본 구조
```python
for 변수 in 반복가능객체:
반복수행문
```
* for문의 구조를 살펴보면 조건식이 존재하지 않고 '변수'와 '반복가능객체'만 사용하고 있다.

반복가능객체
---
* 반복해서 사용할 수 있는 객체. 객체 내부에 요소가 여러 개 저장되어 있고 한 번에 하나씩 꺼내서 사용할 수 있는 객체
* 문자열, 리스트, 튜플, 세트, 딕셔너리 등
```
1. 시퀀스 자료형 : 문자열, 리스트, 튜플
2. 비시퀀스 자료형 : 세트, 딕셔너리
```
* for문을 이용하면 시퀀스 자료형에 저장된 요소들은 순서대로 하나씩 사용
* 비시퀀스 자료형에 저장된 요소들은 순서와 상관없이 하나씩 사용

시퀀스 for문
===
for문과 문자열
---
```python
for 문자 in 문자열:
반복실행문
```
```python
for ch in 'Hello':
print(ch)
```

예제
---
* 문자열 자료형의 비밀번호를 입력받아서 숫자와 문자가 모두 포함되었는지 확인하는 프로그램
* 모두 포함하면 "가능한 비밀번호 입니다.", 아니면 "불가능한 비밀번호 입니다."를 출력
* 변수.isalpha() : 변수가 문자인 경우 True
* 변수.isnumeric() : 변수가 숫자인 경우 True

```python
pwd = input('비밀번호>>>')

ch_count = 0
num_count = 0

for ch in pwd:
if ch.isalpha():
ch_count += 1
elif ch.isnumeric():
num_count += 1

if ch_count > 0 and num_count > 0:
print('가능한 비밀번호')
else:
print('불가능한 비밀번호')
```

for문과 리스트
---
* 리스트 순회 : for문과 리스트를 활용하면 리스트의 각 요소를 순차적으로 사용할 수 있다.
```python
for 요소 in 리스트:
반복실행문
```
```python
for item in ['가위','바위','보']:
print(item)
```

* 리스트 내포
* 리스트를 생성할 때 for문을 사용할 수 있다.
```python
리스트 = [표현식 for 변수 in 반복가능객체]

# 반복가능객체의 요소를 하나씩 변수에 저장
# 해당 변수를 다시 표현식으로 처리
# 그 결과를 리스트에 저장
```
```python
[n * 2 for n in [1,2,3]]
```

for문과 튜플
---
* 기본 형식
```python
for 요소 in (튜플):
반복실행문
```
* 예시
```python
four_seasons = ('Spring', 'Summer', 'Autumn', 'Winter')
for season in four_seasons:
print(season)
```

for문과 range() 함수
---
* range() 함수는 정수 범위를 만들어 낼 때 유용한 함수
* range() 함수의 기본 형식
* range(start, stop, step)
* start는 시작 값, stop은 종료 값, step은 증가 또는 감소 폭을 의미
```python
range(5)
range(1, 11)
range(1, 10 ,2)
```
```python
for n in range(1, 11):
print(n)
```

예제 문제
---
* 출력하고자 하는 구구단을 입력받아 출력하는 프로그램

4일차
===
비시퀀스와 for문
===
for문과 세트
---
* 세트는 비시퀀스 자료형이기 때문에 순서가 없다.
* 하지만 저장된 요소를 순서에 상관없이 꺼내어 사용할 수 있다.
```python
for item in {'가위', '바위', '보'}:
```
* 실행할 때 마다 다른 결과가 나타난다.

for문과 딕셔너리
---
* 딕셔너리 또한 비시퀀스 자료형이다.
* value만으로 구성된 리스트나 튜플과 같은 시퀀스 자료형과 다른 for문 사용법을 가집니다.
```python
person = {
'name':'에밀리',
'age':20
}

for item in person:
print(item)
```
* 실행 결과 key를 전달하는 것을 확인할 수 있다.
* value 사용 방법
```python
for key in person:
print(person[key])

for key in person:
print(person.get(key))
```

문제
---
1. 1부터 5 사이의 존재하는 모든 정수를 역순으로 출력
2. 사용자로부터 임의의 양의 정수를 하나 입력받고 1부터 입력받은 정수까지 합계를 출력

break
===
* while문이나 for문과 같이 반복문을 강제로 종료할 때 사용
* 반복문 안에서 break를 만나면 반복이 종료됩니다.
```python
n = 1
while True:
print(n)
if n == 10:
break
n += 1
```

예제
---
* 대한민국의 수도를 맞히는 프로그램
* 정답을 작성하기 전 까지 프로그램은 종료되지 않습니다.
```python
while True:
city = input('한국의 수도>>>')
if city == '서울' or city == 'seoul' or city == 'SEOUL':
print('정답')
break
else:
print('다시 입력')
```

* 사용자에게 취미를 입력받아 리스트에 저장하는 프로그램
* 아무것도 입력하지 않고 엔터를 하면 종료
$$hide
```python
hobbies = []
while True:
hobby = input('취미(종료=엔터)>>>')
if hobby == '':
print('종료')
break
else:
hobbies.append(hobby)

print(hobbies)
```
$$

continue
===
* 반복문의 시작 지점으로 제어의 흐름을 옮기는 역할
* while문에서 conticue문을 만나면 조건식으로 이동하여 조건식의 결과가 True면 실행합니다.
* for문에서 conticue문을 만나면 반복가능객체로 이동하여 꺼낼 요소가 남아있으면 실행합니다.
```python
total = 0
for a in range(1,101):
if a % 3 == 0: # 3의 배수인지 검사
continue
total += a
print(total)

# 결과 : 3367
```

예제
---
* 사용자로부터 과일 이름을 입력 받아 리스트에 보관하는 프로그램
* 총 5개의 과일 이름을 보관
* 리스트에는 사과, 감귤을 미리 입력
* 중복된 과일은 저장할 수 없다.
* 만약 중복된 과일을 입력하면 다른 과일을 입력 받습니다.

$$hide
```python
fruits = ['사과','감귤']
count = 3

while count>0:
fruit = input('>>>')
if fruit in fruits:
print("이미 리스트에 있습니다.")
continue
fruits.append(fruit)
count -= 1
print(f'입력이 {count}남음')

print(f'5개의 과일 {fruits}')
```
$$

* 사용자에게 5개의 양의 정수를 입력 받아 그 합계를 구하는 프로그램
* 0 이하의 값을 입력하면 재입력을 요구

$$hide
```python
count = 0
total = 0

while count < 5:
n = int(input(f'{count+1}번째 정수>>>'))
if n <= 0:
print('0이하는 안됩니다.')
continue
total += n
count += 1
print(f'합계:{total}')
```
$$

내장함수
===
* 파이썬 인터프리터에는 항상 사용할 수 있는 많은 함수가 내장됨
* 이를 내장함수라고 함
* 우리는 이미 print()함수나 input()함수 등 내장 함수를 사용해 왔다.
* 사용 빈도가 높은 함수를 알아보자.

문자열 내장 함수
===
chr() 함수
---
* 모든 문자는 자신만의 코드 값을 가지고 있다. 이를 '문자 코드'라고 함.
* 아스키코드, 유니코드
* chr()함수는 특정 문자의 유니코드 값을 전달하면 해당 유니코드 값을 가진 문자로 반환
* 유니코드 값의 유효 범위는 0에서 1,114,111(16진수로 0x10FFFF)
```python
chr(48) # 0
chr(49) # 0

chr(65) # A
chr(66) # B

chr(97) # a
chr(98) # b
```

ord() 함수
---
* 하나의 문자를 인자로 받고 해당 문자에 해당하는 유니코드 정수를 반환
```python
ord('A') # 65
ord('한') # 54620
```

eval() 함수
---
* 실행하고자 하는 표현식을 문자열로 전달하면 결과값을 반환
```python
eval('100+200') # 300

a = 10
eval(a * 5) # 50

eval('min(1, 2, 3)') # 1
```

format() 함수
---
* 전달받은 인수와 포멧 코드에 따라 형식을 갖춘 문자열을 반환
* 포멧 코드는 전달하지 않을 수도 있음, 이 경우 str()함수를 호출한 것과 동일한 효과를 나타냄
* print() 함수에서 사용하던 format() 메소드와는 다른 함수이다.
```python
format(10000)
# 결과 : '10000'
#str(10000)과 같다.

format(10000, '_')
# 결과 : '10_000'
# 천 단위 구분 기호로 밑줄 사용

format(10000, ',')
# 결과 : '10,000'
# 천 단위 구분 기호로 쉼표를 사용
```

str() 함수
---
* 전달받은 인수를 문자열로 변환
```python
str(10) # '10'

str(1.5) # '1.5'

str(True) # 'True'
```

예제
---
* 사용자로부터 계산식을 입력받아 결과 출력

$$hide
```python
expr = input('>>>')
result = eval(expr)
print(f'{expr}={result}')
```
$$

내장함수 문제
---
* 사용자로부터 계산식을 입력받아 결과를 출력하는 프로그램
* [내장함수 문제 정답](https://replit.com/@g2jkj0274/py5naejanghamsu1)

* chr() 함수 문제
1. 유니코드 값 65와 97에 해당하는 문자를 출력하는 프로그램
2. 유니코드 값 33에서 40에 해당하는 모든 문자를 출력하는 프로그램
3. 유니코드 값 44032에서 44035에 해당하는 모든 문자를 출력하는 프로그램
* ord() 함수 문제
1. 문자 'A'와 'a'에 해당하는 유니코드 값을 출력하는 프로그램
2. 사용자로부터 문자를 입력받아 해당 문자의 유니코드 값을 출력하는 프로그램
3. 문자열 'Hello'의 각 문자에 해당하는 유니코드 값을 출력하는 프로그램
* eval() 함수 문제
1. 사용자로부터 두 수를 입력받아 더한 결과를 출력하는 프로그램
2. 사용자로부터 수식을 입력받아 그 결과를 출력하는 프로그램
3. 사용자로부터 리스트를 입력받아 그 리스트의 최대값을 출력하는 프로그램
* format() 함수 문제
1. 숫자 1234567을 천 단위로 쉼표를 사용하여 출력하는 프로그램
2. 숫자 987654321을 천 단위로 밑줄을 사용하여 출력하는 프로그램
3. 숫자 1234.5678을 소수점 이하 둘째 자리까지 표시하여 출력하는 프로그램
* str() 함수 문제
1. 정수 10을 문자열로 변환하여 출력하는 프로그램
2. 실수 3.14159를 문자열로 변환하여 출력하는 프로그램
3. 논리값 True와 False를 문자열로 변환하여 각각 출력하는 프로그램
* [내장함수 정답 모음](https://replit.com/@g2jkj0274/py5naejanghamsu2)

숫자 내장 함수
===
abs()
---
* 전달된 인수(정수 or 실수)의 절대값을 반환
```python
abs(10) # 10
abs(-10) # 10
```

divmod()
---
* 전달된 두 인수를 나누어 몫과 나머지를 한 쌍의 결과로 반환
* 몫과 나머지는 튜플로 반환됨
```python
divmod(10, 3) # (3, 1)

type(divmod(10, 3)) # class 'tuple'
```

float()
---
* 전달된 인수(숫자 or 문자열)를 실수로 만들어 반환
* 전달된 인수가 없으면 0.0을 반환
```python
float(3) # 3.0

float('3.5') # 3.5
```

int()
---
* 전달된 인수(숫자 or 문자열)를 정수로 만들어 반환
* 전달된 인수가 없으면 0을 반환
```python
int(3.9) # 3

int('3') # 3
```

max()
---
* 전달된 인수 중 가장 큰 값을 반환
```python
max(1, 10) # 10

li = [5, 3, 4, 2, 1]
max(li)
# 5
```

min()
---
* 전달된 인수 중 가장 작은 값을 반환
```python
min(1, 10) # 1

li = [5, 3, 4, 2, 1]
min(li)
# 1
```

pow()
---
* 전달된 두 인수의 거듭제곱을 반환
* 연산자 중에서 거듭제곱 연산자 **과 같다.
```python
pow(10, 2) # 100

pow(10, 3) # 1000

pow(10, -2) # 0.01

pow(10, -3) # 0.001
```

round()
---
* 전달된 인수를 이용해 반올림한 값을 반환
* 전달된 인수가 하나이면 정수로 반올림
* 전달된 인수가 2개이면 두 번째 전달한 인수만큼 소수점을 남긴다.
```python
round(1.5) # 2

round(1.4) # 1

round(1.55, 1) # 1.6

round(2.675, 2) # 2.67
```
* 마지막 실행 결과를 보면 2.68 대신 2.67이 출력됨.
* 이는 소수점이 있는 실수(float)는 표현 방식의 한계로 인해 언제나 정확하게 표현되지 않음.
* 이러한 특성으로 인해 나타난 현상이며, 놀랍게도 버그(bug)가 아니다.

sum()
---
* 전달된 리스트나 튜플과 같은 반복가능객체의 합계를 반환
* 숫자가 아닌 값을 전달하면 에러 발생
```python
list1 = [1,2,3,4,5]
sum(list1) # 15

list2 = ['h','e','l','l','o']
sum(list2) # 에러
```

예제
---
* 빵집에서 10000원을 주고 3000원 가격의 빵을 구매했을 때 몇 개의 빵을 사고 얼마의 거스름돈이 남았는지 작성하세요.

시퀀스 내장 함수
===
* 시퀀스? : 데이터 구조 중 하나로 데이터를 순서대로 나타낸 것

enumerate()
---
* 리스트와 함께 사용할 수 있다.
* 해당 함수를 사용하면 리스트에 저장된 요소와 해당 요소의 인덱스가 튜플 형태로 함께 추출됨
```python
for item in enumerate([리스트]):
반복실행문

for item in enumerate(['가위','바위','보'])
print(item)

# 실행결과
(0, '가위')
(1, '바위')
(2, '보')
```
* 실행 결과를 통해서 item은 튜플이며, 각 튜플의 첫 번째 요소는 리스트의 인덱스, 두 번째 요소는 리스트에 저장된 요소임을 확인
* enumerate() 함수가 튜플을 반환하는 것을 알고 있기 때문에 언패킹(unpacking)을 이용하여 다음과 같이 코드 작성 할 수 있다.
```python
for idx, element in enumerate(['가위','바위','보'])
print(idx, element)

# 실행결과
0 가위
1 바위
2 보
```

range()
---
* 전달된 인수값에 따라 시퀀스 자료형의 데이터를 생성하는 함수
* 특정 범위의 값을 생성하기 때문에 범위 생성자라고도 함
* 주로 for문에서 사용, 원하는 횟수만큼 for문 내부의 실행문을 실행
* range() 함수의 결과 자료형은 range이기 때문에 list() 함수나 tuple() 함수를 통해서 자주 사용하는 리스트나 튜플로 변환해서 사용
```python
range(stop)
range(start, stop)
range(start, stop, step)
```
* range(stop) : 0부터 stop 사이의 모든 정수가 생성, 생성되는 변수를 n이라고 하면 n의 범위는 0 <= n < stop
* range(start, stop) : start부터 stop 사이의 모든 정수가 생성, 생성되는 변수를 n이라고 하면 n의 범위는 start <= n < stop
* range(start, stop, step) : start부터 stop 사이의 정수 중에서 step만큼의 차이를 가지고 있는 정수 생성

len()
---
* 전달된 객체의 길이(항목 수)를 반환
```python
li = ['a', 'b', 'c', 'd']
len(li) # 4

d = {'a':'apple', 'b':'banana'}
len(d) # 딕셔너리는 키:값으로 구성된 한 쌍을 하나의 데이터로 본다.

len(range(10)) # 10
# range()로 생성된 값은 0~9 입니다.

len(range(1, 10)) # 9
# range()로 생성된 값은 1~9 입니다.
```
sorted()
---
* 함수에 전달된 반복가능객체의 오름차순 정렬 결과를 반환.
* reverse = True 옵션을 추가 할 경우 내림차순 정렬 결과 반환
```python
my_list = [6,3,1,2,5,4]
sorted(my_list) # [1,2,3,4,5,6]

sorted(my_list, reverse=False) # [1,2,3,4,5,6]
sorted(my_list, reverse=True) # [6,5,4,3,2,1]
```
* 주의점
* sorted() 함수를 사용하면 정렬된 결과를 반환할 뿐 실제로 전달된 객체가 정렬되는 것이 아니다.
* 실제로 객체를 정렬하려면 sorted() 함수의 결과를 객체 자신에게 다시 전달해야 함
```python
my_list = [6,3,1,2,5,4]
sorted(my_list) # [1,2,3,4,5,6]

my_list # [6,3,1,2,5,4]

my_list = sorted(my_list)
```

zip()
---
* 전달된 여러 개의 반복가능객체의 각 요소를 튜플로 묶어서 반환
* 전달된 반복가능객체들의 길이가 서로 다르면 길이가 짧은 반복가능객체를 기준으로 동작
```python
names = ['james', 'emily', 'amanda']
scores = [60,80,80]
for student in zip(names, scores):
print(student)

# 실행결과
('james', 60)
('emily', 70)
('amanda', 80)
```
* 각 요소를 순서대로 하나씩 튜플로 구성한 뒤 반환한 것을 알 수 있다.
* 튜플은 언패킹이 가능하기 때문에 다음과 같은 모습으로 구성할 수도 있다.
```python
names = ['james', 'emily', 'amanda']
scores = [60,80,80]
for name, score in zip(names, scores):
print('{}'의 점수는 {}점입니다.', format(name,score))
```

메소드
===
* 특정 객체(object)가 가지고 있는 함수를 의미
* 특정 데이터 자료형에 포함되어 있는 함수
* 함수와 메소드는 같은 개념
* 차이가 있다면 호출 방식이 다르다.
* 함수 : 독립적으로 호출 가능
* 메소드 : 특정 객체를 통해서만 호출할 수 있다.

메소드 호출 방식
---
```python
# 함수의 경우
name = input('이름을 입력 하세요')
print('이름은',name,'입니다')

# 메소드의 경우
my_list = []
my_list.append('apple')
my_list.pop()
```
* 객체 뒤에 마침표(.)를 붙이고 호출됨

문자열 메소드
===
format()
---
* 문자열 정렬에 사용
```python
print("10자리 왼쪽 정렬 '{:<10d}'".format(123))
print("10자리 오른쪽 정렬 '{:>10d}'".format(123))
print("10자리 가운데 정렬 '{:^10d}'".format(123))

print("10자리 왼쪽 정렬 '{:*<10d}'".format(123))
print("10자리 오른쪽 정렬 '{:*>10d}'".format(123))
print("10자리 가운데 정렬 '{:*^10d}'".format(123))
```
* <, >, ^는 정렬 옵션
* 10d는 10자리의 필드 폭을 의미
* 정렬 옵션 앞에 채움문자를 지정하면 공백 대신 채움 문자가 빈자리를 채움

**예제 문제**
* 문자열 변수 name과 age를 사용하여 "이름은 홍길동이고, 나이는 25세입니다."라는 문장을 출력하는 코드

count()
---
* 문자열 내부에 포함된 특정 문자열의 개수를 반환한다.
```python
s = '내가 그린 기린 그림은 목 긴 기린 그림이고, 네가 그린 기린 그림은 목 짧은 기린 그림이다.'
s.count('기린')
```

* 인덱스를 지정해서 검색 범위를 지정할 수 있다.
```python
s = 'best of best'
s.count('best', 5)
```
* count() 메소드에 전달한 첫 번째 인수 'best'를 인덱스 5부터 검사
* 따라서 첫 번째 'best'는 검색 대상에서 제외

```python
s = 'best of best'
s.count('best', -7)
```

| b | e | s | t | | o | f | | b | e | s | t |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
| -12 | -11 | -10 | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
* 마이너스 인덱스를 사용하더라도 검색 방향은 기존과 동일하게 왼쪽 -> 오른쪽 방향이다.

**예제 문제**
* 다음 문자열 text에서 문자 a가 몇 번 등장하는지 세는 코드
* text = "banana apple avocado"

find()
---
* 문자열 내부에 포함된 특정 문자열을 찾을 때 사용
* 찾고자 하는 문자열이 있으면 문자열이 처음으로 나온 위치, 즉 인덱스(index)를 반환
```python
s = 'apple'
s.find('p')
```
* find() 메소드는 찾는 문자열이 없는 경우 -1을 반환
```python
s = 'apple'
s.find('z')
```
* count() 메소드와 마찬가지로 인덱스를 이용해서 검색 범위를 지정 할 수 있다.
* 인덱스를 지정하면 지정한 인덱스부터 찾는다.
```python
s = 'best of best'
s.find('best', 5)
```
* find()메소드와 다른 방향으로 찾는 rfind() 메소드도 있다.
* rfind() 메소드는 right와 find를 합친 이름으로 오른쪽부터 찾는다는 의미
```python
s = 'best of best'
s.rfind('best')
```

**예제 문제**
* 다음 문자열 sentence에서 "world"가 처음 등장하는 위치를 출력하는 코드
* sentence = "Hello world! Welcome to the world of Python."

index()
---
* find() 메소드와 같은 역할을 수행
* 두 메소드의 차이점
* find() : 찾는 문자열이 없는 경우 -1
* index() : 찾는 문자열이 없는 경우 오류
```python
s = 'apple'
s.index('p')

s = 'apple'
s.index('z')
# ValueError 발생 확인할 수 있다.
```

**예제 문제**
* 다음 문자열 sentence에서 문자 "e"가 처음 등장하는 위치를 출력하는 코드
* sentence = "Hello world! Welcome to the world of Python."

대소문자 변환 메소드
---
* 영문 대소문자를 변환해 주는 메소드들

| 메소드 | 의미 |
| --- | --- |
| upper | 모두 대문자로 반환 |
| lower | 모두 소문자로 반환 |
| capitalize | 첫 글자는 대문자로 반환하고 나머지는 소문자로 반환 |

```python
s = 'best of best'
s.upper()

s.lower()

s.capitalize()
```
* 파이썬은 영문 대소문자를 구분하기 때문에 apple, APPLE, Apple 모두 다르게 인식한다.
* 이 세 단어를 모두 같은 단어로 인식하게 하려면 해당 메서드를 사용하여 통일시킨 뒤 처리하면 된다.

**예제 문제**
* 다음 문자열 text를 모두 대문자로 변환한 결과를 출력하는 코드
* text = "hello world"

join()
---
* 인수로 전달한 반복가능객체(문자열, 리스트)의 각 요소 사이에 문자열을 포함시켜 새로운 문자열을 만들고 그 결과를 반환
```python
'-'.join('python')

# 리스트의 경우
'+'.join(['a','b','c','d','e'])
```
* 포함하는 문자 없이 단순 연결하는 방법
```python
''.join(['x','y','z'])
```
* 딕셔너리의 경우
```python
''.join({'a':'apple', 'b':'banana'})
```
* 딕셔너리의 key를 연결하는 것을 알 수 있다.
* join() 메소드에서는 딕셔너리의 value는 사용하지 않는다.

**예제 문제**
* 다음 문자열 리스트 words를 공백으로 구분하여 하나의 문자열로 결합한 결과를 출력하는 코드
* words = ["Hello", "world", "welcome", "to", "Python"]

split()
---
* 하나의 문자열을 여러 개의 문자로 분리해서 저장한 리스트를 반환
* 기본적으로 공백 문자를 기준으로 분리하지만, 특정 문자열을 기준으로 분리할 수 있다.
```python
# 공백 문자를 기준으로 분리
s = 'Life is too short'
s.split()
# 결과 : ['Life', 'is', 'too', 'short']
# 아무런 인수도 전달하지 않으면 공백을 기준으로 각 문자열이 분리되어 리스트에 저장된다.
```
```python
# 특정 문자열을 기준으로 분리
s = '010-1234-5678'
s.split('-')
# 결과 : ['010', '1234', '5678']
```
* CSV(Comma Separated Value) : 콤마(,)로 구분된 데이터
* 데이터를 주고받기 위한 표준 형식
* 파이썬은 split() 메소드에 콤마를 인수로 전달하여 쉽게 CSV데이터를 리스트로 변환해서 사용 할 수 있다.
```python
s = '제임스,25,남,서울'
s.split(',')
```

* split() 요소 추출
```python
s = '제임스,25,남,서울'
s.split(',')[0]
```

**예제 문제**
* 다음 문자열 sentence를 공백 기준으로 분리하여 리스트로 만드는 코드
* sentence = "Hello world welcome to Python"

replace()
---
* 문자열의 일부 문자열을 다른 문자열로 바꾼 결과를 반환
```python
s = 'Life is too short'
s.replace('short', 'long')
```
* 전달한 인수 중 첫 번째 인수를 두 번째 인수로 바꾼 것을 확인할 수 있다.

* replace() 메소드는 어떤 문자열을 제거하기 위한 용도로도 사용할 수 있다.
```python
s = '010-2345-6789'
s.replace('-','')
```

**예제 문제**
* 다음 문자열 text에서 "Python"을 "Java"로 교체한 결과를 출력하는 코드
* text = "I love Python programming"

불필요한 문자열 제거 메소드
---
* 문자열의 양 끝에 불필요한 문자열을 제거하는 메소드들이 있다.
* 양 끝의 문자열은 제거할 수 있지만, 중간에 포함된 문자열은 제거할 수 없다.

| 메소드 | 의미 |
| --- | --- |
| lstrip | 왼쪽 끝에 있는 불필요한 문자열을 제거한 결과를 반환. left strip의 줄임말 |
| rstrip | 오른쪽 끝에 있는 불필요한 문자열을 제거한 결과를 반환. right strip의 줄임말 |
| strip | 양쪽 끝에 있는 불필요한 문자열을 제거한 결과를 반환. |
```python
s = ' apple'
len(s)
# 10

s.lstrip()
# 'apple'
len(s.lstrip())
# 5
```
* 공백 이외에 불필요한 문자열을 직접 지정하여 제거할 수 있다.
```python
s = ' 커피 종류 선택 > 커피, 잔돈 반환

사용자 함수 용어
===
함수 용어 정리
---
```
1. 함수 정의 : 사용자 함수를 새로 만드는 것을 의미
2. 인수 : 사용자 함수에 전달할 입력(input) = argument
3. 매개변수 : 인수를 받아서 저장하는 변수 = parameter
4. 반환값 : 사용자 함수의 출력(output)을 의미 = return
5. 함수 호출 : 만들어진 사용자 함수를 실제로 사용하는 것
```

함수 정의
---
* 함수 정의란? : 함수를 만드는 것
* 함수를 정의하려면 def 키워드를 이용해야 합니다.
```python
def 함수 이름(매개변수):
본문
return 반환값
```
* 함수 이름은 개발자 마음대로
* 매개변수는 함수에 전달되는 인수(입력)가 저장될 변수
* 전달 인수가 없으면 없어도 된다.
* 함수의 본문은 모두 들여쓰기 문법 적용
* return 부분은 함수의 반환값이 있는 경우 반드시 작성하고, 없으면 생략 가능

함수 호출
---
* 함수 호출 방법
```
변수 = 함수 이름(인수)
```
* 인수와 반환값의 유무에 따라 달라집니다.
* 인수가 없으면 생략 가능, 반환값이 없다면 호출 결과를 저장할 변수 생략 가능
```python
def welcome():
print('hello')
print('hi')

welcome()
```
```python
welcome()

def welcome():
print('hello')
print('hi')
```

인수와 매개변수
===
* 함수로 전달되는 인수를 저장하는 변수 = 매개변수

인수가 있는 함수
---
```python
def introduce(name, age):
print(f'내 이름은{name}이고 나이는{age}입니다.')

introduce('james', 25)
```

가변 매개변수
---
* 함수로 전달해야 하는 인수의 개수가 정해지지 않아도 매개변수를 선언할 수 있다.
* 가변 매개변수를 만드는 키워드 : 애스터리스크(*)
* 매개변수 앞에 *를 붙이면 가변 매개변수가 되면서 전달되는 모든 인수를 하나의 튜플로 만들어 줍니다.
```python
def show(*args):
for item in args:
print(item)

show('python')
show('happy','birthday')
```

디폴트 매개변수
---
* 매개변수로 전달되는 인수가 없는 경우에 기본적으로 사용할 수 있도록 설정할 수 있다.
* 이것을 디폴트 매개변수라고 합니다.
```python
def greet(message='hi'):
print(message)

greet()
greet('hello')
```
* 디폴트 매개변수 사용시 주의점!
```python
def greet(message='안녕하세요', name):
print(f'{name}님 {message}')

greet('김철수')
```
* 디폴트값 '안녕하세요'를 사용하고 '김철수'가 name에 전달하는 것 처럼 보임
* 하지만 실제로는 '김철수'라는 값을 message에 저장
* name에 전달되는 값이 없어 오류가 발생
```python
def greet(name, message='안녕하세요'):
print(f'{name}님 {message}')

greet('김철수')
```

예제
---
* 전달된 모든 인수를 모두 더해서 합계를 출력하는 프로그램
$$hide
```python
def adder(*args):
print(f'{args}의 합은 {sum(args)}입니다')

adder(1, 2, 3, 4)
```
$$

반환값(return)
===
반환값이 있는 함수
---
```python
def address():
str = '우편번호 1234\n'
str += '서울시 어디구 어디동'
return str

print(address())
```

다중 반환
---
* 파이썬은 여러 개의 반환값도 처리할 수 있다.
```python
def calculator(*args):
return sum(args), sum(args) / len(args), max(args), min(args)

a, b, c, d = calculator(1, 2, 3, 4, 5)

print(a)
print(b)
print(c)
print(d)
```
* 반환값이 4개로 보이지만 사실 1개의 튜플로 만들어서 반환 중입니다.
* 아래처럼 작성해도 같은 결과
```python
def calculator(*args):
return sum(args), sum(args) / len(args), max(args), min(args)

result = calculator(1, 2, 3, 4, 5)

print(result[0])
print(result[1])
print(result[2])
print(result[3])
```

함수의 종료를 위한 return
---
```python
def charge(energy):
if energy < 0:
print('0보다 작은 에너지는 X')
return
print('에너지 충전')

charge(1)
charge(-1)
```
* 반환값이 생략된 상태로 사용되는 return문은 어떤 값을 반환한다는 의미가 아닌 현재 실행 중인 함수의 실행을 종료 한다는 의미
* 자주 사용하니 알아두면 좋습니다.

예제
---
* 커피 자판기 프로그램
* 자판기에 돈과 주문할 커피를 전달
* 주문할 수 있는 종류와 가격 : 아메리카노=1000, 카페라떼=1500, 카푸치노=2000
* 없는 커피 주문시 입력한 돈 반환
* 구매 금액이 부족하면 돈 반환
* 정상 주문이면 주문한 커피와 잔돈 반환

$$hide
```python
def coffee_machine(money, pick):
print(f'{money}원에 {pick} 선택')
menu = {
'아메리카노':1000,
'카페라떼':1500,
'카푸치노':2000
}
if pick not in menu:
print(f'{pick}은 메뉴에 없음')
return money, '없는 메뉴'
elif menu[pick] > money:
print(f'{pick}는 {menu[pick]}원 입니다.')
return money, '금액 부족'
else:
return money-menu[pick], pick

order = input('커피 선택[아메리카노, 카페라떼, 카푸치노]>>>')
pay = int(input('투입할 금액>>>'))

change, coffee = coffee_machine(pay, order)
print(f'잔돈:{change}, 커피:{coffee}')
```
$$

지역변수와 전역변수
===
지역변수
---
* 함수 내부에서 선언한 변수는 함수 내부에서만 사용할 수 있는 지역변수(local variable)
* 함수 외부에서는 지역변수에 접근할 수 없다.
```python
def f():
a = 10
print('f() 내부: {}'.format(a))

f()
print('f() 외부: {}'.format(a))
```

전역변수
---
* 함수 외부에서 선언한 변수는 함수 내부나 함수 외부에서 모두 사용 가능
* 이런 변수를 전역변수(global variable)라고 합니다.
```python
b = 10
def f():
print('f() 내부: {}'.format(b))

f()
print('f() 외부: {}'.format(b))
```

global 키워드
---
* 함수 내부에서 전역 변수를 수정하려면 global 키워드를 사용
```python
x = 10 # 전역 변수

def 함수():
global x
x = 5 # 전역 변수 수정

함수()
print(x) # 출력 결과: 5
```

모듈과 import
===
* 모듈이란? : 한 마디로 파이썬 파일(.py)
* 언제든지 사용할 수 있도록 변수나 함수 또는 클래스를 모아 놓은 파일을 모듈이라고 함
* 모든 파이썬 파일은 모듈이 될 수 있다.

모듈의 생성
---
* 직접 모듈을 만들어보자
* 생성할 모듈은 C:\PythonStudy\Section12 디렉터리에 converter.py라는 이름으로 저장하자
```python
MILES = 0.621371
POUND = 0.00220462

def kilometer_to_miles(kilometer):
return kilometer * MILES

def gram_to_pounds(gram):
return gram * POUND
```
* MILES와 POUND는 단위 변환에서 사용하는 변수
* 각각 킬로미터를 마일, 그램을 파운드로 변환하는 함수
```python
miles = kilometer_to_miles(160)
print(miles)

pounds = gram_to_pounds(1000)
print(pounds)
```

모듈의 사용
---
* converter.py 모듈에 저장된 함수를 사용하는 방법
* 우선 모듈을 사용하기 위해서는 해당 모듈을 import해야 한다.
* import 방법은 크게 2가지가 있다.
* import? : 사전적 의미로 '수입', 프로그래밍에서는 외부 파일 등을 불러오는 것을 import라고 함

* 1번 방법
* 모듈 전체를 가져오는 방법
```python
import 모듈
```
* 이 방법은 모듈에 저장된 모든 클래스나 함수를 사용하고자 할 때 사용
* 가장 쉽게 모듈을 가져오는 방법입니다.

* 2번 방법
* 모듈에 포함된 함수 중에서 특정 함수만 골라서 가져오는 방법
```python
# 모듈에서 함수 1개만 가져오는 방법
from 모듈 import 함수

# 모듈에서 2개 이상의 함수를 가져오는 방법
from 모듈 import 함수1, 함수2

# 모듈의 모든 함수를 가져오는 방법
from 모듈 import *
```

* 두 방식의 차이를 알아봅시다.
* 우선 새로운 파이썬 파일을 만듭니다.
* 저장할 디렉더리 : C:\PythonStudy\Section12
* 생성할 파일명 : module1.py
* 이전에 생성한 converter.py와 같은 위치
* 다음과 같은 module1.py 파일 생성
```python
import converter

miles = converter.kilometer_to_miles(150)
print('150km={}miles'.format(miles))

pounds = converter.gram_to_pounds(1000)
print('1000g={}pounds'.format(pounds))

# import한 모듈에 포함된 함수는 마침표(.) 표기법을 이용해서 모듈.함수() 형식으로 호출해야 정상적으로 실행됨
```
* 또한 import문은 코드를 작성할 때 가정 먼저 작성하도록 파이썬에서 권장합니다.
* 항상 먼저 작성하세요.
* 다음으로 converter.py 모듈에서 kilometer_to_miles() 함수만 import
* 새로운 파이썬 파일을 만들어 실행
* 저장할 디렉더리 : C:\PythonStudy\Section12
* 생성할 파일명 : module2.py
```python
from converter import kilometer_to_miles

miles = kilometer_to_miles(150)
print('150km={}miles'.format(miles))
```
* 여기서 중요한 특징은 함수를 호출하는 방법입니다.
* 전체 모듈을 import하는 경우 : 모듈.함수()와 같은 형식으로 함수를 호출할 때 마다 모듈을 명시해야 함
* 일부 함수만 import하는 경우 : 함수()와 같이 함수만 호출하면 된다. (어떤 모듈인지 명시할 필요 없다.)

* 이와 같은 함수 호출의 차이가 있기 때문에 모듈 전체를 import하기 위해서 from절을 활용.
* 아래의 내용 진행
* 저장할 디렉더리 : C:\PythonStudy\Section12
* 생성할 파일명 : module3.py
```python
from converter import *

miles = kilometer_to_miles(150)
print('150km={}miles'.format(miles))
```
* 이와 같이 처리하면 모듈의 모든 함수를 사용할 수 있지만 from절을 활용했기 때문에 함수를 호출할 때마다 모듈을 명시할 필요가 없다.

별명 사용하기
---
* 모듈이나 함수를 import하는 경우에 원래 이름 대신 별명(alias)을 지정하고 사용할 수 있다.
* 모듈이나 함수의 이름이 긴 경우 주로 짧은 별명을 지정하고 긴 본래 이름 대신 사용
* 별명을 지정할 때는 as 키워드를 사용한다.
* 저장할 디렉더리 : C:\PythonStudy\Section12
* 생성할 파일명 : module4.py
```python
import converter as cvt

miles = cvt.kilometer_to_miles(150)
print('150km={}miles'.format(miles))

pounds = cvt.gram_to_pounds(1000)
print('1000g={}pounds'.format(pounds))

# converter 모듈에 cvt라는 별명을 지정한 뒤 사용하는 것을 확인할 수 있다.
```
* 모듈뿐만 아니라 함수에도 별명을 지정할 수 있다.
* 저장할 디렉더리 : C:\PythonStudy\Section12
* 생성할 파일명 : module5.py
```python
from converter import kilometer_to_miles as k_to_m

miles = k_to_m(150)
print('150km={}miles'.format(miles))

# kilometer_to_miles 함수의 이름에 k_to_m이라는 별명을 지정한 모습
```
* 파이썬으로 개발하다 보면 몇몇 모듈이나 함수는 관례적으로 정해진 별명을 지정한 뒤 사용하는 것을 볼 수 있다.
* as를 사용하지 않겠다는 생각이 들더라도 다른 사람들이 작성한 코드를 해석하기 위해서 반드시 알고 있어야 하는 내용이다.

문제
---
* 개인정보 보안 처리를 위해 주어진 인수의 일부를 *로 바꿔서 반환하는 함수를 만들어서 이를 모듈로 저장하는 프로그램
* 모듈명 : my_secure.py
* secure_name() 함수 : 김철수 -> 김**
* secure_no() 함수 : 951012-1234567 -> 951012-1******
* secure_phone() 함수 : 010-1234-5678 -> 010-****-5678
```python
# 파일에 다음과 같이 my_secure.py 모듈을 포함하는 코드 작성 후 실행

from my_secure import *

print(secure_name('김철수 '))
print(secure_no('951012-1234567'))
print(secure_phone('010-1234-5678'))
```

* 모듈 문제 - 정답
$$hide
```python
def secure_name(name):
return name[0] + '**'

def secure_no(no):
return no[0:8] + '******'

def secure_phone(phone):
return phone.replace(phone[4:8], '****')

# 01 ~ 02 : name[0]은 name의 첫 글자 의미
# 04 ~ 05 : no[0:8]은 첫 8글자를 의미
# 07 ~ 08 : replace() 메소드는 기존 문자열의 일부를 다른 문자열로 변경하는 메소드.
replace(기존 문자열, 새로운 문자열) 방식으로 사용
```
$$

6일차
===

표준 모듈의 활용
===
* 표준 모듈이란? : 파이썬에 기본적으로 설치되어 있는 모듈
* 표준 모듈은 별도로 설치하지 않고 import 후 사용할 수 있다.
* 내장 함수나 메소드로 해결할 수 없는 작업들은 표준 모듈을 사용해서 해결할 수 있다.

math
---
* 수학(math)에 관련된 함수를 제공하는 모듈
* import 방법
```python
import math
```

* 원주율 pi
* 원주율(π, 파이)은 흔히 3.14로 알고 있다.
* 좀 더 정확한 값을 사용하고자 한다면 math 모듈의 pi 변수값을 사용해야 한다.
```python
math.pi
```

* ceil() 함수, floor()함수
* 올림은 ceil() 사용, 내림은 floor()함수 사용.
* 두 함수는 모두 전달된 값을 정수로 올림 또는 내림 처리합니다.
```python
math.ceil(1.1)
math.floor(1.9)
```

* trunc() 함수
* 전달된 값을 정수로 절사할 수 있다. (절사 : 끊어 버림)
* 내림 함수 floor()와 비교해보면 양수를 처리할 때는 차이가 없지만, 음수를 처리할 때는 결과의 차이가 있다.
```python
math.trunc(-1.9) # 결과 : -1
math.floor(-1.9) # 결과 : -2
```

* sqrt() 함수
* 제곱근을 구할 수 있다.
* 제곱근 : 어떤 수를 제곱해서 얻는 수, 원래의 수를 구하기 위해 어떤 수를 두 번 곱해야 하는지를 나타냄
```python
math.sqrt(25) # 결과 : 5
```

* pow() 함수
* 제곱근을 구할 수 있다.
```python
math.pow(2, 3) # 결과 : 8
```

random
---
* 난수(random number)를 생성하는 모듈
* 난수를 통해서 간단한 게임을 제작할 수 있고 확률도 처리할 수 있다.
* random 모듈도 import후 바로 사용 가능
```python
import random
```

* randint() 함수
* 전달하는 두 인수 사이의 정수를 임의로 생성
```python
random.randint(1, 10)
# 1에서 10이하
```

* randrange() 함수
* range() 함수와 사용법이 비슷하다.
* range() 함수는 특정 범위의 정숫값들을 모두 생성, 하지만 randrange() 함수는 그 특정 범위에 속한 정수 중에서 하나만 임의로 생성
```python
random.randrange(10) # 0 이상 10 미만
random.randrange(1, 10) # 1이상 10 미만
random.randrange(1, 10, 2) # 1이상 10 미만, 홀수
```
* random() 함수
* 0 이상 1 미만 범위에서 임의의 실수를 생성
* 0 이상 1 미만 범위를 백분율로 환산하면 0% 이상 100%미만이기 때문에 확률을 처리할 때도 사용한다.
```python
random.random()
```
* 50%의 확률로 '안녕하세요'를 출력하는 프로그램
```python
if random.random() < 0.5:
print('안녕하세요')

# 함수의 결과가 0.5보다 작을 확률이 곧 50%의 확률이다.
```

* choice() 함수
* 전달된 시퀀스 자료형에 속한 요소 중에서 하나를 임의로 반환한다.
```python
seasons = ['spring', 'summer', 'fall', 'winter']
random.choice(seasons)
```

* sample() 함수
* 전달된 시퀀스 자료형에 속한 요소 중 지정된 개수의 요소를 임의로 반환
* 반환 결과는 리스트(list) 자료형이며 중복 없이 임의의 요소가 선택됨
```python
# 로또 번호 생성 코드
random.sample(range(1, 46), 6)
```

* shuffle() 함수
* 말 그대로 임의로 섞는 것을 의미
* 전달된 시퀀스 자료형에 속한 요소의 순서를 임의로 조정하여 다시 재배치하는 함수
* shuffle() 함수를 호출하면 실제로 전달된 시퀀스 자료형의 순서가 재배치 됩니다.
```python
my_list = [1,2,3,4,5]
random.shuffle(my_list)
print(my_list)
```
* shuffle() 함수는 내부 값의 수정이 가능한 시퀀스 자료형(대표적으로 리스트)을 전달해야 합니다.
* 내부 요소의 변경이 불가능한 문자열(str)이나 튜플(tuple) 같은 자료형을 전달하면 오류가 발생합니다.

문제
---
* 컴퓨터가 주사위를 던지면 사용자가 주사위의 숫자를 맞히는 프로그램
* 사용자가 맞힐 때 까지 게임은 반복합니다.

$$hide
```python
import random

dice = random.randint(1, 6)
while True:
user = int(input('주사위 값을 얼마일까요?>>>'))
if dice == user:
print('{}! 정답입니다.'.format(dice))
break
else:
print('오답입니다. 다시 시도하세요.')
```
$$

time
---
* 시간 처리에 관련된 모듈

* time() 함수
* 1970년 01월 01일 0시 0분 0초부터 현재까지 경과된 시간(timestamp)을 반환
* 소수점 이하는 마이크로초(µs)를 의미
* time() 함수는 현재 시간을 반환하므로 실행 시점에 따라 결과가 다르게 나타납니다.
```python
time.time()
```

* ctime() 함수
* 인수로 전달된 시간을 형식을 갖춰 반환
```python
time.ctime()
```

* strftime() 함수
* 인수로 전달된 날짜와 지시자를 이용하여 형식을 갖춘 날짜 데이터가 문자열로 반환
* strftime() 함수에서 사용할 수 있는 지시자는 다음과 같습니다.

| 구분 | 지시자 | 의미 |
| --- | --- | --- |
| 년 | %y | 2자리 숫자로 표시 |
| | %Y | 4자리 숫자료 표시 |
| 월 | %m | 2자리 숫로 표시(01~12) |
| | %b | 3자리 영문으로 표시(Jan~Dec) |
| | %B | 전체 영문으로 표시(January~December) |
| 일 | %d | 2자리 숫자로 표시(01~31) |
| 요일 | %a | 3자리 영문으로 표시(Sun~Sat) |
| | %A | 전체 영문으로 표시(Sunday~Saturday) |
| 시 | %I | 12시각제로 표시(01~12) |
| | %H | 24시각제로 표시(00~23) |
| 분 | %M | 2자리 숫자로 표시(00~59) |
| 초 | %S | 2자리 숫자로 표시(00~59) |
| 오전/오후 | %p | AM 또는 PM |
```python
time.strftime('%Y-%m-%d %a %H:%M:%S')
```
* 함수에 지시자만 전달되었기 때문에 형식을 갖춘 현재 날짜 데이터가 출력

* sleep() 함수
* 인수로 전달된 초(second)만큼 시스템을 일시 중지
```python
time.sleep(1)
```

datetime
---
* 날짜와 시간 데이터를 처리할 때 사용
```python
import datetime
```

* now() 메소드
* datetime 클래스 내부에 정의되어 있는 메소드
* 시스템의 현재 날짜와 시간을 반환합니다.
```python
present = datetime.datetime.now()
print(present)

# 현재 시간이 년-월-일 시:분:초.마이크로초 단위로 출력
# datetime이 2번 나오는 이유 : 모듈.클래스.메서드
```

* date() 함수
* 특정 날짜를 만들어 반환
```python
birthday = datetime.date(2017, 8, 25)
print(birthday)
```

* time() 함수
* 특정 시간을 만들어서 반환
```python
wake = datetime.time(10, 48, 0)
```

* 날짜/시간 관련 필드값
* 특정 날짜에서 원하는 데이터만 추출하고자 하는 경우 해당 필드값을 이용
```python
today = datetime.datetime.now()

today.year
today.month
today.day
today.hour
today.minute
today.second
```

* timedelta() 함수
* 날짜/시간 데이터의 연산을 위하여 사용

| 의미 | 사용 방법 |
| --- | --- |
| 1주 | timedelta(week=1) |
| 1일 | timedelta(day=1) |
| 1시간 | timedelta(hours=1) |
| 1분 | timedelta(minutes=1) |
| 1초 | timedelta(seconds=1) |

* timedelta() 함수로 어제, 오늘, 내일 만들기
```python
today = datetime.datetime.now()
yesterday = today - datetime.timedelta(days=1)
tomorrow = today + datetime.timedelta(days=1)
```

* total_seconds() 메소드
* 어떤 기간에 포함된 총 시간을 초로 반환
```python
date1 = datetime.date(2020, 8, 25)
date2 = datetime.date(2020, 8, 26)
date2 - date1

datetime.datedelta(days=1)

(date2 - date1).total_seconds()
```

예제문제
---
* 1부터 10000000(천만)까지 합계를 구하고 그 결과와 연산에 걸린 시간을 함께 출력하는 프로그램
```python
from datetime import *

start = datetime.now()
total = 0
for num in range(1, 10000001):
total += num
end = datetime.now()

elapse = end - start
elapse = elapse.total_seconds()

print('총 합은 {}입니다.'.format(total))
print('총 {}초가 소요되었습니다.'.format(elapse))

# 01 : from절을 이용해 import하여 함수 사용시 모듈명 생략
# 03 : 계산 시작하기 직전 시간 구함
# 04~06 : 1부터 10000000까지 합을 구함
# 07 : 계산이 끝난 직후 시간을 구함
# 09~10 : 계산에 소요된 시간을 구한 뒤 total_seconds() 함수를 통해 초 단위로 변환
```

7일차
===

외부 모듈의 활용
===
패키지
---
* 모듈의 상위 개념으로 패키지(package)가 있습니다.
* 패키지란 모듈의 집합을 의미, 간단하게 정리하면 모듈이 모여있는 디렉터리
* 파이썬을 설치할 때 함께 설치되지 않는 모듈들은 기본적으로 패키지의 형태로 배포하고 있습니다.

패키지 설치
---
```python
pip install numpy
```
* File > Settings > Project:프로젝트이름 > Python interpreter

```python
import numpy as np
np.sum([1,2,3,4,5])
```

패키지 삭제
---
```python
pip uninstall numpy
```

문제
---
* pandas 패키지를 설치
* 설치 후 화면을 보여주세요.
```python
import pandas as pd

# 데이터 준비
data = {
'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'Age': [24, 27, 22, 32, 29],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
}

# 데이터 프레임 생성
df = pd.DataFrame(data)

# 데이터 프레임 내용 출력
print("데이터 프레임 내용:")
print(df)
```

* matplotlib 패키지를 설치
* 설치 후 화면을 보여주세요.
```python
import matplotlib.pyplot as plt

# 데이터 준비
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

# 그래프 그리기
plt.plot(x, y, marker='o')

# 제목과 축 레이블 설정
plt.title("Simple Line Graph")
plt.xlabel("X Axis")
plt.ylabel("Y Axis")

# 그래프 표시
plt.show()
```

파일 입출력의 개요
===
* 파이썬을 이용하면 컴퓨터에 저장된 파일을 읽어 들이는 것은 물론 새로운 파일을 생성해서 저장하는 것도 가능하다.
* 이런 작업을 파일 입출력(input/output)이라고 합니다.
* 파일 입력(input) : 기존의 파일 내용을 읽어 들이는것
* 파일 출력(output) : 기존 파일에 새로운 내용을 추가하거나 새로운 파일을 생성

파일 열기
---
* 여기서 파일 열기란 어떤 파일을 열어 본다는 의미가 아닌 입출력 작업을 진행할 파일을 지정하는 것
* 파일 입력과 파일 출력 모두 반드시 파일 열기 작업을 가장 먼저 해야 합니다.
* 파일 열기는 open() 함수를 이용
```python
파일객체 = open(파일명.모드)
```
**파일명**
* 입출력 작업을 수행할 파일을 의미
* 파일명만 작성할 수도 있고 경로를 함께 작성할 수도 있습니다.
* C:\PythonStudy\Section13 디렉터리에서 소스를 작성하는 것으로 가정
```python
# 파일명만 작성하는 경우 파이썬 소스 코드 파일(.py)과 같은 경로에 존재하는 파일
open('sample.txt') # C:\PythonStudy\Section13\sample.txt

# 전체 경로를 작성하는 것도 가능, 파이썬의 경로 구분자는 슬래시(/)입니다.
open('C:/sample.txt') # C:\sample.txt

# 현재 디렉터리(.)를 기준으로 경로를 결정
open('./sample.txt') # C:\PythonStudy\Section13\sample.txt

# 상위 디렉터리(..)를 기준으로 경로를 결정
open('../sample.txt') # C:\PythonStudy\sample.txt
```

**모드**
* 파일을 여는 목적
* 파일 입력을 위해서인지 출력을 위해서인지 모드를 통해 결정

| 분류 | 종류 | 의미 | 설명 | 파일이 없을 때 동작 | 파일이 있을 때 동작 |
| --- | --- | --- | --- | --- | --- |
| 입력 | r | read | 읽기 | 오류 발생 | 읽기 |
| 출력 | w | write | 쓰기 | 새로 생성 | 새로 생성 |
| | a | append | 추가 | 새로 생성 | 추가 |
| | x | exclusive | 베타적 추가 | 새로 생성 | 오류 발생 |

* 입출력 모드를 생략하면 기본적으로 r 모드로 파일이 열립니다.

* 파일을 여는 목적을 결정했다면 어떤 파일인지 종류를 구분
* 열려고 하는 파일이 텍스트 파일인가 아닌가로 결정합니다.

| 종류 | 의미 | 설명 |
| --- | --- | --- |
| t | text | 텍스트 파일 |
| b | binary | 바이너리 파일(텍스트 파일 이외 모든 파일) |

* 열고자 하는 파일의 종류를 생략하면 기본적으로 t 모드로 파일이 열립니다.

* 지금까지 살핀 모드를 종합하여 사용할 수 있습니다.
[![image.png](https://i.postimg.cc/J4prxxhL/image.png)](https://postimg.cc/2VBN84vc)

파일 닫기
---
* 파일을 더 이상 사용하지 않거나 프로그램을 종료하고자 할 때
```python
파일객체.close()
```

파일의 생성
---
* 간단한 파일을 생성
```python
file = open('myFile.txt', 'wt')
print('파일 생성')
file.close()
```

with문
---
* 파일을 사용하는 프로그램은 언제든지 문제가 발생할 수 있다.
* 이러한 이유로 예외처리(try-except)와 같이 함께 처리하면 좋다.
* 예외처리가 아니라도 파이썬에서 close() 메소드를 자동으로 호출하는 기능이 with문 이다.
```python
with open(파일명, 모드) as 파일객체:
파일처리 코드
```
* 아래의 내용을 작성해보자.
```python
with open('myFile.txt', 'wt') as file:
print('파일 생성')

# 이렇게 작성하면 close() 메소드를 생략할 수 있어서 좋다.
```

파일 출력(output)
===
텍스트 파일 생성하기
---
* 이번에는 내용이 있는 텍스트 파일을 생성
```python
file = open('hello.txt', 'wt')

file.write('안녕하세요.')
file.write('\n')
file.write('반갑습니다.')
file.write('\n')
print('파일 생성')

file.close()
```
* 파일에 작성할 때는 write() 메소드를 사용
* 줄 바꿈 처리를 하지 않기 때문에 강제로 줄 바꿈 문자를 삽입

텍스트 파일에 내용 추가
---
```python
file = open('hello.txt', 'at')

file.write('hello.\n')
file.write('nice to meet you.\n')
print('파일에 새로운 내용 추가')

file.close()
```

예제
---
* 오늘의 스케줄을 입력하면 그 내용을 모두 파일에 보관하는 프로그램
* 스케줄을 입력하지 않고 Enter를 누르면 프로그램 종료
* 생성되는 파일의 이름은 현재 날짜이고 확장자는 txt
* 2020-10-22.txt와 같은 형식으로 저장

$$hide
```python
import time

file = open(time.strftime('%Y-%m-%d')+'.txt', 'at')
while True:
schedule = input('입력>>>')
if not schedule:
break
file.write(schedule + '\n')
file.close()
```
$$

8일차
===

파일 입력(input)
===
텍스트 파일 읽기
---
* 파일을 읽을 때 사용하는 여러 메소드를 이용해서 hello.txt 파일을 읽은 뒤 화면에 그대로 출력하는 프로그램을 구현해보자.
* 파일이 없다면 생성 후 아래의 내용 기입
```
안녕하세요.
반갑습니다.
Hello
Nice to meet you
```

**read() 메소드**
* 형식
```
file.read(size)
```
* read() 메소드는 파일로부터 데이터를 읽어 들이는 메소드
* 텍스트 모드와 바이너리 모드에서 다른 방식으로 동작

| 항복 | 텍스트 모드 | 바이너리 모드 |
| --- | --- | --- |
| 반환값 | 읽어 들인 문자열 | 읽어 들인 바이트열 |
| 매개변수 size | 읽어 들일 최대 문자의 개수 | 읽어 들일 최대 바이트 수 |
| 매개변수 size 생략 | 파일 전체 읽음 | 파일 전체 읽음 |
| 파일의 끝에 도달 | 빈 문자열('') 반환 | 빈 문자열('') 반환 |

* 모드와 상관없이 공통적으로 size를 생략하고 read()와 같은 형식으로 호출하면 파일 전체를 읽어 들입니다.
* size값으로 음수를 전달해도 파일 전체를 읽어 들입니다.
* TIP : 1글자와 1바이트는 크기가 다르다.
* 영문은 1글자가 1바이트로 서로 동일하지만, 한글은 1글자가 2바이트로 서로 크기가 다르다.

* 우선 read() 메소드를 이용해 파일 전체를 한 번에 읽어 들이는 프로그램
```python
file = open('hello.txt', 'rt')

str = file.read()
print(str, end='')

file.close()
```
* 파일과 동일한 모습으로 출력하기 위해서 print() 함수의 자동 줄 바꿈 방지를 위한 end=''속성을 추가

* read() 메소드를 통해 전체를 읽으려면 그 만큼의 메모리 공간이 필요
* 읽어야 할 파일이 크다면 일부만 읽어 들이는 작업을 반복하는 반복문을 이용해서 파일 전체를 읽도록 구현하는 것이 좋다.
* 이제 read() 메소드에 인수 size값을 전달해서 한 번에 읽는 글자 수를 제한하고 반복문을 이용해서 전체를 읽어보자.
```python
file = open('hello.txt', 'rt')

while True:
str = file.read(5)
if not str:
break
print(str, end='')

file.close()

# 파일로부터 최대 5글자를 읽어 들입니다.
```

**readline() 메소드**
* 해당 메소드는 텍스트 파일을 한 줄씩 읽어서 처리하는 메소드
* 만약 파일이 종료되어 더 이상 읽어 들일 데이터가 없으면 빈 문자열을 읽어 들입니다.
* 반복문을 이용해서 여러 번 읽어 들여야 파일 전체를 읽어 들일 수 있습니다.
```python
file = open('hello.txt', 'rt')

while True:
str = file.readline()
if str == '':
break
print(str, end='')

file.close()
```

**readlines() 메소드**
* 라인 하나가 아닌 전체 라인을 모두 읽어 각 라인 단위로 리스트에 저장
```python
file = open('hello.txt', 'rt')
line_list = file.readlines()
```
* for문 사용하여 반복 처리
```python
file = open('hello.txt', 'rt')

line_list = file.readlines()
for line in line_list:
print(line,end='')

file.close()
```
* enumerate() 함수를 이용하면 간단하게 라인 번호도 함께 출력할 수 있습니다.
```python
file = open('hello.txt', 'rt')

line_list = file.readlines()
for no, line in enumerate(line_list):
print('{} {}'.format(no+1, line), end='')

file.close()
```

* sys 모듈을 사용하면 보다 쉽게 파일을 읽을 수 있다.
* sys 모듈에는 표준 입출력을 위한 stdin과 stdout객체가 포함되어 있다.
* stdout : 출력을 위한 객체, 화면 출력 메소드인 write()와 writelines 메소드 사용 가능
* writelines() 메소드를 사용하면 리스트와 같은 반복 가능한 객체의 요소를 한 줄씩 자동으로 출력할 수 있습니다.
```python
import sys

file = open('hello.txt', 'rt')

line_list = file.readlines()
sys.stdout.writelines(line_list)

file.close()
```

예제
---
* 동요 '엄마돼지 아기돼지'의 가사가 저장되어 있는 파일에서 '꿀'이란 글자가 몇 번 나오는지 찾는 프로그램
$$hide
```python
# encoding 추가
file = open('동요.txt', 'rt', encoding='utf=8')

line_list = file.readlines()

count = 0
for line in line_list:
for ch in line:
if ch == '꿀':
count += 1

print(f'{count}번')
```
$$

파일 입출력의 활용
===
파일 복사
===
파일 복사 개념
---
* 파일 복사는 원본 파일의 복사본 파일을 만드는 것
* 원본 파일로부터 파일의 내용을 읽어서 변수에 저장한 뒤 복사본 파일로 전송하면 간단하게 파일 복사를 할 수 있다.

파일 복사 구현
---
* 텍스트 뿐만 아니라 이미지, 동영상과 같은 파일들도 복사가 가능하도록 구현
* 그러기 위해선 바이너리 모드로 파일을 읽어야 함
* 원본 파일의 내용을 읽을 때 read() 메소드, 복사본 파일에 읽은 내용을 그대로 기록할 때는 write() 메소드

복사할 원본 파일 준비
---
* 파일이 너무 크지 않은 적당한 영상 파일 준비
* [무료 동영상 샘플 다운로드](https://pixabay.com/ko/videos/)

with문 사용
---
* 실무에서 많이 사용하는 with문을 사용
* with문을 사용하면 close() 메소드의 호출이 자동으로 처리됩니다.

복사 단위
---
* 원본 파일을 한 번에 다 읽어서 모두 변수에 저장하려면 메모리 용량이 부담.
* 원본 파일에서 한 번에 읽어들이는 데이터의 크기를 1KB(1024Byte)로 설정

복사 프로그램의 구현
---
```python
buffer_size = 1024
with open('code.mp4', 'rb') as source:
with open('code2.mp4', 'wb') as copy:
while True:
buffer = source.read(buffer_size)
if not buffer:
break
copy.write(buffer)
print('code2.mp4 파일 복사 완료')
```

결과 확인
---
* 디렉터리에서 파일이 복사 됐는지 확인

CSV 파일 입출력
===
CSV 파일이란
---
* Comma Separated Values
* 쉼표로 분리한 값들
* 데이터베이스나 스프레드시트 데이터를 저장하기 위해서 사용하는 형식
* CSV 파일의 내부는 실제 쉼표로 이용해서 모든 항목이 구분되어 있음
* 쉼표로 구성된 각 항목들이 테이블을 구성하는 각각의 데이터가 되는 방식

CSV 파일 읽기
---
* 쉼표로 데이터가 구분되어 있어서 문자열 처리 메소드를 활용하면 별도의 외부 모듈 없이 읽을 수 있다.
* CSV 파일을 읽는 기본적인 아이디어는 다음과 같다.
* 1. 한 줄에 한 데이터가 있기 때문에 readline() 메소드로 한 줄씩 읽습니다.
* 2. 쉼표로 분리하기 위해서 split() 메소드를 이용합니다.
```python
student_list = []
with open('학생명단.csv', 'rt', encoding='utf=8') as file:
file.readline()
while True:
line = file.readline()
if not line:
break
student = line.split(',')
student_list.append(student)
print(student_list)
```

* 조금 다른 형식의 CSV파일
* 간혹 큰따옴표를 이용해서 텍스트를 묶는 경우가 있다.
* 큰따옴표를 제거하기 위해서 회원명에 추가로 strip() 메소드를 사용
```python
member_list = []
with open('회원명단.csv', 'rt', encoding='utf=8') as file:
file.readline()
while True:
line = file.readline()
if not line:
break
member = line.split(',')
member[0] = member[0].strip('""')
member_list.append(member)
print(member_list)
```

CSV 모듈로 CSV 파일 생성하기
---
* CSV 모듈 사용
* CSV 파일을 w 모드로 열고 생성된 객체를 csv.writer() 메소드에 전달
* 그러면 CSV 파일을 생성할 수 있는 객체가 생성되는데 이 객체를 이용해서 writerow() 메소드를 호출하면 CSV 파일에 데이터를 저장할 수 있다.
```python
import csv

with open('차량관리.csv', 'w') as file:
csv_maker = csv.writer(file, delimiter=',')
csv_maker.writerow([1, '08러1234', '2020-10-20,14:00'])
csv_maker.writerow([2, '25다1234', '2020-10-20,14:10'])
csv_maker.writerow([3, '28하1234', '2020-10-20,14:20'])
print('차량관리.csv 파일 생성 완료')
```
* 해당 파일에 불필요한 라인이 하나씩 추가되어 있다.
* 이를 막기 위해서 새로운 라인을 추가하지 못하도록 newline 옵션을 사용
```python
import csv

with open('차량관리.csv', 'w', newline='', encoding='utf=8') as file:
csv_maker = csv.writer(file, delimiter=',')
csv_maker.writerow([1, '08러1234', '2020-10-20,14:00'])
csv_maker.writerow([2, '25다1234', '2020-10-20,14:10'])
csv_maker.writerow([3, '28하1234', '2020-10-20,14:20'])
print('차량관리.csv 파일 생성 완료')
```
* 여기까지 진행하면 아마도 잘 작성 되었을 것이다.
* 하지만 남아있는 문제가 있을 수 있다.
* 3번째 데이터는 데이터 자체에 쉼표를 포함하고 있어 위 결과를 보면 쉼표를 기준으로 2개의 데이터로 분리된 것처럼 보임
* 이를 막기 위해서 quotechar 옵션 사용
* quotechar 옵션은 delimiter 옵션으로 분리되면 안되는 데이터를 묶어 주는 문자를 지정할 때 사용
```python
import csv

with open('차량관리.csv', 'w', newline='', encoding='utf=8') as file:
csv_maker = csv.writer(file, delimiter=',', quotechar='""')
csv_maker.writerow([1, '08러1234', '2020-10-20,14:00'])
csv_maker.writerow([2, '25다1234', '2020-10-20,14:10'])
csv_maker.writerow([3, '28하1234', '2020-10-20,14:20'])
print('차량관리.csv 파일 생성 완료')
```

CSV 모듈로 CSV 파일 읽기
---
```python
import csv

with open('차량관리.csv', 'r', newline='', encoding='utf=8') as file:
csv_reader = csv.reader(file, delimiter=',')
for line in csv_reader:
print(line)
```

9일차
===

JSON 파일 입출력
===
JSON 파일이란?
---
* 데이터를 전달할 때 사람이 읽고 쓰기 쉽도록 텍스트 형식을 정해 놓은 개방형 데이터 표준 형식
* 많은 양의 데이터를 처리할 때는 속도가 느리다.
* 경량의 데이터를 주고받을 때 주로 사용
* JavaScript Object Notation의 약자로 JavaScript의 객체 표현 방법
* JavaScript : 동적인 웹 페이지를 처리하기 위한 웹 프로그래밍 언어

JSON 데이터의 형식
---
* 속성-값 쌍으로 구성된 데이터들이 순서 없이 모여 있는 구조
* 중괄호를 이용해서 전체 JSON 데이터를 묶고, 속성과 값 사이에 콜론을 붙여 줍니다.
* 속성과 값으로 구성된 각 데이터의 구분은 쉼표를 이용
```
{
"morning":"시리얼"
"lunch":"갈비탕"
"evening":"김치찌개"
}
```
* 파이썬의 딕셔너리와 같다

JSON 파일 생성
---
* JSON 데이터는 딕셔너리 모습을 하고 있다.
* 파이썬은 JSON 데이터 처리를 위해 json모듈을 제공
* json 모듈을 import하면 리스트나 딕셔너리와 같은 파이썬 객체를 JSON 데이터로 변환하거나, JSON 데이터를 다시 파이썬 객체로 변환이 가능하다.

* 파이썬 객체를 JSON 데이터로 변환하는 과정
* 파이썬 객체를 JSON 문자열로 변환하는 것을 JSON 인코딩이라고 합니다.
* JSON 인코딩을 이용해 파이썬 객체를 JSON 문자열로 변환하고, 변환된 문자열을 파일에 기록하면 확장자가 json인 JSON파일을 만들 수 있다.
* json.dumps() 메소드 사용
```python
import json

dict_list = [
{
'name': 'james',
'age': 20,
'spec': [
175.5,
70.5
]
},
{
'name': 'alice',
'age': 21,
'spec': [
168.5,
60.5
]
}
]
json_string = json.dumps(dict_list)
with open('dictList.json', 'w') as file:
file.write(json_string)

print('파일 생성')
```
* 보기 좋은 형식으로 만들기 위해 json.dumps() 메소드에 indent=4 옵션 추가
```python
import json

dict_list = [
{
'name': 'james',
'age': 20,
'spec': [
175.5,
70.5
]
},
{
'name': 'alice',
'age': 21,
'spec': [
168.5,
60.5
]
}
]
json_string = json.dumps(dict_list, indent=4)
with open('dictList.json', 'w') as file:
file.write(json_string)

print('파일 생성')
```
* indent=4 는 들여쓰기 공백문자를 4개로 처리한다는 의미

JSON 파일 읽기
---
* 반대로 JSON 데이터를 파이썬 객체로 변환하는 과정
* 인코딩된 JSON 데이터를 다시 파이썬 객체로 변경하는 것을 JSON 디코딩이라고 합니다.
* 디코딩 처리 메소드 : json.loads()
```python
import json

with open('dictList.json', 'r') as file:
json_reader = file.read()
dict_list = json.loads(json_reader)

for dic in dict_list:
print('이름{}'.format(dic['name']))
print('나이{}'.format(dic['age']))
print('키{}'.format(dic['spec'][0]))
print('몸무게{}'.format(dic['spec'][1]))
print()
```

클래스 도입의 필요성
===
* 다음 학생 정보를 전달해서 출력하는 student_info() 함수
* 학생 정보에는 이름,학과,담당교수,전화번호,주소,학점이 있습니다.
* 이 6개 정보를 넘겨줘야 student_info() 함수를 호출할 수 있습니다.
```python
def student_info(name,department,professor,phone,address,grade):
print(name)
print(department)
print(professor)
print(phone)
print(address)
print(grade)
```
* 학생 정보 입력 후 출력
```python
name='emily'
department='computer'
professor='james'
phone='010-1234-5678'
address='seoul'
grade='A'
```
* 잘 처리 했지만 변수가 많아서 힘들다.
* 이런 상황을 벗어나기 위해 클래스와 객체를 이용할 수 있다.

클래스와 객체
===
객체의 개념
---
* 개발을 하다보면 정수,실수,문자열 등 기본 자료형으로 표현하기 힘든 것이 있다.
```
게시글 번호
제목
작성자
비밀번호
내용
.
.
.
```
* 이러한 것을 쉽게 관리하려면 여러개의 항목을 하나의 이름을 가진 객체로 만드는 것이 가장 좋다.

클래스의 개념
---
* 클래스 : 객체를 만드는 도구
* 하나의 클래스를 두면 그 클래스를 통해 여러 개의 객체를 만들 수 있다.
* 객체를 인스턴스 라고도 한다. (관점의 차이)
* 와플 머신 클래스로 만든 와플=객체
* 와플은 와플 머신 클래스의 인스턴스

클래스 정의
---
* 클래스를 작성하는 것
* 클래스 이름을 네이밍 할 때 규칙이 있다.
* [클래스 네이밍 규칙](https://myun9-cloud.tistory.com/11)
```python
class 클래스:
본문
```

객체 생성
---
```python
객체 = 클래스()
```

클래스 정의와 객체 생성
---
```python
class WaffleMachine:
pass

waffle = WaffleMachine()
print(waffle)
```

클래스의 구성
===
클래스의 기본 구성
---
* 객체를 만들어내는 클래스는 객체가 가져야 할 구성 요소를 가지고 있다.
* 객체를 생성하기 위해서 클래스는 객체가 가져야 할 값과 기능을 가지고 있어야 한다.
* 클래스는 변수와 함수로 구성된다고 볼 수 있다.
* 사람을 예시로 설명
```
값 : 이름, 나이, 연락처 등
기능 : 잔다, 먹는다, 달린다 등
```
* 사람(객체)이 가지고 있는 값은 변수, 기능은 함수라고 볼 수 있다.
* 즉, 클래스는 변수와 함수로 구성된다고 볼 수 있다.
* 클래스를 구성하는 변수는 2가지로 분리할 수 있다.
* 클래스를 기반으로 생성된 모든 인스턴스들이 공유하는 변수인 클래스 변수
* 모든 인스턴스들이 개별적으로 가지는 변수인 인스턴스 변수
```python
class Person:
species = "Homo Sapiens" # 클래스 변수

def __init__(self, name, age):
self.name = name # 인스턴스 변수
self.age = age # 인스턴스 변수
```
* 그리고 클래스를 구성하는 함수는 더 이상 함수라고 부르지 않음
* 클래스 내부에 존재하는 함수는 메소드라고 함

인스턴스 변수와 인스턴스 메소드
---
* 인스턴스 변수 : 클래스 기반으로 만들어지는 모든 인스턴스들이 각각 따로 저장하는 변수
* 모든 인스턴스 변수는 self라는 키워드를 앞에 붙여 줍니다.

* 인스턴스 메소드 : 인스턴스 변수를 사용하는 메소드
* 인스턴스 변수값에 따라 각 인스턴스마다 다르게 동작
```python
class Person:
def who_am_i(self, name, age, tel, address):
self.name=name
self.age=age
self.tel=tel
self.address=address

boy=Person()
boy.who_am_i('john',15,'123-1234','toronto')
print(boy.name)

'''
첫 번째 매개변수가 self()이므로 인스턴스 메소드
모든 인스턴스는 who_am_i() 메소드 호출 가능
self에는 who_am_i() 메소드를 호출하는 인스턴스가 전달
self를 제외한 나머지 매개변수에 실제로 사용될 데이터 전달

boy라는 인스턴스를 생성
boy 인스턴스에서 who_am_i 메소드를 호출
이 때, self는 boy를 가리킴
[즉, self는 메소드를 호출한 그 객체 자신]
'''
```

예제
---
* 사용자로부터 온전한 수식을 입력받고 입력받은 수식의 결과를 출력하는 Calculator 클래스 제작
$$hide
```python
class Calculator:
def input_expr(self):
expr=input('수식>>>')
self.expr=expr

def calculator(self):
return eval(self.expr)

calc = Calculator()
calc.input_expr()
print('수식 결과 : {}'.format(calc.calculator()))
```
$$

생성자와 소멸자
===
생성자
---
* 다음과 같은 클래스를 만들어보자
```python
class Candy:
def set_info(self,shape,color):
self.shape=shape
self.color=color

satang=Candy()
satang.set_info('circle','brown')
```
* 코드가 실행되면서 satang 인스턴스(객체)가 생성
* 이 때 satang 인스턴스에 저장된 모양과 색상 정보가 없다.
* satang 인스턴스는 생성된 이후에 메소드를 호출해서 값을 가지게 됨

* 정리
```
1. 값이 없는 인스턴스를 생성
2. 값을 저장할 수 있는 메소드 호출
```
* 지금까지는 값이 없는 인스턴스를 먼저 생성하고 인스턴스의 값을 저장하는 메소드를 나중에 호출
* 이제부터 인스턴스를 생성할 때 처음부터 값을 가지고 있는 인스턴스를 만들어보자

\_\_init\_\_
---
* 생성자
* 생성자는 인스턴스를 생성할 때 자동으로 호출되는 특별한 메소드
* 모든 클래스는 \_\_init\_\_라는 이름을 가진 생성자를 가지고 있다.
* TIP : 일반적으로 \_\_로 시작하는 메소드들은 파이썬에 의해 미리 기능과 역할이 부여된 메소드를 의미
```python
class Candy:
def __init__(self,shape,color):
self.shape=shape
self.color=color

satang=Candy('circle','brown')
```

소멸자
---
* 인스턴스가 생성될 때 자동으로 생성되는 생성자와 마찬가지
* 인스턴스가 소멸할 때 자동으로 호출되는 메소드
* \_\_del\_\_이라는 메소드 이름을 가지고 있다.

\_\_del\_\_
---
```python
class Sample:
def __del__(self):
print('인스턴스가 소멸합니다.')

sample = Sample()
del sample
```
* \_\_del\_\_()이라는 메소드를 정의해 놓았다.
* 이 메소드가 소멸자
* sample 인스턴스가 del sample 코드로 인해서 소멸될 때 자동으로 소멸자가 호출

예제
---
* 생성자를 이용해서 용량을 가진 usb 인스턴스를 만드는 프로그램
$$hide
```python
class USB:
def __init__(self, capacity):
self.capacity=capacity

def info(self):
print(f'{self.capacity}GB USB')

usb = USB(64)
usb.info()
```
$$
* 생성자와 소멸자를 이용해서 서비스 안내 메시지 출력
* 객체 생성시 '길 안내' 라는 문자열을 매개변수로 전달 및 '길 안내 시작' 출력
* 소멸시 '종료'라는 프린트 출력
```
길 안내 시작
길 안내 종료
```
$$hide
'''
class Service:
def __init__(self, service):
self.service=service
print(f'{self.service} 시작')

def __del__(self):
print(f'{self.service} 종료')

s = Service('길 안내')
del s
'''
$$

클래스 메소드와 정적 메소드
===
클래스 변수
---
* 클래스를 구현할 때 인스턴스마다 서로 다른 값을 가지는 경우에는 인스턴스 변수 사용
* 인스턴스 변수는 self 키워드를 붙여서 사용

* 이번에는 인스턴스들이 서로 같은 값을 가지는 경우
* 한국 사람을 클래스로 구현한다고 가정
* 사람들의 이름, 나이 등은 여전히 인스턴스마다 서로 다른 값을 가짐
* 하지만 소속 국가는 한국으로 하나이다.
* 이렇게 모든 인스턴스가 동일한 값을 사용할 때 클래스 변수로 처리해서 모든 인스턴스들이 공유하도록 처리하는 것이 좋다. = 메모리 절약
```python
class Korean:
country = '한국'

def __init__(self,name,age):
self.name=name
self.age=age

man = Korean('홍길동',35)
man.name # 홍길동
Korean.name # 에러
man.country # 한국
Korean.country # 한국
```
* 인스턴스 변수는 self를 붙여서 사용하지만 클래스 변수는 사용 안함
* 인스턴스 변수는 인스턴스 man을 통해 접근하지만, 클래스 변수는 korean을 통해 접근 가능
* TIP : 클래스 변수는 클래스를 통해 접근하는 것이 권장 사항

클래스 메소드
---
* 클래스 메소드(class method) : 클래스 변수를 사용하는 메소드를 의미
* 클래스 메소드의 특징
```
1. 인스턴스 또는 클래스로 호출
2. 생성된 인스턴스가 없어도 호출 가능
3. @classmethod 데코레이터(decorator)를 표시하고 작성
4. 매개변수 self를 사용하지 않고 cls를 사용
```
* 클래스 메소드는 인스턴스를 통해서 호출하지 않고 클래스.메소드()와 같은 형식으로 호출
* 클래스 메소드는 self를 사용하지 않기 때문에 인스턴스 변수애 접근할 수 없지만, cls를 통해서 클래스 변수에 접근할 수 있다.
* 이것이 self를 통해 앤스턴스 변수를 사용하는 인스턴스 메소드와 가장 큰 차이점이다.

**데코레이터란?**
* 데코레이터는 함수나 메소드에 어떤 기능을 추가하는 방법
* @로 시작하고 함수나 메소드의 위에 붙여서 사용
* @classmethod 데코레이터 : @classmethod는 클래스 메소드를 정의할 때 사용
* 클래스 메소드는 인스턴스가 아니라 클래스 자체를 첫 번째 인자로 받음
* 번외 : @staticmethod : 첫 번째 인자로 특별한 것을 받지 않는다. 그냥 일반 함수처럼 동작

```python
class Korean:
country = '한국'

@classmethod
def trip(cls, country):
if cls.country == country:
print('국내')
else:
print('해외')

Korean.trip('한국')
Korean.trip('미국')
```
* trip() 메소드는 클래스 메소드임을 알리는 데코레이터 @classmethod로 시작
* 첫 번째 매개변수 cls는 클래스의 줄임말로 여기서는 클래스 Korean을 의미
* 클래스 메소드는 인스턴스를 생성하지 않아도 클래스만으로 호출 가능

정적 메소드
---
* 정적 메소드(static method) : self를 사용하지 않기 때문에 인스턴스 변수 사용 불가
* 인스턴스를 생성하지 않아도 사용할 수 있는 메소드
* 정적 메소드의 특징
```
1. 인스턴스 또는 클래스로 호출
2. 생성된 인스턴스가 없어도 호출 가능
3. @staticmethod 데코레이터를 표시하고 작성
4. 반드시 작성해야 할 매개변수가 없다.
```
* 정적 메소드는 self와 cls를 모두 사용하지 않음
* 때문에 인스턴스 변수와 클래스 변수를 모두 사용하지 않는 메소드를 정의할 때 적절함
* 정적 메소드는 클래스에 소속되어 있지만, 인스턴스에는 영향을 주지 않고 받지도 않음
```python
class Korean:
country = '한국'

@staticmethod
def slogan():
print('Imagine your Korea')

Korean.slogan()
```
* 정적 메소드임을 알리는 @staticmethod로 시작
* slogan() 메소드는 Korean 클래스에 있지만, 인스턴스 변수나 클래스 변수 모두 사용 안함

예제
---
* 가방클래스를 만들고 가방객체를 생성할 때 마다 현재 만들어진 가방이 몇 개인지 계산할 수 있는 클래스
```
print(f'현재 가방{Bag.remain_bag()}')
bag1 = Bag()
bag2 = Bag()
bag3 = Bag()
print(f'현재 가방{Bag.remain_bag()}')
bag1.sell()
bag2.sell()
print(f'현재 가방{Bag.remain_bag()}')
```

$$hide
```python
class Bag:
count = 0
def __init__(self):
Bag.count += 1
@classmethod
def sell(cls):
cls.count -= 1
@classmethod
def remain_bag(cls):
return cls.count

print(f'현재 가방{Bag.remain_bag()}')
bag1 = Bag()
bag2 = Bag()
bag3 = Bag()
print(f'현재 가방{Bag.remain_bag()}')
bag1.sell()
bag2.sell()
print(f'현재 가방{Bag.remain_bag()}')
```
$$

상속
===
상속이란?
---
* 파이썬에서 어떤 클래스가 가지고 있는 기능을 물려받아 사용할 수 있는 클래스를 만들 수 있음
* 다른 클래스의 기능을 물려받을 때 상속받는다는 표현을 사용
* 상속 관계에 있는 클래스를 표현할 때 부모 클래스와 자식 클래스라고 함

| 구분 | 부모 클래스 | 자식 클래스 |
| --- | --- | --- |
| 의미 | 상속해 주는 클래스 | 상속받는 클래스 |
| 용어 | 슈퍼 클래스 | 서브 클래스 |
| | 기반 클래스 | 파생 클래스 |
* 파이썬에서는 super라는 키워드는 슈퍼 클래스를 지정하는 용도로 사용하므로 슈퍼 클래스와 서브 클래스라는 용어 사용

상속 관계 구현
---
* 기본적으로 두 클래스가 상속 관계에 놓이려면 IS-A 관계를 성립해야 함
* IS-A 관계 : ~은 ~이다. 로 해석 가능한 관계를 의미(예 : 학생은 사람이다.)
* 학생 : 서브클래스
* 사람 : 슈퍼 클래스
* 슈퍼 클래스는 일반 클래스처럼 구현되지만, 서브 클래스는 슈퍼 클래스를 상속받는지 명시할 수 있도록 새로운 문법 사용

* 상속의 기본 형태
```python
class 슈퍼 클래스:
본문

class 서브 클래스(슈퍼 클래스):
본문
```
* 서브 클래스를 구현할 때는 괄호 안에 어떤 슈퍼 클래스를 상속받는지 명시
* 상속 관계에 놓인 서브 클래스는 마치 자신의 것처럼 슈퍼 클래스의 기능을 사용할 수 있다.
```python
class Person:
def __init__(self, name):
self.name = name
def eat(self, food):
print(f'{self.name}가 {food}를 먹습니다.')

class Student(Person):
def __init__(self, name, school):
super().__init__(name)
self.school = school
def study(self):
print(f'{self.name}는 {self.school}에서 공부를 합니다.')

potter = Student('해리포터', '호그와트')
potter.eat('감자')
potter.study()
```

서브 클래스의 \_\_init\_\_()
---
* 서브 클래스는 슈퍼 클래스가 없으면 존재할 수 없다. (부모가 있어야 자식이 있다.)
* 그래서 서브 클래스의 생성자를 구현할 때는 반드시 슈퍼 클래스의 생성자를 먼저 호출하는 코드를 작성해야 한다.
```python
def __init__(self, name, school):
super().__init__(name)
self.school = school
```
* 우선 super라는 키워드는 슈퍼 클래스를 의미
* Student를 생성하기 위해서 Student의 생성자를 호출하면 super().\_\_init\_\_(name)에 의해서 슈퍼 클래스인 Person의 생성자가 먼저 호출되면서 슈퍼 클래스 생성
* 슈퍼 클래스 Person의 생성에는 name이 필요하므로 name이 함께 전달
* 이 과정으로 슈퍼 클래스 Person의 생성이 끝나면 서브 클래스 Student도 school의 값을 저장하면서 생성

서브 클래스의 인스턴스 자료형
---
* 슈퍼 클래스 객체는 슈퍼 클래스의 인스턴스
* 그에 비해 서브 클래스 객체는 서브 클래스의 인스턴스이면서 동시에 슈퍼 클래스의 인스턴스
* 즉 서브 클래스 Student의 객체는 동시에 Person의 인스턴스

* 어떤 객체가 어떤 클래스의 인스턴스인지 확인
* isinstance() 함수 사용
```python
isinstance(객체, 클래스)
```
* 객체가 클래스의 인스턴스인 경우 True아니면 False를 반환
* 작성했던 코드에 아래의 내용 추가
```python
print(isinstance(potter, Student))
print(isinstance(potter, Person))
```

예제
---
* 원두(bean)를 저장하는 Coffee 클래스와 원두(bean)에 물(water)을 섞은 Espresso 클래스를 상속 관계로 구현
```
coffee = Espresso('콜롬비아', 30)
coffee.espresso_info()
```
$$hide
```python
class Coffee:
def __init__(self, bean):
self.bean = bean
def coffee_info(self):
print(f'원두{self.bean}')

class Espresso(Coffee):
def __init__(self, bean, water):
super().__init__(bean)
self.water = water
def espresso_info(self):
super().coffee_info()
print(f'물: {self.water}ml')

coffee = Espresso('콜롬비아', 30)
coffee.espresso_info()
```
$$

예외 처리의 필요성
===
예외와 오류
---
* 예외(exception) : 프로그램에 존재하는 오류(error)를 의미
* 예외와 오류는 비슷하지만, 약간의 차이가 있다.
* 프로그램을 개발하다 보면 많은 문제가 발생함
* 이 중에서 개발자가 직접 처리할 수 있는 간단한 문제는 '예외'
* 개발자가 처리할 수 없는 복잡한 문제는 '오류'

예외 처리의 필요성
---
* 예외 처리의 목적은 어떤 문제가 발생했을 때 그 문제를 해결하는 것이 아님
* 발생되는 문제로 인해 프로그램이 비정상적으로 종료되는 것을 막고 사용자에게 발생한 문제에 대한 정보를 전달하기 위함

* 어떤 숫자를 0으로 나누는 경우 ZeroDivisionError라는 예외가 발생
[![Zero-Division-Error.png](https://i.postimg.cc/5jWC86Fs/Zero-Division-Error.png)](https://postimg.cc/8fwcSk4v)
* 정상적으로 종료되지 안음, 보기도 나쁘다.
* 예외 처리 과정을 거쳐 다음과 같이 실행할 수 있습니다.
```
2/0
0으로 나눌 수 없습니다.
```
* 예외 처리를 통해서 프로그램이 비정상적으로 종료 되는 것을 막고 사용자에게 왜 문제가 발생했는지 정보를 전달했다.

* 웹 페이지에도 예외 처리가 필요
[![404.png](https://i.postimg.cc/h4T1YF1R/404.png)](https://postimg.cc/nMVmsPW3)
* 아래와 같이 예외 처리를 하여 사용자에게 정돈된 모습을 보여 줄 수 있다.
* 그리고 그 문제에서 벗어나기 위해서 어떤 행동을 해야 하는지도 전달할 수 있다.
[![img-error.png](https://i.postimg.cc/fTbk9mLq/img-error.png)](https://postimg.cc/rzv86d55)
* 이미 발생한 문제를 예외 처리로 잡을 수는 없다.
* 하지만 발생한 문제로 인해서 더 이상 프로그램이 비정상적으로 종료되는 등의 현상을 막을 수 있다.
* 추가적으로 사용자에게 발생 이유나 대체 방법을 전달할 수 있다.
* 이러한 이유에서 예외 처리가 필요하다.

예외 처리
===
고전적인 예외 처리
---
* 사용자로부터 2개의 정수를 입력받아 나눗셈을 하고 그 결과를 보여주는 프로그램
```python
a = int(input('제수 입력>>>'))
b = int(input('피제수 입력>>>'))

if b == 0:
print('0으로 나눌 수 없음')
else:
print(f'{a}/{b}={a/b}')
```
* 어떤 값이던 0으로 나누는 것은 불가능
* 그래서 if문으로 연산을 하지 못하도록 예외 처리
* 이것이 지금까지 우리가 사용했던 예외 처리 방식

* 이렇게 if문으로 의존한 고전적인 예외 처리 방식에는 다음과 같은 문제가 있다.
```
1. 어떤 문제가 발생할지 예상할 수 있어야 대비가 가능함
2. 어떤 문제가 발생할지 예상을 해도 대비할 수 없는 경우가 있다.
```
* 0이 아닌 실수값을 입력해 보자

예외의 종류
---
* 파이썬은 발생할 수 있는 모든 문제를 예외 클래스로 만들어 두었다.
* 프로그램이 실행되면서 어떤 문제가 발생하면 자동으로 해당 문제의 인스턴스가 발생

* 기본적으로 모든 예외 클래스는 BaseException 클래스의 서브 클래스
* BaseException 클래스의 서브 클래스 중에는 Exception 클래스가 있는데 대부분의 예외 클래스는 이 Excepstion 클래스의 서브 클래스이다.

| 순번 | 예외 클래스 | 의미 |
| --- | --- | --- |
| 1 | BaseException | 최상위 예외 클래스 |
| 2 | Exception | 대부분의 예외 클래스의 슈퍼 클래스 |
| 3 | ArithmeticError | 산술 연산에 문제가 있을 때 |
| 4 | AttributeError | 잘못된 속성을 참조할 때 |
| 5 | EOFError | 파일에서 더 이상 읽어 들일 데이터가 없을 때 |
| 6 | ModuleNotFoundError | import할 모듈이 없을 때 |
| 7 | FileNotFoundError | 존재하지 않는 파일일 때 |
| 8 | indexError | 잘못된 인덱스를 사용할 때 |
| 9 | NameError | 잘못된 이름(변수)을 사용할 때 |
| 10 | SystaxError | 문법이 뜰렸을 때 |
| 11 | TypeError | 계산하려는 데이터의 유형이 잘못되었을 때 |
| 12 | ValueError | 계산하려는 데이터의 값이 잘못되었을 때 |
[![img-9-4.png](https://i.postimg.cc/SR5x711S/img-9-4.png)](https://postimg.cc/p5fvPCt4)

예외 처리 방식
---
**모든 예외를 처리하는 방식**
* 파이썬은 예외 처리를 위해서 try except문을 사용
```python
try:
코드 작성 영역
except:
예외 발생 시 처리 영역
```
* try문에 평소 작성하던 코드를 작성하면 됩니다.
* try문을 실행하다가 예외가 발생하면 해당 예외를 자동으로 except문으로 넘겨서 처리함
```python
try:
a = int(input('제수 입력>>>'))
b = int(input('피제수 입력>>>'))
print(f'{a}/{b}={a/b}')
except:
print('예외 발생')
```
* 실행시 0을 입력해서 의도적으로 예외를 발생 -> 자동으로 except문으로 처리

예제
---
* 사용자가 입력한 키를 정수로 반올림 해서 다시 저장하는 프로그램
* 일부러 예외가 발생하도록 구현했습니다.
* 어떤 부분에서 예외가 발생하는지 찾아보세요.
```python
try:
height = input('키 입력>>>')
height = round(height)
print(f'입력한 키는 {height}cm으로 처리')
except:
print('예외 발생')
```
$$hide
```
입력시 값을 실수로 받지 않습니다.
따라서 height는 str입니다.
round() 함수는 str 자료형의 인수를 처리할 수 없습니다.
TypeError 발생
예외 처리
```
$$

**특정 예외만 처리하는 방식**
* try except를 사용하면 모든 예외 처리가 된다.
* 좀 더 친절한 예외 처리를 위해 다음과 같이 예외 메시지를 출력하고자 한다.
```
0으로 나눌 수 없습니다.
정수만 입력할 수 있습니다.
```
* 이런 경우에는 except문 뒤에 처리하고자 하는 예외를 모두 명시하면 됩니다.
```
try:
a = int(input('제수 입력>>>'))
b = int(input('피제수 입력>>>'))
print(f'{a}/{b}={a/b}')
except ZeroDivisionError:
print('0으로 나눌 수 없음')
except ValueError:
print('정수만 입력')
except:
print('알 수 없는 예외')

# 마지막에 except를 작성하여 예상하지 못한 예외를 모두 처리
```

**예외 메시지 처리**
* 지금까지 모든 예외 메시지를 직접 만들어서 사용함
* 하지만 기본적으로 예외 메시지를 이미 가지고 있음
* 예외들이 가지고 있는 예외 메시지를 확인하려면 except문에 as절을 추가
```python
try:
코드 작성
except 예외 as 예외 메시지:
예외 발생 시 처리 영역
```
* 아래의 내용을 작성해보자
```python
a = [10, 20, 30, 40, 50]

try:
a[10]
except IndexError as e:
print(e)
```
* a 리스트는 인덱스 0~4까지만 사용 가능
* try 내부에서 인덱스 10을 사용
* IndexError발생 > 해당 예외 메시지가 변수 e에 저장
* TIP : 실제 이미 존재하는 예외 메시지는 예외가 발생한 일반적인 이유만 작성됨
* 사용하기 부족한 점이 있으니 직접 만들어서 사용하는 것이 좋다.

**else문과 finally문**
* try except문에 추가로 사용할 수 있다.
* else문은 예외가 발생하지 않으면 처리되는 구문
* finally문은 예외 발생과 상관없이 항상 처리되는 구문
```python
try:
a = int(input('제수 입력>>>'))
b = int(input('피제수 입력>>>'))
result = a / b
except ZeroDivisionError:
print('0으로 나눌 수 없음')
except ValueError:
print('정수만 입력')
except:
print('알 수 없는 예외')
else:
print(f'{a}/{b}={result}')
finally:
print('프로그램 종료')
```

예제
---
* 사용자가 입력한 파일을 읽어서 화면에 출력하는 프로그램
* 만약 사용자가 입력한 파일이 존재하지 않으면 예외 처리를 통해 해당 파일이 존재하지 않는다는 메시지 출력
* 파일은 텍스트 파일
$$hide
```
try:
filename = input('열고자 하는 파일명 입력>>>')
file = open(filename, 'rt')
except FileNotFoundError:
print('파일이 없습니다.')
else:
buffer = file.read()
print(buffer, end='')
print()
file.close()
finally:
print('프로그램 종료')
```
$$

**강제로 예외 발생시키기**
* 파이썬은 예외로 인식하지 못하지만 실제로는 예외인 경우가 있다.
* 예시로 사람의 나이를 입력 받는 프로그램이 있다고 하자
* 50과 같은 정수를 입력하면 아무런 예외가 없다.
* 사용자가 -1000을 입력하더라도 정수이기 때문에 예외가 발생하지 않는다.
* 하지만 -1000은 사람의 나이가 될 수 없기에 예외가 발생되어야 한다.
* 이런 경우 raise문을 사용한다.
```python
raise 예외 클래스()

또는

raise 예외 클래스(예외 메시지)
```
* raise는 일부러 예외를 발생시킨다는 의미
* 주로 사용되는 예외 클래스는 Exception이다.

* 간단한 코드로 문법을 살펴보자
```
try:
raise Exception('강제 예외')
except Exception as e:
print('발생한 예외')
print(e)
```
* raise문은 try문 내부에 작성
* 실제 프로그램을 구현할 때는 if문을 사용해서 예외 발생 조건을 작성한 뒤 raise를 작성하는 것이 일반적이다.

예제
---
* 사용자의 점수를 0부터 100 사이로 입력 받아 80점 이상은 합격, 아니면 불합격을 출력하는 프로그램
* 입력된 정수가 0~100 사이의 유효한 값이 아니면 예외 발생 및 메시지 출력
* 예외 메시지 : 점수는 0~100 사이입니다.
$$hide
```
try:
score = int(input('점수 입력>>>'))
if score < 0 or score > 100:
raise Exception('점수는 0~100')
except Exception as e:
print(e)
else:
if score >= 80:
print(f'{score}, 합격')
else:
print(f'{score}, 불합격')
```
$$

**사용자 예외 클래스**
* 파이썬에 존재하지 않는 예외 클래스를 직접 만들어서 사용
* 직접 예외 클래스를 만드는 방법은 Exception 클래스를 상속받은 클래스를 새로 만드는 것
* Exception 클래스의 생성자인 \_\_init\_\_() 메소드에 전달합니다.

* Exception 클래스를 상속받아야 하므로 기본적인 상속 문법을 알아야 합니다.
```python
class 예외 클래스(Exception):
def __init__(self):
super().__init__('예외 메시지')
```
* 예외 메시지는 예외 클래스를 생성할 때 인자로 전달받아 생성할 수도 있습니다.
```python
class 예외 클래스(Exception):
def __init__(self, message):
super().__init__(message)
```
* 시간의 범위인 -~23 사이를 벗어난 값이 발생되면 '올바른 시간이 아닙니다.'를 출력하는 HourError 클래스 생성
```python
class HourError(Exception):
def __init__(self):
super().__init__('올바른 시간이 아닙니다.')
```
* 다음 코드를 작성 후 예외를 발생해 보자
```python
try:
hour = int(input('시간 입력>>>'))
if hour < 0 or hour > 23:
raise HourError
except HourError as e:
print(e)
```

예제
---
* 입력받은 이름이 2~6자 사이가 아니면 NameError 예외 발생
* 메시지 출력 : 이름은 2~6자 사이
$$hide
```python
class NameError(Exception):
def __init__(self, message):
super().__init__(message)

try:
name = input('이름>>>')
if len(name) < 2 or len(name) > 6:
raise NameError('이름은 2~6자')
except NameError as e:
print(e)
else:
print(f'이름:{name}')
```
$$}

파이썬1 방특