▶︎동적 언어와 정적 언어

• 프로그램 실행 중에 변수의 타입을 동적으로 바꿀 수 있으므로 파이썬을 동적 프로그래밍 언어(dynamic programming language)라고 한다.

  a = 1
  type(a) # <class 'int'>
  

a = "1" type(a) # <class 'str'>

- 한 번 변수에 타입을 지정하면 지정한 타입 외에 다른 타입은 사용할 수 없는 언어를 **정적 프로그래밍 언어(static programming language)**라고 한다.
  - 파이썬과 달리 자바는 정수형(int) 변수 a에 숫자 1을 대입하고 다시 문자열 "1"을 대입하려 할 때 컴파일 오류가 발생한다.
```java
int a = 1;  // a 변수를 int형으로 지정
a = "1";  // a 변수에 문자열을 대입할 수 없으므로 컴파일 에러

동적 언어의 장단점

• 장
  • 파이썬과 같은 동적 언어는 타입에 자유로워 유연한 코딩이 가능하므로 쉽고 빠르게 프로그램을 만들 수 있다.
  • 타입 체크를 위한 코드가 없으므로 비교적 깔끔한 소스 코드를 작성할 수 있다.
• 단
  • 하지만 프로젝트의 규모가 커질수록 타입을 잘못 사용하여 버그가 생길 확률도 높아진다.
    • 안전성을 선호하는 금융권 프로젝트에서는 이런 이유로 동적 언어보다는 정적 언어를 주요 언어로 선택하는 경향이 많다.
      

▶︎파이썬 타입 어노테이션

• 파이썬은 동적 언어의 단점을 극복하기 위해 3.5 버전부터 타입 어노테이션 기능을 지원.
• 정적 언어에서와 같은 강제적인 타입 체크가 아니라 타입 어노테이션(type annotation), 즉 타입에 대한 힌트를 제공하는 정도의 기능만 지원.
• 이는 동적 언어의 장점을 잃지 않으면서 기존에 작성된 코드와의 호환성을 유지하려는 당연한 선택이라고 할 수 있다.

타입 어노테이션 사용

• 기본 어노테이션 타입
  • 정수 int
  • 문자열 str
  • 리스트 list
  • 튜플 tuple
  • 딕셔너리 dict
  • 집합 set
  • 불 bool

변수에 타입 지정

• 변수 이름 바로 뒤에 : int와 같이 콜론과 타입을 작성하여 num 변수가 int형이라는 것을 명시.
• 이는 코드를 읽는 사람에게 해당 변수가 어떤 타입의 값을 저장할 것인지 미리 알려주는 역할을 한다.

  num: int = 1
  name: str = "홍길동"
  numbers: list = [1, 2, 3]

함수에 타입 지정

• 함수의 매개변수에도 같은 규칙을 적용하여 매개변수의 타입을 명시.
• -> int처럼 화살표 기호를 사용해 함수의 반환값 타입도 명시할 수 있다.
• 함수를 사용하는 사람이 어떤 타입의 인수를 넘겨야 하고, 어떤 타입의 값을 반환받을지 쉽게 알 수 있다.

  def add(a: int, b: int) -> int: 
    return a + b
  

def greet(name: str) -> str: return f"안녕하세요, {name}님!"

def get_user_info(user_id: int) -> dict: return {"id": user_id, "name": "홍길동"}

<br/>

# ▶︎typing 모듈과 내장 타입의 발전
- 기본 타입 어노테이션(int, str, list 등)만으로도 많은 경우를 처리할 수 있지만, 더 구체적인 타입 정보가 필요할 때 typing 모듈 사용.
- 파이썬 3.9부터는 내장 타입(list, dict, tuple 등)을 직접 사용할 수 있게 되어 typing 모듈의 List, Dict, Tuple을 가져올 필요가 없어졌다. 
  ```python
  # 파이썬 3.5~3.8: typing 모듈 필수
  from typing import List, Dict, Tuple, Optional

  numbers: List[int] = [1, 2, 3]
  user_info: Dict[str, int] = {"age": 30}

  # 파이썬 3.9 이상: 내장 타입 사용 가능  
  numbers: list[int] = [1, 2, 3]
  user_info: dict[str, int] = {"age": 30}

• 하지만 여전히 typing 모듈이 필요한 경우들이 있다.

  from typing import Optional, Union, Callable, Any
  
  # 1. Optional - None이 가능한 경우
  user_name: Optional[str] = None  # str 또는 None
  
  # 2. Union - 여러 타입이 가능한 경우  
  user_id: Union[int, str] = "jenny"  # 정수 또는 문자열 (user_id로 정수도 사용가능)
  
  # 3. Callable - 함수 타입 지정
  def process_data(callback: Callable[[int], str]) -> str:
      return callback(42)
  
  # 4. Any - 모든 타입 허용 (비상시에만 사용)
  unknown_data: Any = {"key": "value"}
  
  # 5. 복잡한 중첩 구조
  nested_data: dict[str, list[Optional[int]]] = {
      "scores": [95, None, 87, None]
  }

  
  

▶︎mypy

• 파이썬은 타입 어노테이션으로 매개변수의 타입을 명시하더라도 다음과 같이 다른 타입의 인수를 입력할 수 있다.
  • 파이썬 타입 어노테이션이 강제적인 타입 체크가 아닌 단순한 힌트 역할만 하기 때문.
  • 타입 어노테이션을 무시하고도 프로그램이 정상적으로 동작한다.

    def add(a: int, b: int) -> int: 
    return a+b
    

result = add(3, 3.4) print(result) # 6.4

```

• 파이썬 자체로는 타입 어노테이션을 검사하지 않지만, 별도 도구를 사용하면 더 적극적으로 타입을 검사할 수 있다. 그 대표적인 도구가 바로 mypy이다.
• mypy: 정적 타입 검사기. 코드를 실행하기 전에 타입 어노테이션이 올바른지 미리 확인해준다. mypy는 파이썬 표준 라이브러리가 아니므로 pip install mypy 설치해야 한다.
• 대규모 프로젝트나 팀 개발에서는 코드의 가독성과 유지보수성을 높이기 위해 타입 어노테이션을 적극적으로 활용하고 있다. FastAPI, Django 등 인기 있는 프레임워크들도 타입 어노테이션을 적극 지원하므로, 현대적인 파이썬 개발에서는 필수적인 기능이라고 할 수 있다.

• 반복 가능(iterable) 객체: for 문과 같은 반복 구문에 적용할 수 있는 리스트와 같은 객체.

▶︎이터레이터

• 이터레이터: 데이터를 하나씩 순서대로 꺼내올 수 있는 객체.
  • next() 함수를 사용하여 값을 하나씩 가져올 수 있다.
  • 모든 값을 다 가져오면 StopIteration 예외가 발생한다.
• 반복 가능하다고 해서 이터레이터는 아니다.

  a = [1, 2, 3]
  next(a) # 오류

• 하지만 반복 가능하다면 다음과 같이 iter 함수를 이용해 이터레이터로 만들 수 있다.

  a = [1, 2, 3]
  ia = iter(a)
  type(ia) # <class 'list_iterator'>
  

next(ia) # 1 next(ia) # 2 next(ia) # 3 next(ia) # StopIteration 예외

- next 함수를 호출할 때마다 이터레이터 객체의 요소를 차례대로 반환한다. 하지만 더는 반환할 값이 없다면 StopIteration 예외가 발생한다.
- 이터레이터의 값을 가져오는 가장 일반적인 방법은 for 문을 이용.
  - for 문을 이용하면 자동으로 값을 가져오므로 next 함수를 직접 호출하거나 StopIteration 예외를 처리할 필요가 없다.
  - 이터레이터는 for 문을 이용하여 반복하고 난 후에는 다시 반복하더라도 더는 그 값을 가져오지 못한다. 즉, **for문이나 next로 그 값을 한 번 읽으면 그 값을 다시는 읽을 수 없다.**
```python
a = [1, 2, 3]
ia = iter(a)
for i in ia:
    print(i)

# 1
# 2
# 3

이터레이터 만들기

이터레이터 클래스를 만드는 핵심 규칙

• __iter__ 메서드: 이터레이터 객체 자신을 반환.
• __next__ 메서드: 다음 값을 반환하고, 더 이상 값이 없으면 StopIteration 예외를 발생.
• 이 두 메서드만 구현하면 for 문이나 next() 함수에서 사용할 수 있는 이터레이터가 된다.

MyIterator 클래스의 동작 원리

# iterator.py
class MyIterator:
    def __init__(self, data):
        self.data = data
        self.position = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.position >= len(self.data):
            raise StopIteration
        result = self.data[self.position]
        self.position += 1
        return result

if __name__ == "__main__":
    i = MyIterator([1,2,3])
    for item in i:
        print(item)

• 1. __init__ 메서드: 이터레이터를 초기화.
  • self.data: 반복할 데이터를 저장.
  • self.position: 현재 위치를 추적하는 변수 (0부터 시작).
• 2. __iter__ 메서드: 이터레이터 객체 자신을 반환한다
  • 이 메서드가 있어야 파이썬이 해당 객체를 반복 가능한 객체로 인식한다.
  • for 문, iter() 함수, next() 함수 등에서 사용하기 위해 필수.
  • 보통 return self로 자기 자신을 반환한다.
• 3. __next__ 메서드: 다음 값을 반환.

• self.position을 이용해 현재 위치의 값을 가져온다.
• 위치를 하나씩 증가시킨다.
• 더 이상 값이 없으면 StopIteration 예외를 발생시킨다.

=> 이렇게 구현하면 next() 함수나 for 문에서 사용할 수 있는 이터레이터 완성!

입력받은 데이터를 역순으로 출력

# reviterator.py
class ReverseIterator:
    def __init__(self, data):
        self.data = data
        self.position = len(self.data) -1

    def __iter__(self):
        return self

    def __next__(self):
        if self.position < 0:
            raise StopIteration
        result = self.data[self.position]
        self.position -= 1
        return result

if __name__ == "__main__":
    i = ReverseIterator([1,2,3])
    for item in i:
        print(item)

▶︎제너레이터

• 제너레이터: 간단하게 이터레이터를 만드는 특별한 함수.
• 이터레이터를 클래스로 만들려면 __iter__와 __next__ 메서드를 구현해야 하는 등 복잡하다. 하지만 제너레이터를 사용하면 함수 하나만으로 간단하게 이터레이터를 만들 수 있다.

제너레이터의 핵심 특징

• 일반 함수와 비슷하지만 return 대신 yield 키워드를 사용한다.
• yield를 만나면 값을 반환하고 함수 실행을 일시정지한다.
• 다시 호출하면 일시정지했던 지점부터 계속 실행한다.
• 마치 음악 플레이어의 재생/일시정지 기능처럼 동작.
  

제너레이터 만들기

def mygen():
    yield 'a'
    yield 'b'
    yield 'c'

g = mygen()
type(g) # <class 'generator'>

next(g) # 'a'
next(g) # 'b'
next(g) # 'c'
next(g) # StopIteration 오류

• mygen 함수는 yield 구문을 포함하므로 제너레이터이다.
• 제너레이터 객체는 g = mygen()과 같이 제너레이터 함수를 호출하여 만들 수 있다.
• type 명령어로 확인하면 g 객체는 제너레이터 타입의 객체.
• 제너레이터 객체 g로 next 함수를 실행하면 mygen 함수의 첫 번째 yield 문에 따라 'a' 값을 반환한다.
• 제너레이터는 yield라는 문장을 만나면 그 값을 반환하되 현재 상태를 그대로 기억한다.
• 다시 next() 함수를 실행 시 두 번째 yield 문에 따라 'b' 값을 반환한다.
• 계속해서 next 함수를 호출하면 StopIteration 오류.
  

제너레이터 표현식

• mygen 함수는 1부터 1,000까지 각각의 숫자를 제곱한 값을 순서대로 반환하는 제너레이터.

  # generator.py
  def mygen():
    for i in range(1, 1000):
        result = i * i
        yield result
  

gen = mygen()

print(next(gen)) # 1 print(next(gen)) # 4 print(next(gen)) # 9

- **제너레이터 표현식(generator expression)**: 제너레이터는 def를 이용한 함수로 만들 수 있지만, 튜플 표현식으로 좀 더 간단하게 만들 수도 있다.
```python
gen = (i * i for i in range(1, 1000))

• 이 표현식은 mygen 함수로 만든 제너레이터와 완전히 똑같이 기능한다.
• 여기서 사용한 표현식은 리스트 컴프리헨션(list comprehension) 구문과 비슷. 다만 리스트 대신 튜플을 이용한 점이 다르다.
  

제너레이터와 이터레이터

• 제너레이터는 이터레이터와 서로 상당히 비슷.
• 클래스를 이용해 이터레이터를 작성하면 좀 더 복잡한 행동을 구현할 수 있다.
• 이와 달리 제너레이터를 이용하면 간단하게 이터레이터를 만들 수 있다.
  • 간단한 경우라면 제너레이터 함수나 제너레이터 표현식을 사용하는 것이 가독성이나 유지 보수 측면에서 유리.
• => 이터레이터의 성격에 따라 클래스로 만들 것인지, 제너레이터로 만들 것인지를 선택해야 한다.
  

제너레이터 활용하기

• 상황: 시간이 오래 걸리는 작업을 처리해야 하는데, 모든 결과가 필요하지 않은 경우.

  일반적인 리스트 컴프리헨션

  import time
  
  def longtime_job():
      print("job start")
      time.sleep(1)  # 1초 지연 - 실제로는 데이터베이스 조회, 파일 처리 등을 시뮬레이션
      return "done"
  
  # 리스트 컴프리헨션: 5번의 작업을 모두 실행해서 리스트로 만든다
  list_job = [longtime_job() for i in range(5)]
  print(list_job[0])  # 첫 번째 결과만 필요한 상황

• 문제점

  • longtime_job() 함수는 1초씩 걸린다.
  • 리스트를 만들 때 5번의 함수를 모두 미리 실행한다.
  • 첫 번째 결과만 필요한데도 5초를 기다려야 한다.

제너레이터를 사용한 해결책

import time

def longtime_job():
    print("job start")
    time.sleep(1)
    return "done"

# 제너레이터 표현식: 함수를 미리 실행하지 않고 필요할 때만 실행
list_job = (longtime_job() for i in range(5))
print(next(list_job))  # 첫 번째 값만 요청

• 핵심 차이점
  • [ ] (리스트 컴프리헨션) → ( ) (제너레이터 표현식)으로 변경
  • list_job[0] → next(list_job)으로 값을 가져오는 방식 변경.
• 제너레이터의 동작 방식
  • (longtime_job() for i in range(5))는 함수를 즉시 실행하지 않는다.
  • next(list_job)을 호출할 때 비로소 첫 번째 longtime_job()만 실행한다.
  • 나머지 4개는 실행되지 않는다.
• 결과 분석: 제너레이터를 사용함으로써 놀라운 성능 개선.
  • 실행 시간이 5초에서 1초로 대폭 단축되었다. 이는 리스트 컴프리헨션에서는 5개의 함수를 모두 실행했지만, 제너레이터에서는 필요한 첫 번째 함수만 실행했기 때문.
  • "job start"가 5번 출력되던 것이 1번만 출력되는 것을 보면, 실제로 함수 호출 횟수가 줄어든 것을 확인할 수 있다.
  • 이와 함께 메모리 사용량도 크게 절약되는데, 리스트는 모든 결과를 메모리에 저장하지만 제너레이터는 필요할 때만 값을 생성하기 때문.
• 이런 방식을 '느긋한 계산법(lazy evaluation)'이라고 한다.

제너레이터는 다음과 같은 상황에서 매우 유용하다

• 대용량 데이터 처리 시 메모리 절약
• 시간이 오래 걸리는 작업을 필요할 때만 실행
• 무한한 데이터 스트림 처리

▶︎클로저

• 클로저: 외부 함수의 변수를 기억하는 내부 함수를 말한다.
• 예) 함수 A 안에 함수 B가 있고, 함수 B가 함수 A의 변수를 사용한다고 하자. 보통은 함수 A가 끝나면 함수 A의 변수도 사라진다. 하지만 클로저에서는 함수 A가 끝나도 함수 B가 함수 A의 변수를 계속 사용할 수 있다. 마치 함수 A의 변수가 함수 B 안에 저장되어 있는 것처럼 말이다.

예제) 클래스 사용

• 입력으로 받은 수 n에 항상 3을 곱하여 반환하는 함수. 5를 곱하여 반환하는 함수.

  def mul3(n):
    return n * 3
  

def mul5(n): return n * 5

- 클래스 사용
```python
class Mul:
    def __init__(self, m):
        self.m = m

    def mul(self, n):
        return self.m * n

if __name__ == "__main__":
    mul3 = Mul(3)
    mul5 = Mul(5)

    print(mul3.mul(10))  # 30 출력
    print(mul5.mul(10))  # 50 출력

• __call__ 메서드를 이용하여 개선

  • mul() 함수의 이름을 __call__로 바꾸었다.

  • __call__ 함수는 Mul 클래스로 만든 객체에 인수를 전달하여 바로 호출할 수 있도록 하는 메서드.

    • mul3 객체를 mul3(10)처럼 호출할 수 있다.

      class Mul:
      def __init__(self, m):
        self.m = m
      

    def call(self, n):

    return self.m * n

if name == "main": mul3 = Mul(3) mul5 = Mul(5)

print(mul3(10))  # 30 출력
print(mul5(10))  # 50 출력

<br/>

## 예제) 클로저: 외부 함수 안에 내부 함수를 구현
```python
def mul(m):
    def wrapper(n):
        return m * n
    return wrapper

if __name__ == "__main__":
    mul3 = mul(3)
    mul5 = mul(5)

    print(mul3(10))  # 30 출력
    print(mul5(10))  # 50 출력

• 함수가 함수를 반환하는 것은 파이썬에서 가능하다.
  • 외부 함수 mul 안에 내부 함수 wrapper를 구현.
  • 외부 함수는 내부 함수 wrapper를 반환.
• mul(3)을 호출하면 외부 함수 mul은 종료되지만, 반환된 wrapper 함수는 여전히 m=3 값을 기억하고 있다. -> 클로저의 핵심!
• 이후 mul3(10)을 호출하면 wrapper 함수가 기억하고 있던 m=3 값을 사용해서 3 * 10 = 30을 계산한다.
• 즉, 클로저는 함수가 생성될 때의 환경(변수 값)을 기억하는 특별한 함수라고 할 수 있다.
  • 여기서 반환된 wrapper 함수가 바로 클로저이고,
  • mul과 같이 클로저를 만들어내는 함수를 클로저 팩토리(closure factory) 함수라고 한다.
    

▶︎데코레이터

def myfunc():
    print("함수가 실행됩니다.")

• 이 함수의 실행 시간을 측정 하고 싶다.
  • 함수가 시작하는 순간의 시간과 함수가 종료되는 순간의 시간 차이를 구한다.

    import time
    

def myfunc(): start = time.time() print("함수가 실행됩니다.") end = time.time() print("함수 수행시간: %f 초" % (end-start))

myfunc()

- 실행 시간을 측정해야 하는 함수가 myfunc 말고도 많다면? 이런 코드를 모든 함수에 마찬가지로 적용하는 것은 너무 비효율적이다. -> 클로저 이용.
  - elapsed 함수로 클로저를 만든다. 이 함수는 함수를 인수로 받는다. (파이썬은 함수도 객체이므로 함수 자체를 인수로 전달할 수 있다.)
  - `decorated_myfunc = elapsed(myfunc)`로 생성한 `decorated_myfunc`를 `decorated_myfunc()`로 실행하면 실제로는 elapsed 함수 내부의 wrapper 함수가 실행되고, 이 함수는 전달받은 myfunc 함수를 실행하면서 실행 시간을 함께 출력한다.
```python
import time

def elapsed(original_func):   # 기존 함수를 인수로 받는다.
    def wrapper():
        start = time.time()
        result = original_func()    # 기존 함수를 수행한다.
        end = time.time()
        print("함수 수행시간: %f 초" % (end - start))  # 기존 함수의 수행시간을 출력한다.
        return result  # 기존 함수의 수행 결과를 반환한다.
    return wrapper

def myfunc():
    print("함수가 실행됩니다.")

decorated_myfunc = elapsed(myfunc)
decorated_myfunc()

• 클로저를 이용하면 기존 함수에 기능을 덧붙이기가 매우 편리하다. 이렇게 기존 함수를 바꾸지 않고 기능을 추가할 수 있게 만드는 클로저를 데코레이터(decorator)라고 한다.
• 파이썬은 함수 위에 @+함수명이 있으면 데코레이터 함수로 인식한다.
  • myfunc 함수 바로 위에 @elapsed(@+함수명)라는 데코레이터를 추가.
  • 따라서 이제 myfunc 함수는 ‘elapsed 데코레이터’를 통해 수행될 것이다.

    import time
    

def elapsed(original_func): # 기존 함수를 인수로 받는다. def wrapper(): start = time.time() result = original_func() # 기존 함수를 수행한다. end = time.time() print("함수 수행시간: %f 초" % (end - start)) # 기존 함수의 수행시간을 출력한다. return result # 기존 함수의 수행 결과를 반환한다. return wrapper

@elapsed def myfunc(): print("함수가 실행됩니다.")

decorated_myfunc = elapsed(myfunc) # @elapsed 데코레이터로 인해 더이상 필요하지 않다.

decorated_myfunc()

myfunc()

- 기존 함수에 인수를 넣고 싶을 때.
  - myfunc 함수는 입력 인수가 필요하지만, elapsed 함수 안의 wrapper 함수는 전달받은 myfunc 함수를 입력 인수 없이 호출해 오류가 발생.
  - 그러므로 **데코레이터 함수는 기존 함수의 입력 인수에 상관없이 동작하도록 만들어야 한다.** 데코레이터는 기존 함수가 어떤 입력 인수를 취할지 알 수 없기 때문이다. 
  - 이렇게 전달받아야 하는 기존 함수의 입력 인수를 알 수 없는 경우에는 `*args`**와** `**kwargs` **매개변수를 이용**하면 된다.
```python
import time

def elapsed(original_func):   # 기존 함수를 인수로 받는다.
    def wrapper(*args, **kwargs):   # *args, **kwargs 매개변수 추가
        start = time.time()
        result = original_func(*args, **kwargs)  # 전달받은 *args, **kwargs를 입력파라미터로 기존함수 수행
        end = time.time()
        print("함수 수행시간: %f 초" % (end - start))  # 수행시간을 출력한다.
        return result  # 함수의 결과를 반환한다.
    return wrapper

@elapsed
def myfunc(msg):
    """ 데코레이터 확인 함수 """
    print("'%s'을 출력합니다." % msg)

myfunc("You need python")

+) *args와 **kwargs

• *args: 모든 입력 인수를 튜플로 변환하는 매개변수.

• **kwargs: 모든 ‘키=값’ 형태의 입력 인수를 딕셔너리로 변환하는 매개변수.

• func(1, 2, 3, name='foo', age=3) 함수가 입력 인수의 개수와 형태에 상관없이 모든 입력을 처리하려면.

  def func(*args, **kwargs):
      print(args)
      print(kwargs)
  
  func(1, 2, 3, name='foo', age=3)
  # (1, 2, 3)
  # {'age': 3, 'name': 'foo'}

  • func 함수에 *args, **kwargs 매개변수를 지정하면 다양한 입력 인수를 모두 처리할 수 있다.
  • 1, 2, 3 같은 일반 입력은 args 튜플, name = 'foo'와 같은 ‘키=값’ 형태의 입력은 kwargs 딕셔너리로 저장한다.

아스키코드

• 컴퓨터는 오직 숫자만 이해할 수 있기 때문에 문자를 처리하려면 특별한 방법이 필요하다.
• 과거부터 지금까지 사용하는 유일한 방법 -> 문자와 숫자를 1:1로 매칭시키는 문자 셋(character set)을 만들기.
  • 예) 숫자 65는 'A', 숫자 66은 'B'와 같이 숫자마다 문자를 매핑해 놓으면 컴퓨터는 해당 숫자를 문자로 대체하여 인식.
• 초기 컴퓨터 시대에는 각 회사마다 서로 다른 문자 셋을 만들어 사용. -> 호환성 문제.
• 1960년대 미국에서 아스키(ASCII, American Standard Code for Information Interchange)라는 표준을 만들었다.
  • 전 세계 모든 컴퓨터가 같은 규칙을 사용하도록 한 최초의 문자 셋 표준.
  • 총 128개의 문자를 지원: 영문 대소문자, 숫자, 특수문자를 포함하여 영어권 국가에서 사용하는 모든 문자를 처리하는 데는 부족함이 없었다.
    

유니코드

• 아스키의 한계: 128개 문자로는 한글, 중국어, 일본어, 아랍어 같은 다른 나라의 문자들을 표현할 수 없다.
• 각 나라에서는 자신만의 문자 셋을 만들기 시작했다.
  • 한국: 한글과 한자를 처리하기 위한 KSC5601
  • 일본: 히라가나와 가타카나, 한자를 위한 JIS
  • 중국: 중국어 간체를 위한 GB2312
• 한국 컴퓨터에서 만든 문서를 일본 컴퓨터에서 열면 글자가 깨져 보였고, 한글과 중국어를 같은 문서에 함께 쓰는 것도 불가능. -> 각 나라 웹사이트를 보려면 매번 다른 설정을 해야 하고, 잘못 설정하면 깨진 글자.
• 1990년대에 유니코드(Unicode) 등장.
  • 유니코드는 전 세계 모든 문자를 하나의 거대한 표에 정리하자는 아이디어에서 출발.
  • 현재 유니코드는 100만 개 이상의 문자를 지원할 수 있도록 설계되어 있으며, 한글, 중국어, 일본어, 아랍어는 물론 이집트 상형문자와 이모지까지 포함하고 있다.
• 유니코드가 전 세계 표준으로 자리 잡으면서 이제 한 문서에 "Hello 안녕하세요 こんにちは 你好"처럼 여러 나라 언어를 자유롭게 섞어 쓸 수 있게 되었다.

유니코드로 문자열 다루기

• 파이썬은 버전 3부터 모든 문자열을 유니코드로 처리한다.
• 인코딩: 유니코드 문자열을 바이트 문자열로 바꾸는 것.
  • 유니코드 문자열은 인코딩(encoding) 없이 그대로 파일에 적거나 다른 시스템으로 전송할 수 없다.
  • 유니코드 문자열은 단순히 문자 셋의 규칙이기 때문.
  • 파일에 적거나 다른 시스템으로 전송하려면 바이트(byte) 문자열로 변환해야 한다.
• 디코딩: 바이트 문자열을 유니코드 문자열로 바꾸는 것.
  • 파일을 읽거나 네트워크를 통해 바이트 문자열을 수신할 때는 해당 바이트가 어떤 방식의 인코딩을 사용했는지를 미리 알아야만 디코딩할 수 있다.

인코딩하기 encode()

• 유니코드 문자열을 바이트 문자열로 바꾸는 방법.
• 인수를 생략하면 기본값인 utf-8로 동작한다.

  a = "Life is too short"
  b = a.encode('utf-8')
  

b # 'Life is too short' type(b) # <class 'bytes'>

```

디코딩하기 decode()

• euc-kr로 인코딩한 바이트 문자열을 utf-8로 디코딩하려 한다면 오류.

입출력과 인코딩

: 파일을 읽거나 네트워크를 통해 데이터를 주고받을 때 추천하는 방법.

• 입력으로 받은 바이트 문자열은 되도록 빨리 유니코드 문자열로 디코딩한다.
• 함수나 클래스 등에서는 유니코드 문자열만 사용한다.
• 입력에 대한 결과를 전송하는 마지막 부분에서만 유니코드 문자열을 바이트 문자열로 인코딩해서 반환한다.

이와 같은 규칙을 지킨다면 인코딩과 관련해서 큰 어려움은 없을 것이다. (다중 인코딩되거나 문자열이 꼬여 버리는 불상사가 발생하기도 한다.)

• 외부 라이브러리는 파이썬 표준 라이브러리가 아니므로 사용하려면 먼저 pip 도구를 이용하여 설치해야 한다.

▶︎pip

• pip: 파이썬 모듈이나 패키지를 쉽게 설치할 수 있도록 도와주는 도구.
• 의존성 있는 모듈이나 패키지를 자동으로 함께 설치해 준다.
  • 예를 들어, B 패키지를 설치하기 위해 A 패키지가 먼저 필요하다면, pip은 B 패키지를 설치할 때 A 패키지도 자동으로 함께 설치해 준다.

• pip install SomePackage
• pip uninstall SomePackage: 설치한 패키지를 삭제.
• pip install SomePackage==1.0.4: 특정 버전으로 설치. 버전을 생략하면 최신 버전으로 자동 설치.
• pip install --upgrade SomePackage: 최신 버전으로 업그레이드.
• pip list: 설치된 패키지 확인.
  

▶︎Faker

• 테스트용 가짜 데이터를 생성할 때 사용.
• 설치: pip install Faker

Faker 함수들

Faker 사용해 보기

• 이름

  from faker import Faker
  

fake = Faker() fake.name() # 'Matthew Estrada'

- 한글이름
```python
fake = Faker('ko-KR')
fake.name() # '김하은'

• 주소

  fake.address() # '충청북도 수원시 잠실6길 (경자주이읍)'

  
  

▶︎sympy

• sympy: 방정식 기호(symbol)를 사용하게 해 주는 외부 라이브러리.
• 설치: pip install sympy

sympy 사용해 보기

• sympy.symbols(): x처럼 방정식에 사용하는 미지수를 나타내는 기호를 생성할 때 사용.

  x = sympy.symbols("x")
  x, y = sympy.symbols('x y') # 2개의 미지수가 필요 시

• sympy.Eq(a, b): a와 b가 같다는 방정식.

  f = sympy.Eq(x*Fraction('2/5'), 1760)

• +) fractions.Fraction: 유리수 연산을 정확하게 계산하기 위해 사용.
  • Fraction(분자, 분모)
  • Fraction('분자 / 분모')

    a = Fraction(1, 5)
    a = Fraction('1/5')

• sympy.solve(f): x에 해당하는 값 구하기.
  • 방정식의 해는 여러 개일 수 있으므로 solve() 함수는 결괏값으로 리스트를 반환한다.

    result = sympy.solve(f)
    result # [4400]

    
    

sympy 활용

• 2차 방정식의 해 구하기.

  x = sympy.symbols("x")
  f = sympy.Eq(x**2, 1)
  sympy.solve(f) # [-1, 1]

• 연립방정식의 해 구하기.
  • 미지수가 2개 이상이라면 결괏값이 리스트가 아닌 딕셔너리.

    x, y = sympy.symbols('x y')
    f1 = sympy.Eq(x+y, 10)
    f2 = sympy.Eq(x-y, 4)
    sympy.solve([f1, f2]) # {x: 7, y: 3}

• 파이썬 표준 라이브러리는 파이썬을 설치할 때 자동으로 컴퓨터에 설치된다.

📍datetime.date

• datetime.date: 연, 월, 일로 날짜를 표현할 때 사용하는 함수.
• 연, 월, 일로 datetime.date 객체를 만들 수 있다.

  day1 = datetime.date(2021, 12, 14) # 2021-12-14
  day2 = datetime.date(2023, 4, 5)

• 객체.days
  • day2에서 day1을 빼면 datetime 모듈의 timedelta 객체가 반환된다.
  • 이 객체를 diff 변수에 대입하고 이 diff 변수를 이용하여 두 날짜의 차이를 확인할 수 있다.

    diff = day2 - day1
    diff.days # 477

• 요일
  • datetime.date 객체의 weekday 함수
    • 0은 월요일을 의미하며 순서대로 1은 화요일, 2는 수요일, …, 6은 일요일이 된다.

      day = datetime.date(2021, 12, 14)
      day.weekday() # 1

  • isoweekday 함수
    • 월요일은 1, 화요일은 2, …, 일요일은 7을 반환.

      day = datetime.date(2021, 12, 14)
      day.isoweekday() # 2

      
      

▶︎time

📍time.time

• time.time(): UTC(universal time coordinated, 협정 세계 표준시)를 사용하여 현재 시간을 실수 형태로 반환하는 함수.
  • 1970년 1월 1일 0시 0분 0초를 기준으로 지난 시간을 초 단위로 반환해 준다.

    time.time() # 1684983953.5221913

    
    

📍time.localtime

• time.localtime: time.time()이 반환한 실숫값을 사용해서 연, 월, 일, 시, 분, 초, ... 의 형태로 바꾸어 주는 함수.
• 입력 인수 없이 사용할 경우 현재 시각을 기준으로 함수가 수행.

  time.localtime(time.time())
  # time.struct_time(tm_year=2023, tm_mon=5, tm_mday=21, tm_hour=16, tm_min=48, tm_sec=42, tm_wday=1, tm_yday=141, tm_isdst=0)

  
  

📍time.asctime

• time.asctime: time.localtime가 반환된 튜플 형태의 값을 인수로 받아서 날짜와 시간을 알아보기 쉬운 형태로 반환하는 함수.
• 입력 인수 없이 사용할 경우 현재 시각을 기준으로 함수가 수행.

  time.asctime(time.localtime(time.time()))
  # 'Fri Apr 28 20:50:20 2023'

  
  

📍time.ctime

• time.ctime(): time.asctime(time.localtime(time.time()))을 간단하게.
• ctime이 asctime과 다른 점은 항상 현재 시간만을 반환한다.

  time.ctime()
  # 'Fri Apr 28 20:56:31 2023'

  
  

📍time.strftime

• time.strftime('출력할 형식 포맷 코드', time.localtime(time.time()))
• 입력 인수 없이 사용할 경우 현재 시각을 기준으로 함수가 수행.
• strftime 함수는 시간에 관계된 것을 세밀하게 표현하는 여러 가지 포맷 코드를 제공한다.
  • %a: 요일의 줄임말 (Mon)
  • %A: 요일 (Monday)
  • %b: 달의 줄임말 (Jan)
  • %B: 달 (January)
  • %c: 날짜와 시간을 출력 (Thu May 25 10:13:52 2023)
  • %d: 일 day ([01,31])
  • %H: 시간 hour, 24시간 출력 형태 ([00,23])
  • %I: 시간 hour, 12시간 출력 형태 ([01,12])
  • %j: 1년 중 누적 날짜 ([001,366])
  • %m: 달 ([01,12])
  • %M: 분 ([01,59])
  • %p: AM or PM (AM)
  • %S: 초 ([00,59])
  • %U: 1년 중 누적 주, 일요일 시작 ([00,53])
  • %W: 1년 중 누적 주, 월요일 시작 ([00,53])
  • %w: 숫자로 된 요일 ([0(일), 6(토)])
  • %x: 현재 설정된 지역에 기반한 날짜 출력 (05/25/23)
  • %X: 현재 설정된 지역에 기반한 시간 출력 (17:22:21)
  • %Y: 연도 출력 (2023)
  • %Z: 시간대 출력 (대한민국 표준시)
  • %%: 문자 % (%)
  • %y: 세기 부분을 제외한 연도 출력 (01)

    time.strftime('%x', time.localtime(time.time()))
    # '05/25/23'
    

time.strftime('%c', time.localtime(time.time()))

'Thu May 25 10:13:52 2023'

<br/>

## 📍time.sleep
- `time.sleep`: 일정한 시간 간격을 두고 루프를 실행할 수 있다.
- 인수는 실수 형태를 쓸 수 있다. 1이면 1초, 0.5면 0.5초.
- 주로 루프 안에서 많이 사용. 
```python
# 1초 간격으로 0부터 9까지의 숫자를 출력
for i in range(10):
    print(i)
    time.sleep(1)

📍math.gcd, math.lcm

• gcd: 최대 공약수(gcd, greatest common divisor)
• lcm: 최소 공배수(lcm, least common multiple)

  math.gcd(60, 100, 80) # 20
  math.lcm(15, 25) # 75

  
  

▶︎random 모듈

• random: 난수(규칙이 없는 임의의 수)를 발생시키는 모듈.
• 📍random()
  • 0.0에서 1.0 사이의 실수 중에서 난수 값을 반환

    random.random() # 0.53840103305098674

  • 1에서 10 사이의 정수 중에서 난수 값을 반환

    random.randint(1, 10) # 6

• 📍choice(리스트, 무작위로 추출할 원소의 개수): 입력으로 받은 리스트에서 무작위로 하나를 선택하여 반환.

  data = [1, 2, 3, 4, 5]
  random.sample(data, len(data)) # [5, 1, 3, 4, 2]

  
  

▶︎itertool 모듈

📍itertools.zip_longest

• itertools.zip_longest(*iterables, fillvalue=None)
• 같은 개수의 자료형을 묶는 파이썬 내장 함수인 zip 함수와 똑같이 동작.
• 전달한 반복 가능 객체(*iterables)의 길이가 서로 다르다면 긴 객체의 길이에 맞춰 fillvalue에 설정한 값을 짧은 객체에 채울 수 있다.

  students = ['한민서', '황지민', '이영철', '이광수', '김승민']
  snacks = ['사탕', '초컬릿', '젤리']
  

result = zip(students, snacks) print(list(result)) # [('한민서', '사탕'), ('황지민', '초컬릿'), ('이영철', '젤리')]

result = itertools.zip_longest(students, snacks, fillvalue='새우깡') print(list(result)) # [('한민서', '사탕'), ('황지민', '초콜릿'), ('이영철', '젤리'), ('이광수', '새우깡'), ('김승민', '새우깡')]

<br/>

## 📍itertools.permutations. itertools.combinations
- `itertools.permutations(iterable, r)`
  - 반복 가능 객체 중에서 r개를 선택한 순열을 이터레이터(반복 가능한 객체)로 반환하는 함수.
  ```python
  list(itertools.permutations(['1', '2', '3'], 2))
  # [('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')]

• itertools.permutations(iterable, r)
  • 반복 가능 객체 중에서 r개를 선택한 조합을 이터레이터로 반환하는 함수. (조합은 순서에 상관없이)

    list(itertools.combinations(['1', '2', '3'], 2))
    # [('1', '2'), ('1', '3'), ('2', '3')]

• itertools.combinations_with_replacement()
  • 같은 숫자를 허용하는 중복 조합.

    len(list(itertools.combinations_with_replacement(range(1, 46), 6)))
    # 15890700

    
    

📍functools.reduce

• functools.reduce(function, iterable)
  • 함수(function)를 반복 가능한 객체(iterable)의 요소에 차례대로(왼쪽에서 오른쪽으로) 누적 적용하여 이 객체를 하나의 값으로 줄이는 함수.

    data = [1, 2, 3, 4, 5]
    result = functools.reduce(lambda x, y: x + y, data)
    print(result)  # 15 

    # functools.reduce()로 최댓값 구하기
    num_list = [3, 2, 8, 1, 6, 7]
    max_num = functools.reduce(lambda x, y: x if x > y else y, num_list)
    print(max_num)  # 8 출력

    
    

▶︎operator 모듈

📍operator.itemgetter

• 주로 sorted와 같은 함수의 key 매개변수에 적용하여 다양한 기준으로 정렬할 수 있도록 도와준다.

• 리스트

  from operator import itemgetter
  
  students = [
      ("jane", 22, 'A'),
      ("dave", 32, 'B'),
      ("sally", 17, 'B'),
  ]
  
  result = sorted(students, key=itemgetter(1))
  # [('sally', 17, 'B'), ('jane', 22, 'A'), ('dave', 32, 'B')]

  • itemgetter(1): students의 아이템인 튜플의 두 번째 요소를 기준으로 정렬.

• 딕셔너리

  from operator import itemgetter
  
  students = [
      {"name": "jane", "age": 22, "grade": 'A'},
      {"name": "dave", "age": 32, "grade": 'B'},
      {"name": "sally", "age": 17, "grade": 'B'},
  ]
  
  result = sorted(students, key=itemgetter('age'))
  # [{'name': 'sally', 'age': 17, 'grade': 'B'}, {'name': 'jane', 'age': 22, 'grade': 'A'}, {'name': 'dave', 'age': 32, 'grade': 'B'}]

  • itemgetter('age')처럼 딕셔너리의 키를 사용해야 한다.
    

📍operator.attrgetter

• 리스트의 요소가 튜플이 아닌 클래스의 객체라면 다음처럼 attrgetter()를 적용하여 정렬해야 한다.

  from operator import attrgetter
  

class Student: def init(self, name, age, grade): self.name = name self.age = age self.grade = grade

students = [ Student('jane', 22, 'A'), Student('dave', 32, 'B'), Student('sally', 17, 'B'), ]

result = sorted(students, key=attrgetter('age'))

- attrgetter('age'): Student 객체의 age 속성으로 정렬하겠다는 의미.
<br/>

# 📍shutil
- 파일을 복사(copy)하거나 이동(move)할 때 사용하는 모듈.
- `shutil.copy`
- `shutil.move`
```python
shutil.copy("c:/doit/a.txt", "c:/temp/a.txt.bak") #  c:\doit\a.txt를 c:\temp\a.txt.bak이라는 이름으로 복사
shutil.move("c:/doit/a.txt", "c:/temp/a.txt") # 이동

📍glob.glob

-glob(pathname): 디렉터리에 있는 파일들을 리스트로 만들기.

• *, ? 등 메타 문자를 써서 원하는 파일만 읽어 들일 수도 있다.
  • ?: 1자리 문자열
  • *: 임의의 길이의 문자열

    import glob
    

glob.glob("c:/doit/mark*")

['c:/doit\marks1.py', 'c:/doit\marks2.py', 'c:/doit\marks3.py']

<br/>

# ▶︎pickle 모듈
- pickle: 객체의 형태를 그대로 유지하면서 파일에 저장하고 불러올 수 있게 하는 모듈. 
- 어떤 자료형이든 저장하고 불러올 수 있다.

## 📍pickle.dump
- `pickle.dump`: 딕셔너리 객체인 data를 그대로 파일에 저장.
```python
import pickle

f = open("test.txt", 'wb')
data = {1: 'python', 2: 'you need'}
pickle.dump(data, f)
f.close()

📍pickle.dump

• pickle.load: 원래 있던 딕셔너리 객체(data) 상태 그대로 불러온다.

  import pickle
  

f = open("test.txt", 'rb') data = pickle.load(f) print(data) # {2:'you need', 1:'python'}

<br/>

# ▶︎os 모듈
- 환경 변수나 디렉터리, 파일 등의 OS 자원을 제어할 수 있게 해 주는 모듈.

## 📍os.environ
- 내 시스템의 환경 변숫값을 알고 싶을 때.
- 환경 변수에 대한 정보를 딕셔너리 형태로 구성된 environ 객체로 반환한다.
```python
os.environ
# environ({'PROGRAMFILES': 'C:\\Program Files', 'APPDATA': … 생략 …})

# 반환받은 객체를 호출하여 사용
os.environ['PATH']
# 'C:\\ProgramData\\Oracle\\Java\\javapath;...생략...'

📍os.chdir

• 현재 디렉터리의 위치를 변경.

  os.chdir("C:\WINDOWS")

  
  

📍os.getcwd

• 현재 자신의 디렉터리 위치를 반환

  os.getcwd() # 'C:\WINDOWS'

  
  

📍os.system

• os.system("명령어"): 시스템 명령어 호출.

  os.system("dir")

  
  

📍os.popen

• 시스템 명령어를 실행한 결괏값을 읽기 모드 형태의 파일 객체로 반환.

  f = os.popen("dir")
  print(f.read()) # 객체 읽기

그 외

• 📍os.mkdir(디렉터리): 디렉터리를 생성.
• 📍os.rmdir(디렉터리): 디렉터리를 삭제. 단, 디렉터리가 비어 있어야 삭제할 수 있다.
• 📍os.remove(파일): 파일을 지운다.
• 📍os.rename(src, dst): src라는 이름의 파일을 dst라는 이름으로 바꾼다.
  

▶︎threading

• 컴퓨터에서 동작하고 있는 프로그램을 프로세스(process)라고 한다.
• 보통 1개의 프로세스는 1가지 일만 하지만, 스레드(thread)를 사용하면 한 프로세스 안에서 2가지 또는 그 이상의 일을 동시에 수행할 수 있다.
• 📍threading.Thread(): 스레드 생성.
• 📍start(): 스레드 실행.
• 📍join(): 해당 스레드가 종료될 때까지 기다리게 한다.

  # thread_test.py
  import time
  import threading
  

def long_task(): for i in range(5): time.sleep(1) print("working:%s\n" % i)

print("Start")

threads = [] for i in range(5): # long_task를 5회 수행 t = threading.Thread(target=long_task) # 스레드 생성 threads.append(t)

for t in threads: t.start() # 스레드 실행

for t in threads: t.join() # join으로 스레드가 종료될때까지 기다린다.

print("End")

<br/>

# ▶︎traceback 모듈
- traceback: 프로그램 실행 중 발생한 오류를 추적하고자 할 때 사용하는 모듈이다.
- 📍`traceback.format_exc()`: 오류 추적 결과를 문자열로 반환하는 함수.
```python
import traceback

def a():
    return 1/0

def b():
    a()

def main():
    try:
        b()
    except:
        print("오류가 발생했습니다.")
        print(traceback.format_exc())

main()


# 오류가 발생했습니다.
# Traceback (most recent call last):
#   File "c:\doit\traceback_sample.py", line 14, in main
#     b()
#   File "c:\doit\traceback_sample.py", # line 9, in b
#     a()
#   File "c:\doit\traceback_sample.py", line 5, in a
#     return 1/0
# ZeroDivisionError: division by zero

▶︎json

• 📍json.load(파일_객체): JSON 파일을 읽어 데이터를 딕셔너리 자료형으로 반환.

  with open('myinfo.json') as f:
    data = json.load(f)
  

type(data) # <class 'dict'> data # {'name': '홍길동', 'birth': '0525', 'age': 30}

- 📍`json.dump(딕셔너리, 파일_객체)`: 딕셔너리 자료형을 JSON 파일로 생성.
```python
data = {'name': '홍길동', 'birth': '0525', 'age': 30}
with open('myinfo.json', 'w') as f:
    json.dump(data, f)

• 📍json.dumps(): 파이썬 자료형을 JSON 문자열로.
  • 딕셔너리를 JSON 데이터로 변경하면 ‘홍길동’과 같은 한글 문자열이 코드 형태로 표시된다. 왜냐하면 dump(), dumps() 함수는 기본적으로 데이터를 아스키 형태로 저장하기 때문.
  • ensure_ascii=False 옵션: 한글 문자열이 아스키 형태의 문자열로 변경되는 것을 방지.
  • indent 옵션: 출력되는 JSON 문자열을 보기 좋게 정렬.
  • 리스트나 튜플처럼 다른 자료형도 JSON 문자열로 바꿀 수 있다.
• 📍json.loads(): JSON 문자열을 딕셔너리로 다시 역변환.
  • 그러나 JSON 문자열을 딕셔너리로 다시 역변환하여 사용하는 데는 전혀 문제가 없다.

    d = {"name":"홍길동", "birth":"0525", "age": 30}
    

json_data = json.dumps(d) json_data # '{"name": "\ud64d\uae38\ub3d9", "birth": "0525", "age": 30}'

json.loads(json_data)

{'name': '홍길동', 'birth': '0525', 'age': 30}

ensure_ascii=False 옵션

json_data = json.dumps(d, ensure_ascii=False) json_data # '{"name": "홍길동", "birth": "0525", "age": 30}' json.loads(json_data)

{'name': '홍길동', 'birth': '0525', 'age': 30}

indent 옵션

print(json.dumps(d, indent=2, ensure_ascii=False))

{

"name": "홍길동",

"birth": "0525",

"age": 30

}

리스트나 튜플처럼 다른 자료형도 JSON 문자열로 바꿀 수 있다.

json.dumps([1,2,3]) # '[1, 2, 3]' json.dumps((4,5,6)) # '[4, 5, 6]'

<br/>

# ▶︎webbrowser
- 파이썬 프로그램에서 시스템 브라우저를 호출할 때 사용하는 모듈.
- 📍`webbrowser.open_new('http://python.org')`: 새창으로 열기.
- 📍`webbrowser.open('http://python.org')`: 이미 열린 브라우저로 원하는 사이트를 열고 싶다면.
<br/>

📍abs

• abs(x): 어떤 숫자를 입력받았을 때 그 숫자의 절댓값을 반환하는 함수.

  abs(3) # 3
  abs(-3) # 3
  abs(-1.2) # 1.2

  
  

📍all, any

• all(x): 반복 가능한 데이터 x를 입력값으로 받으며 이 x의 요소가 모두 참이면 True, 거짓이 하나라도 있으면 False를 반환.

  all([1, 2, 3]) # True
  all([1, 2, 3, 0]) # False
  all([]) # True

• any(x): 반복 가능한 데이터 x를 입력으로 받아 x의 요소 중 하나라도 참이 있으면 True를 반환하고 x가 모두 거짓일 때만 False를 반환한다.

  any([1, 2, 3, 0]) # True
  any([0, ""]) # False
  any([]) # False

  
  

📍chr, ord

• chr(i): 유니코드 숫자 값을 입력받아 그 코드에 해당하는 문자를 반환하는 함수.

  chr(97) # 'a'
  chr(44032) # '가'

• ord(c): 문자의 유니코드 숫자 값을 반환하는 함수.

  ord('a') # 97
  ord('가') #44032

  
  

📍dir

• dir(): 객체가 지닌 변수나 함수를 보여 주는 함수.

  dir([1, 2, 3]) # ['append', 'count', 'extend', 'index', 'insert', 'pop',...]
  dir({'1':'a'}) # ['clear', 'copy', 'get', 'has_key', 'items', 'keys',...]
  

<br/>

# 📍divmod
- `divmod(a, b)`: 2개의 숫자 a, b를 입력으로 받는다. 그리고 a를 b로 나눈 몫과 나머지를 튜플로 반환한다.
```python
divmod(7, 3) # (2, 1)

📍enumerate

• enumerate(): 순서가 있는 데이터(리스트, 튜플, 문자열)를 입력으로 받아 인덱스 값을 포함하는 enumerate 객체를 반환한다.
• 보통 enumerate 함수는 for 문과 함께 사용한다.
• 자료형의 현재 순서index와 그 값을 쉽게 알 수 있다.

  for i, name in enumerate(['body', 'foo', 'bar']):
    print(i, name)
  

0 body

1 foo

2 bar

<br/>

# 📍eval
- `eval()`: 문자열로 구성된 표현식을 입력으로 받아 해당 문자열을 실행한 결괏값을 반환하는 함수.
```python
eval('1+2') # 3
eval("'hi' + 'a'") # 'hia'
eval('divmod(4, 3)') # (1, 1)

📍filter

• filter(함수, 반복_가능한_데이터)
  • 첫 번째 인수로 함수, 두 번째 인수로 그 함수에 차례로 들어갈 반복 가능한 데이터를 받는다.
  • 그리고 반복 가능한 데이터의 요소 순서대로 함수를 호출했을 때 반환값이 참인 것만 묶어서(걸러 내서) 반환한다.

    def positive(x):
    return x > 0
    

print(list(filter(positive, [1, -3, 2, 0, -5, 6]))) # [1, 2, 6]

list 함수는 filter 함수의 반환값을 리스트로 출력하기 위해 사용

<br/>

# 📍hex
- `hex(x)`: 정수를 입력받아 16진수(hexadecimal) 문자열로 변환하여 반환하는 함수.
```python
hex(234) # '0xea'
hex(3) # '0x3'

📍id

• id(object): 객체를 입력받아 객체의 고유 주솟값(레퍼런스)을 반환하는 함수.

  a = 3
  id(3) # 135072304
  id(a) # 135072304
  

b = a id(b) # 135072304

id(4) # 135072292

<br/>

# 📍input
- `input([prompt])`: 사용자 입력을 받는 함수. 입력 인수로 문자열을 전달하면 그 문자열은 프롬프트가 된다.
```python
a = input()
hi
a # 'hi'

b = input("Enter: ")
Enter: hi
b # 'hi'

📍int

• int(x): 문자열 형태의 숫자나 소수점이 있는 숫자를 정수로 반환하는 함수. 만약 정수가 입력되면 그대로 반환.

  int('3') # 3
  int(3.4) # 3

• int(x, radix): radix 진수로 표현된 문자열 x를 10진수로 변환하여 반환.

  int('11', 2) # 3 (2진수로 표현된 '11'의 10진수 값)
  int('1A', 16) # 26 (16진수로 표현된 '1A'의 10진수 값)

  
  

📍str

• str(object): 문자열 형태로 객체를 변환하여 반환하는 함수.

  str(3) # '3'
  str('hi') # 'hi'

  
  

📍isinstance

• isinstance(object, class)
  • 첫 번째 인수로 객체, 두 번째 인수로 클래스를 받는다.
  • 입력으로 받은 객체가 그 클래스의 인스턴스인지를 판단하여 참이면 True, 거짓이면 False를 반환한다.

    class Person: pass
    

a = Person() isinstance(a, Person) # True

b = 3 isinstance(b, Person) # False

<br/>

# 📍len
- `len(s)`: 입력값 s의 길이(요소의 전체 개수)를 반환하는 함수.
```python
len("python") # 6
len([1,2,3]) # 3
len((1, 'a')) # 2

📍list, tuple

• list(iterable) 반복 가능한 데이터를 입력받아 리스트로 만들어 반환하는 함수.
  • list 함수에 리스트를 입력하면 똑같은 리스트를 복사하여 반환한다.

    list("python") # ['p', 'y', 't', 'h', 'o', 'n']
    list((1,2,3)) # [1, 2, 3]
    list([1, 2, 3]) # [1, 2, 3]

• tuple(iterable): 반복 가능한 데이터를 튜플로 바꾸어 반환하는 함수.
  • 만약 입력이 튜플인 경우에는 그대로 반환.

    tuple("abc") # ('a', 'b', 'c')
    tuple([1, 2, 3]) # (1, 2, 3)
    tuple((1, 2, 3)) # (1, 2, 3)

    
    

📍map

• map(f, iterable)
  • 함수(f)와 반복 가능한 데이터를 입력으로 받는다.
  • map은 입력받은 데이터의 각 요소에 함수 f를 적용한 결과를 반환한다.
• map 함수는 map 객체를 반환한다.

  def two_times(x): 
    return x*2
  

list(map(two_times, [1, 2, 3, 4])) # [2, 4, 6, 8]

<br/>

# 📍max, min
- `max(iterable)`: 인수로 반복 가능한 데이터를 입력받아 그 최댓값을 반환하는 함수.
  ```python
  max([1, 2, 3]) # 3
  max("python") # 'y'

• min(iterable): 인수로 반복 가능한 데이터를 입력받아 그 최솟값을 반환하는 함수.

  min([1, 2, 3]) # 1
  min("python") # 'h' 

  
  

📍oct

• oct(x): 정수를 8진수 문자열로 바꾸어 반환하는 함수.

  oct(34) # '0o42'
  oct(12345) # '0o30071'

  
  

📍open

• open(filename, [mode])
  • ‘파일 이름’과 ‘읽기 방법’을 입력받아 파일 객체를 반환하는 함수.
  • 읽기 방법(mode)을 생략하면 기본값인 읽기 모드(r)로 파일 객체를 만들어 반환한다.
• mode
  • w: 쓰기 모드로 파일 열기.
  • r: 읽기 모드로 파일 열기.
  • a: 추가 모드로 파일 열기.
  • b: 바이너리 모드로 파일 열기.
    • b는 w, r, a와 함께 사용한다.
    • 예) rb: ‘바이너리 읽기 모드’를 의미.

      f = open("binary_file", "rb")

      
      

📍pow

• pow(x, y): x를 y제곱한 결괏값을 반환하는 함수.

  pow(2, 4) # 16
  pow(3, 3) # 27

  
  

📍range

• range([start,] stop [,step]): 입력받은 숫자에 해당하는 범위 값을 반복 가능한 객체로 만들어 반환.
• for 문과 함께 자주 사용.

인수가 하나일 경우

• 시작 숫자를 지정해 주지 않으면 0부터 시작.

  list(range(5)) # [0, 1, 2, 3, 4]

인수가 2개일 경우

• 입력으로 주어지는 2개의 인수는 시작 숫자와 끝 숫자를 나타낸다.
• 단, 끝 숫자는 해당 범위에 포함되지 않는다는 것에 주의.

  list(range(5, 10)) # [5, 6, 7, 8, 9]

  인수가 3개일 경우

• 세 번째 인수는 숫자 사이의 거리를 말한다.

  list(range(1, 10, 2)) # [1, 3, 5, 7, 9]
  list(range(0, -10, -1)) # [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

  
  

📍round

• round(number [,ndigits]): 숫자를 입력받아 반올림해 반환하는 함수.
• 두 번째 인수는 반올림하여 표시하고 싶은 소수점의 자릿수(ndigits)를 의미.

  round(4.6) # 5
  round(4.2) # 4
  round(5.678, 2) # 5.68 (소수점 2자리까지만 반올림)

  
  

📍sorted

• sorted(iterable): 입력 데이터를 정렬한 후 그 결과를 리스트로 반환하는 함수.
• 리스트 자료형의 sort 함수는 리스트 객체 그 자체를 정렬만 할 뿐, 정렬된 결과를 반환하지는 않는다.

  sorted([3, 1, 2]) # [1, 2, 3]
  sorted(['a', 'c', 'b']) # ['a', 'b', 'c']
  sorted("zero") # ['e', 'o', 'r', 'z']
  sorted((3, 2, 1)) # [1, 2, 3]

  
  

📍sum

• sum(iterable): 입력 데이터의 합을 반환하는 함수.

  sum([1,2,3]) # 6
  sum((4,5,6)) # 15

  
  

📍type

• type(object): 입력값의 자료형이 무엇인지 알려 주는 함수.

  type("abc") # <class 'str'>
  type([ ]) # <class 'list'>
  type(open("test", 'w')) # <class '_io.TextIOWrapper'>

  
  

📍zip

• zip(*iterable): 동일한 개수로 이루어진 데이터들을 묶어서 반환하는 함수.
  • *iterable: 반복 가능한 데이터를 여러 개 입력할 수 있다는 의미이다.

    list(zip([1, 2, 3], [4, 5, 6])) # [(1, 4), (2, 5), (3, 6)]
    list(zip([1, 2, 3], [4, 5, 6], [7, 8, 9])) # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
    list(zip("abc", "def")) # [('a', 'd'), ('b', 'e'), ('c', 'f')]

▶︎오류는 언제 발생하는가?

: 파이썬은 오류가 발생하면 프로그램을 중단하고 오류 메시지를 보여 준다.

• 존재하지 않는 파일을 사용하려고 시도했을 때 발생하는 오류.

  >>> f = open("나없는파일", 'r')
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  FileNotFoundError: [Errno 2] No such file or directory: '나없는파일'

• 0으로 다른 숫자를 나누는 경우를 생각해 보자. 이 역시 자주 발생하는 오류.

  >>> 4 / 0
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  ZeroDivisionError: division by zero

• IndexError 오류.

  >>> a = [1, 2, 3]
  >>> a[3]
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  IndexError: list index out of range

  
  

▶︎오류 예외 처리 기법

try:
    ... # 오류가 발생할 수 있는 구문
except 발생오류 as 오류변수:
    ... # 오류 발생
else:
    ... # 오류 발생하지 않음
finally:
    ... # 무조건 마지막에 실행

try-except 문

try:
    ...
except [발생오류 [as 오류변수]]:
    ...

• try 블록 수행 중 오류가 발생하면 except 블록이 수행된다.
• try 블록에서 오류가 발생하지 않는다면 except 블록은 수행되지 않는다.
• []: 괄호 안의 내용을 생략할 수 있다는 관례적인 표기법.

try-except만 쓰는 방법

try:
    ...
except:
    ...

• 오류의 종류에 상관없이 오류가 발생하면 except 블록을 수행한다.

발생 오류만 포함한 except 문

try:
    ...
except 발생오류:
    ...

• 오류가 발생했을 때 except 문에 미리 정해 놓은 오류와 동일한 오류일 경우에만 except 블록을 수행한다.

발생 오류와 오류 변수까지 포함한 except 문

try:
    ...
except 발생오류 as 오류변수:
    ...

• 두 번째 경우에서 오류의 내용까지 알고 싶을 때 사용하는 방법.
• 예

  # try_except.py
  try:
      4 / 0
  except ZeroDivisionError as e:
      print(e) # division by zero

  • 4를 0으로 나누려고 하면 ZeroDivisionError가 발생하여 except 블록이 실행되고 오류 변수 e에 담기는 오류 메시지를 출력할 수 있다.
    

try-finally 문

• finally 절은 try 문 수행 도중 예외 발생 여부에 상관없이 항상 수행된다.

• 보통 finally 절은 사용한 리소스를 close해야 할 때 많이 사용한다.

  # try_finally.py
  try:
    f = open('foo.txt', 'w')
    # 무언가를 수행한다.
  
    (... 생략 ...)
  

finally: f.close() # 중간에 오류가 발생하더라도 무조건 실행된다.

<br/>

## 여러 개의 오류 처리하기
- try 문 안에서 여러 개의 오류를 처리하려면 except를 계속 사용한다.
```python
try:
    ...
except 발생오류1:
   ... 
except 발생오류2:
   ...

• 예) 0으로 나누는 오류와 인덱싱 오류 처리

  # many_error.py
  try:
      a = [1,2]
      print(a[3])
      4/0
  except ZeroDivisionError as e:
      print(e)
  except IndexError as e:
      print(e)
  
  # list index out of range

• 2개 이상의 오류를 동일하게 처리하기 위해서는 괄호를 사용하여 함께 묶어 처리한다.

  try:
      a = [1,2]
      print(a[3])
      4/0
  except (ZeroDivisionError, IndexError) as e:
      print(e)

  
  

try-else 문

try:
    ...
except [발생오류 [as 오류변수]]:
    ...
else:  # 오류가 없을 경우에만 수행
    ...

• try 문 수행 중 오류가 발생하면 except 절, 오류가 발생하지 않으면 else 절이 수행된다.
  

▶︎오류 회피하기

continue

• 특정 오류가 발생할 경우 그냥 통과시켜야 할 때.

  # process_scores.py
  students = ["김철수", "이영희", "박민수", "최유진"]
  

for student in students: try: with open(f"{student}_성적.txt", 'r') as f: score = f.read() print(f"{student}의 성적: {score}") except FileNotFoundError: print(f"{student}의 성적 파일이 없습니다. 건너뜁니다.") continue # 다음 학생으로 넘어감

<br/>

## pass
- 오류를 완전히 무시하고 싶을 때.
- pass는 신중하게 사용해야 한다. 중요한 오류까지 무시하면 나중에 더 큰 문제가 될 수 있다.
```python
# error_pass.py
try:
    # 설정 파일을 읽으려 시도
    f = open("설정파일.txt", 'r')
    config = f.read()
    f.close()
except FileNotFoundError:
    pass  # 설정 파일이 없어도 계속 진행

# 프로그램의 주요 기능은 계속 수행
print("프로그램이 정상적으로 실행됩니다.")

▶︎오류 일부러 발생시키기

• raise 명령어: 오류를 강제로 발생.

  # error_raise.py
  class Bird:
    def fly(self):
        raise NotImplementedError

  class Eagle(Bird):
    pass
  

eagle = Eagle() eagle.fly() # NotImplementedError

=> Bird 클래스를 상속받는 자식 클래스는 반드시 fly 함수를 구현해야 한다

- **NotImplementedError**: 파이썬에 이미 정의되어 있는 오류. 꼭 작성해야 하는 부분이 구현되지 않았을 경우 일부러 오류를 발생시키기 위해 사용.
<br/>

# ▶︎예외 만들기
- 특수한 경우에만 예외 처리를 하려고 종종 예외를 만들어서 사용한다.
- 예외는 파이썬 내장 클래스인 **Exception 클래스**를 상속하여 만들 수 있다.
```python
class MyError(Exception):
    pass

• raise로 MyError 발생.

  def say_nick(nick):
    if nick == '바보':
        raise MyError()
    print(nick)
  

say_nick("천사") # 천사 say_nick("바보") # MyError

- 예외 처리 기법을 사용하여 MyError 발생을 예외 처리.
```python
try:
    say_nick("천사")
    say_nick("바보")
except MyError:
    print("허용되지 않는 별명입니다.")

# 천사
# 허용되지 않는 별명입니다.

_str_

• 오류 메시지를 출력했을 때 오류 메시지가 보이게 하려면 오류 클래스에 _str_ 메서드를 구현해야 한다.
• _str_ 메서드: print(e)처럼 오류 메시지를 print 문으로 출력할 경우에 호출되는 메서드.

  class MyError(Exception):
    def __str__(self):
        return "허용되지 않는 별명입니다."

  try:
    say_nick("천사")
    say_nick("바보")
  except MyError as e:
    print(e)
  

천사

허용되지 않는 별명입니다.

```

▶︎패키지

• 패키지(packages): 관련 있는 모듈의 집합.
  • 파이썬에서 모듈은 하나의 .py 파일이다.
• 파이썬 패키지는 디렉터리와 파이썬 모듈로 이루어진다.
  • 패키지는 파이썬 모듈을 계층적(디렉터리 구조)으로 관리할 수 있게 해 준다.
• 장점
  • 패키지 구조로 파이썬 프로그램을 만드는 것이 공동 작업이나 유지 보수 등 여러 면에서 유리하다.
  • 패키지 구조로 모듈을 만들면 다른 모듈과 이름이 겹치더라도 더 안전하게 사용할 수 있다.
• 예) game 패키지
  • 확장자가 .py인 파일은 파이썬 모듈.
  • game 디렉터리가 이 패키지의 루트 디렉터리.
  • sound, graphic, play는 서브 디렉터리.

    game/
      __init__.py
      sound/
          __init__.py
          echo.py
          wav.py
      graphic/
          __init__.py
          screen.py
          render.py
      play/
          __init__.py
          run.py
          test.py

    
    

▶︎패키지 만들기

1. C:/doit 디렉터리 밑에 game 및 기타 서브 디렉터리를 생성하고 .py 파일들을 다음과 같이 만든다.

• 각 디렉터리에 init.py 파일을 만들어 놓기만 하고 내용은 일단 비워 둔다.

  C:/doit/game/__init__.py
  C:/doit/game/sound/__init__.py
  C:/doit/game/sound/echo.py
  C:/doit/game/graphic/__init__.py
  C:/doit/game/graphic/render.py

2. echo.py 파일의 내용 작성.

   # echo.py
   def echo_test():
    print("echo")

3. render.py 파일의 내용 작성.

   # render.py
   def render_test():
    print("render")

4. game 패키지를 참조할 수 있도록 명령 프롬프트 창에서 set 명령어로 PYTHONPATH 환경 변수에 C:/doit 디렉터리를 추가하고 실행.

   C:\> set PYTHONPATH=C:/doit
   C:\> python

   
   

▶︎패키지 안의 함수 실행하기

1. 모듈을 import하여 실행

import game.sound.echo

game.sound.echo.echo_test() # echo

2. 모듈이 있는 디렉터리까지를 import하여 실행

from game.sound import echo

echo.echo_test() # echo

3. 모듈의 함수를 직접 import하여 실행

from game.sound.echo import echo_test

echo_test() # echo

패키지를 바로 import

import game

game.sound.echo.echo_test() # 오류

• import game을 수행하면 game 디렉터리의 __init__.py에 정의된 것만 참조할 수 있다.
  

함수를 바로 import는 불가

import game.sound.echo.echo_test

# 오류

• 도트 연산자(.)를 사용해서 import a.b.c처럼 import할 때 가장 마지막 항목인 c는 반드시 모듈 또는 패키지여야만 한다.
  

▶︎_init_.py 파일

해당 디렉터리가 패키지의 일부임을 알려준다.

• 만약 game, sound, graphic 등 패키지에 포함된 디렉터리에 _init_.py 파일이 없다면 패키지로 인식되지 않는다.
• python 3.3 버전부터는 _init_.py 파일이 없어도 패키지로 인식한다(PEP 420). 하지만 하위 버전 호환을 위해 _init_.py 파일을 생성하는 것이 안전한 방법이다.
  

패키지와 관련된 설정이나 초기화 코드를 포함할 수 있다.

패키지 변수 및 함수 정의

• 패키지 수준에서 변수와 함수를 정의할 수 있다.

  # C:/doit/game/__init__.py
  

game 패키지의 _init_.py 파일에 공통 변수나 함수를 정의.

VERSION = 3.5

def print_version_info(): print(f"The version of this game is {VERSION}.")

- 패키지의 \__init__.py 파일에 정의된 변수와 함수의 사용.
```python
import game

print(game.VERSION) # 3.5
game.print_version_info() # The version of this game is 3.5.

패키지 내 모듈을 미리 import

• _init_.py 파일에 패키지 내의 다른 모듈을 미리 import하여 패키지를 사용하는 코드에서 간편하게 접근할 수 있게 한다.

  # C:/doit/game/__init__.py
  

패키지 내의 다른 모듈을 미리 import

from .graphic.render import render_test

VERSION = 3.5

def print_version_info(): print(f"The version of this game is {VERSION}.")

```python
# 패키지를 사용하는 코드에서는 간편하게 game 패키지를 통해 render_test 함수를 사용할 수 있다.

import game

game.render_test() # render

패키지 초기화

• _init_.py 파일에 패키지를 처음 불러올 때 실행되어야 하는 코드를 작성할 수 있다.
  • 데이터베이스 연결이나 설정 파일 로드와 같은 작업을 수행할 수 있다.
• 패키지의 초기화 코드는 하위 모듈의 함수를 import할 경우에도 실행된다.
• 단, 초기화 코드는 한 번 실행된 후에는 다시 import를 수행하더라도 실행되지 않는다.

  # C:/doit/game/__init__.py
  from .graphic.render import render_test
  

VERSION = 3.5

def print_version_info(): print(f"The version of this game is {VERSION}.")

여기에 패키지 초기화 코드를 작성한다.

print("Initializing game ...")

```python
# 패키지를 처음 import할 때 초기화 코드가 실행된다.

import game
# Initializing game ...

# game 패키지의 초기화 코드는 game 패키지의 하위 모듈의 함수를 import할 경우에도 실행된다.

from game.graphic.render import render_test
# Initializing game ...

# game 패키지를 import한 후에 하위 모듈을 다시 import 하더라도 초기화 코드는 처음 한 번만 실행된다.

import game
# Initializing game ...

from game.graphic.render import render_test
# 초기화 코드 실행 안됨

_all_

from game.sound import *
# Initializing game ...

echo.echo_test() # echo라는 이름이 정의되지 않았다는 오류 발생.

• 특정 디렉터리의 모듈을 *를 사용하여 import할 때는 해당 디렉터리의 _init_.py 파일에 __all__ 변수를 설정하고 import할 수 있는 모듈을 정의해 주어야 한다.

  # C:/doit/game/sound/__init__.py
  

all = ['echo']

sound 디렉터리에서 *를 사용하여 import할 경우, 이곳에 정의된 echo 모듈만 import된다는 의미.

```python
from game.sound import *
# Initializing game ...

echo.echo_test() #echo

• from game.sound.echo import *은 __all__과 상관없이 import된다. 이렇게 __all__과 상관없이 무조건 import되는 경우는 from a.b.c import *에서 from의 마지막 항목인 c가 모듈인 때이다.
  

▶︎상대경로 패키지

• graphic 디렉터리의 render.py 모듈에서 sound 디렉터리의 echo.py 모듈을 사용하고 싶다면 render.py를 수정하면 가능하다.

  # render.py
  

from game.sound.echo import echo_test # 전체 경로를 사용하여 import from ..sound.echo import echo_test # 상대경로로 import하는 것도 가능

def render_test(): print("render") echo_test()

```python
from game.graphic.render import render_test
# Initializing game ...

render_test()
# render
# echo

▶︎모듈

• 모듈: 함수나 변수 또는 클래스를 모아 놓은 파이썬 파일. 다른 파이썬 프로그램에서 불러와 사용할 수 있도록 만든 파이썬 파일.
• 다른 사람들이 이미 만들어 놓은 모듈을 사용할 수도 있고 우리가 직접 만들어 사용할 수도 있다.
  

▶︎모듈 만들기

• 파이썬 확장자 .py로 만든 파이썬 파일은 모두 모듈이다.

  # mod1.py
  def add(a, b):
    return a + b
  

def sub(a, b): return a-b

이 mod1.py 파일이 바로 모듈이다.

<br/>

# ▶︎모듈 불러오기
- `import`
  - 이미 만들어 놓은 파이썬 모듈을 사용할 수 있게 해 주는 명령어.
  - import는 현재 디렉터리에 있는 파일이나 파이썬 라이브러리가 저장된 디렉터리에 있는 모듈만 불러올 수 있다.
- ** 파이썬 라이브러리**: 파이썬을 설치할 때 자동으로 설치되는 파이썬 모듈.
```python
import mod1

print(mod1.add(3, 4)) # 7
print(mod1.sub(4, 2)) # 2

• mod1. py 파일에 있는 add 함수를 사용하기 위해서는 mod1.add처럼 모듈 이름 뒤에 도트 연산자(.)를 붙이고 함수 이름을 쓰면 된다.

import 사용법

• 모듈 이름은 파일이름.py에서 .py 확장자를 제거한 파일이름만을 가리킨다.

  import 모듈_이름

• 모듈 이름 없이 함수 이름만 쓸 수 있다.

  from 모듈_이름 import 모듈_함수

• 모듈 이름 없이 함수 이름만 쓸 수 있다.

  from 모듈_이름 import 모듈_함수
  from 모듈_이름 import 모듈_함수1, 모듈_함수2

• 모듈의 모든 함수를 불러와 사용 하고 싶을 때.
  • • 문자는 '모든 것'

      from mod1 import *

      
      

클래스나 변수 등을 포함한 모듈

• 모듈은 함수 뿐만 아니라, 클래스나 변수 등을 포함할 수도 있다.

  # mod2.py
  PI = 3.141592
  

class Math: def solv(self, r): return PI * (r ** 2)

def add(a, b): return a+b

클래스, 함수, 변수를 모두 포함

```python
# mod2 사용
import mod2

print(mod2.PI) # 3.141592

a = mod2.Math()
print(a.solv(2)) # 12.566368

print(mod2.add(mod2.PI, 4.4)) # 7.541592

▶︎if name == "main":

# mod1.py
def add(a, b): 
    return a+b

def sub(a, b): 
    return a-b

print(add(1, 4))
print(sub(4, 2))

• mod1.py 파일을 실행 시 함수 실행 결과값이 출력된다.
• 그런데 이 mod1.py 파일의 add와 sub 함수를 사용하기 위해 mod1 모듈을 import할 때도 mod1.py 파일이 실행되어 결괏값을 출력한다.
• if __name__ == "__main__":를 사용 시
  • 직접 이 파일을 실행했을 때는 __name__ == "__main__"이 참이 되어 if 문 다음 문장이 수행된다.
  • 반대로 대화형 인터프리터나 다른 파일에서 이 모듈을 불러 사용할 때는 __name__ == "__main__"이 거짓이 되어 if 문 다음 문장이 수행되지 않는다.
    

_name_ 변수

• 파이썬의 __name__ 변수는 파이썬이 내부적으로 사용하는 특별한 변수 이름이다.
• 만약 C:\python mod1.py처럼 직접 mod1.py 파일을 실행할 경우, mod1.py의 __name__ 변수에는 __main__ 값이 저장된다.
• 하지만 파이썬 셸이나 다른 파이썬 모듈에서 mod1을 import할 경우에는 mod1.py의 __name__ 변수에 mod1.py의 모듈 이름인 mod1이 저장된다.

  import mod1
  

mod1.name # 'mod1'

<br/>

# ▶︎다른 디렉터리에 있는 모듈을 불러오는 방법
## sys.path.append
- sys 모듈: 파이썬을 설치할 때 함께 설치되는 라이브러리 모듈.
- `sys.path`
  - 파이썬 라이브러리가 설치되어 있는 디렉터리 목록을 보여 준다.
  - 이 디렉터리 안에 저장된 파이썬 모듈은 모듈이 저장된 디렉터리로 이동할 필요 없이 바로 불러 사용할 수 있다.
  - sys.path는 리스트.
- `sys.path.append`를 사용해서 sys.path에 디렉터리를 추가하면 추가된 디렉터리에 저장된 파이썬 모듈을 어디서든 불러 사용할 수 있다.
```bash
sys.path.append("C:/doit/mymod")

PYTHONPATH 환경 변수 사용하기

• set 명령어를 사용해 PYTHONPATH 환경 변수에 mod2.py 파일이 있는 C:\doit\mymod 디렉터리를 설정한다. 그러면 디렉터리 이동이나 별도의 모듈 추가 작업 없이 mymod 디렉터리에 저장된 mod2 모듈을 불러와서 사용할 수 있다.
• 맥이나 유닉스 환경에서는 set 대신 export 명령을 사용.

  C:\doit>set PYTHONPATH=C:\doit\mymod

▶︎클래스

• 클래스: 반복되는 변수와 메서드(함수)를 미리 정해놓은 틀.

클래스는 왜 필요한가?

result1 = 0
result2 = 0

def add1(num):  # 계산기1
    global result1
    result1 += num
    return result1

def add2(num):  # 계산기2
    global result2
    result2 += num
    return result2

print(add1(3))
print(add1(4))
print(add2(3))
print(add2(7))

• 위는 계산기 함수.

• 계산기가 3개, 5개, 10개로 점점 더 많이 필요해진다면 어떻게 해야 할까? 그때마다 전역 변수와 함수를 추가할 것인가?

  class Calculator:
    def __init__(self):
        self.result = 0
  
    def add(self, num):
        self.result += num
        return self.result
  

cal1 = Calculator() cal2 = Calculator()

print(cal1.add(3)) print(cal1.add(4)) print(cal2.add(3)) print(cal2.add(7))

- Calculator 클래스로 만든 별개의 계산기 cal1, cal2(이것을 ‘객체’라고 함)가 각각의 역할을 수행한다. 
- 계산기의 결괏값 역시 다른 계산기의 결괏값과 상관없이 독립적인 값을 유지한다. 
- 이렇게 클래스를 사용하면 계산기 대수가 늘어나도 객체를 생성하면 되므로 함수만 사용할 때보다 간단하게 프로그램을 작성할 수 있다. 
- 빼기 기능을 더하고 싶다면 Calculator 클래스에 다음과 같이 빼기 기능을 가진 함수를 추가하면 된다.
```python
class Calculator:
    def __init__(self):
        self.result = 0

    def add(self, num):
        self.result += num
        return self.result

    def sub(self, num):
        self.result -= num
        return self.result

▶︎클래스와 객체

• 클래스: 똑같은 무언가를 계속 만들어 낼 수 있는 설계 도면(과자 틀)
• 객체: 클래스로 만든 피조물(과자 틀로 찍어 낸 과자)
  • 클래스로 만든 객체는 객체마다 고유한 성격을 가진다. 동일한 클래스로 만든 객체들은 서로 전혀 영향을 주지 않는다.

+) 객체와 인스턴스

• 인스턴스: 클래스로 만든 객체.
  • 특정 객체가 어떤 클래스의 객체인지를 관계 위주로 설명할 때 사용한다.
• 예) a = Cookie()
  • a는 객체이다. 그리고 a 객체는 Cookie의 인스턴스이다.
  • ‘a는 인스턴스’보다 ‘a는 객체’라는 표현이 어울리며
  • ‘a는 Cookie의 객체’보다 ‘a는 Cookie의 인스턴스’라는 표현이 훨씬 잘 어울린다.
    

▶︎클래스 만들기

# 클래스 정의
class FourCal:
    def setdata(self, first, second):
        self.first = first
        self.second = second
    def add(self):
        result = self.first + self.second
        return result
     def mul(self):
        result = self.first * self.second
        return result
    def sub(self):
        result = self.first - self.second
        return result
    def div(self):
        result = self.first / self.second
        return result       

# 클래스 사용
a = FourCal()
b = FourCal()

a.setdata(4, 2) # a 객체의 first, second 객체변수에는 각각 값 4와 2가 저장
b.setdata(3, 8)

a.add() # 6
a.mul() # 8
a.sub() # 2
a.div() # 2

b.add() # 11
b.mul() # 24
b.sub() # -5
b.div() # 0.375

클래스 정의

• class 사용.
• 객체를 만들 수 있는 기능을 가지고 있다.

  class FourCal:
    pass

  
  

객체 생성

• 클래스명(): class의 인스턴스인 객체 생성.

  a = FourCal() # a객체 생성, a는 FourCal의 인스턴스
  

type(a) # <class 'main.FourCal'>

<br/>

## 메서드의 매개변수
- 클래스 안에 구현된 함수는 다른 말로 **메서드(method)**라고 부른다.
- 파이썬 메서드의 첫 번째 매개변수 이름은 관례적으로 self를 사용한다. 
  - 객체의 메서드를 호출할 때 호출한 객체 자신이 전달되기 때문에 self라는 이름을 사용.
  - self말고 다른 이름을 사용해도 상관없다.
- 객체를 이용해 클래스의 메서드를 호출하려면 같이 도트(.) 연산자를 사용하면 된다.
- 메서드의 첫 번째 매개변수 self에는 메서드를 호출한 객체가 자동으로 전달된다.
- +) 메서드의 첫 번째 매개변수 self를 명시적으로 구현하는 것은 파이썬만의 독특한 특징이다. 자바와 같은 언어는 첫 번째 매개변수 self가 필요없다.
```python
class FourCal:
    def setdata(self, first, second): # 메서드의 매개변수
        self.first = first # 메서드의 수행문
        self.second = second

a.setdata(4, 2) # 매서드 호출위해 도트(.) 연산자 사용

메서드를 호출하는 방법

1. 객체.메서드
   • self를 반드시 생략해서 호출해야 한다.

     a = FourCal()
     a.setdata(4, 2)

2. 클래스명.메서드
   • 클래스를 이용해 메서드를 호출. (잘 사용하지는 않음.)
   • 객체 a를 첫 번째 매개변수 self에 꼭 전달해야 한다.

     a = FourCal()
     FourCal.setdata(a, 4, 2)

     
     

메서드의 수행문

• 객체에 생성되는 객체 변수를 ‘인스턴스 변수’ 또는 ‘속성’이라고도 부른다.

  class FourCal:
    def setdata(self, first, second): # 메서드의 매개변수
        self.first = first # 메서드의 수행문
        self.second = second
  

a.setdata(4, 2) # a.first = 4, a.second = 2로 설정

- a.first = 4 수행: a 객체에 객체변수 first가 생성되고 4라는 값이 저장된다.
- a.second = 2 수행: a 객체에 객체변수 second가 생성되고 2라는 값이 저장된다.
- 클래스로 만든 객체의 객체변수는 다른 객체의 객체변수에 상관없이 **독립적인 값을 유지**한다.
```python
a.setdata(4, 2) 
b.setdata(3, 7) 

a.first # 4
b.first #3

▶︎생성자

a = FourCal()
a.add() # 오류

• FourCal 클래스의 인스턴스 a에 setdata 메서드를 수행하지 않고 add 메서드를 먼저 수행하면 오류가 발생한다.
• setdata 메서드를 수행해야 객체 a의 객체변수 first와 second가 생성되기 때문.
• 이렇게 객체에 first, second와 같은 초깃값을 설정해야 할 필요가 있을 때는 setdata와 같은 메서드를 호출하여 초깃값을 설정하기보다 생성자를 구현하는 것이 안전한 방법이다.
  

📍생성자 _init_

• 생성자(constructor): 객체가 생성될 때 자동으로 호출되는 메서드.
• 파이썬 메서드명으로 __init__를 사용하면 이 메서드는 생성자가 된다.
• 객체 생성 시 생성자의 매개변수를 전달해야 한다.

  class FourCal:
    def __init__(self, first, second):
        self.first = first
        self.second = second
    def add(self):
        result = self.first + self.second
  

a = FourCal(4, 2) # 객체 생성 시 매개변수 전달 a.first # 4 a.second # 2

<br/>

# ▶︎클래스의 상속
- **상속**: 어떤 클래스를 만들 때 다른 클래스의 기능을 물려받을 수 있게 만드는 것.
- 상속은 기존 클래스를 변경하지 않고 기능을 추가하거나 기존 기능을 변경하려고 할 때 사용한다. 기존 클래스가 라이브러리 형태로 제공되거나 수정이 허용되지 않는 상황이라면 상속을 사용.
- `class 클래스_이름(상속할_클래스_이름)
`: 클래스 이름 뒤 괄호 안에 상속할 클래스 이름을 넣어주면 된다.
```python
class MoreFourCal(FourCal):
    def pow(self):
        result = self.first ** self.second
        return result

a = MoreFourCal(4, 2)
a.add() # 6 -> 상속받은 class의 메서드를 그대로 쓸 수 있다.
a.mul() # 8
a.sub() # 2
a.div() # 2
a.pow() # 16

• MoreFourCal 클래스는 FourCal 클래스를 상속했으므로 FourCal 클래스의 모든 기능을 사용할 수 있다.
  

▶︎메서드 오버라이딩

• 메서드 오버라이딩(method overriding): 부모 클래스(상속한 클래스)에 있는 메서드를 동일한 이름으로 다시 만드는 것.
• 메서드를 오버라이딩하면 부모 클래스의 메서드 대신 오버라이딩한 메서드가 호출된다.

  class SafeFourCal(FourCal):
    def div(self):
        if self.second == 0:  # 나누는 값이 0인 경우 0을 리턴하도록 수정
           return 0
        else:
            return self.first / self.second
  

a = SafeFourCal(4, 0) a.div() # 0 # FourCal 클래스와 달리 ZeroDivisionError가 발생하지 않는다.

<br/>

# ▶︎클래스 변수
- 클래스 변수: 클래스 안에서 선언한 변수.
- 클래스변수는 `클래스_이름.클래스변수`로 사용할 수 있다.
```python
class Family:
    lastname = "김"

Family.lastname # 김 # 클래스 변수 사용

a = Family()
b = Family()
a.lastname # 김
b.lastname #김

• 클래스로 만든 객체를 이용해도 클래스변수를 사용할 수 있다.

  class Family:
    lastname = "김"
  

Family 클래스로 만든 객체를 이용해 클래스변수 사용

a = Family() b = Family() a.lastname # 김 b.lastname #김

- 클래스변수는 클래스로 만든 모든 객체에 공유된다. 변경되도 모든 객체에 변경 사항이 적용된다.
```python
class Family:
    lastname = "김"

a = Family()
b = Family()

Family.lastname = "박"
a.lastname # 박
b.lastname # 박

+) 객체변수

• 객체변수는 다른 객체들의 영향을 받지 않고 독립적으로 그 값을 유지한다.

  class Family:
    lastname = "김"
  

a = Family() b = Family()

Family.lastname = "박" a.lastname = "최"

a.lastname # 최 b.lastname # 박 ```

명령어 [인수1 인수2 ...]

• 대부분의 명령 프롬프트에서 사용하는 명령어는 다음과 같이 인수를 전달하여 프로그램을 실행하는 방식을 따른다.

▶︎sys 모듈 사용하기

• 파이썬에서는 sys 모듈을 사용하여 프로그램에 인수를 전달할 수 있다.

  # sys1.py
  

import sys

args = sys.argv[1:] for i in args: print(i)

- sys 모듈의 `argv`: 프로그램 실행 시 전달된 인수를 의미.
- `sys1.py aaa bbb ccc`를 프롬프트에 실행 시
  - `argv[0]`: 파일 이름 sys1.py
  - `argv[1]`부터는 뒤에 따라오는 인수가 차례대로 argv의 요소가 된다.

▶︎파일 생성

• 파일_객체 = open(파일_이름, 파일_열기_모드): 프로그램을 실행한 디렉터리에 새로운 파일이 생성.
• 파일 열기 모드
  • r: 읽기 모드 (파일을 읽기만 할 때)
  • w: 쓰기 모드 (파일에 내용을 쓸 때)
    • 해당 파일이 이미 존재할 경우: 원래 있던 내용이 모두 사라지고 새로운 파일이 생성.
    • 해당 파일이 존재하지 않으면: 새로운 파일이 생성.
  • a: 추가 모드 (파일의 마지막에 새로운 내용을 추가할 때)
• 특정 디렉터리에 생성하고 싶다면 파일이름에 디렉터리까지 설정.
• f.close(): 열려 있는 파일 객체를 닫는다.
  • 프로그램을 종료할 때 파이썬 프로그램이 열려 있는 파일의 객체를 자동으로 닫아 주기 때문에 생략 가능.
  • 하지만 close()를 사용해서 열려 있는 파일을 직접 닫아 주는 것이 좋다. 쓰기모드로 열었던 파일을 닫지 않고 다시 사용하려고 하면 오류가 발생하기 때문.

    f = open("C:/doit/새파일.txt", 'w')
    f.close()

    
    

▶︎파일을 쓰기 모드로 열어 내용 쓰기

f = open("C:/doit/새파일.txt", 'w')
for i in range(1, 11):
    data = "%d번째 줄입니다.\n" % i
    f.write(data)
f.close()

• f.write(data): 모니터 화면 대신 파일에 데이터를 적는 방법.
• print(data): 모니터 화면에 데이터를 출력하는 방법.
  

▶︎파일을 읽는 방법

readline 함수

• readline(): 파일의 첫 번째 줄을 읽음.

  f = open("C:/doit/새파일.txt", 'r') # ‘새파일.txt’ 파일을 읽기 모드로 연 후
  line = f.readline() # readline()을 사용해서 파일의 첫 번째 줄을 읽어 
  print(line) # 출력
  f.close()

• 만약 모든 줄을 읽어 화면에 출력하고 싶다면 반복문 이용.

  f = open("C:/doit/새파일.txt", 'r')
  while True:
    line = f.readline()
    if not line: break # 더 이상 읽을 줄이 없으면 break
    print(line)
  f.close()

• readline()은 더 이상 읽을 줄이 없을 경우, 빈 문자열('')을 반환한다.
  

readlines 함수

• readlines(): 파일의 모든 줄을 읽어서 각각의 줄을 요소로 가지는 리스트.

  f = open("C:/doit/새파일.txt", 'r')
  lines = f.readlines() # ["1번째 줄입니다.\n", "2번째 줄입니다.\n", ..., "10번째 줄입니다.\n"]
  for line in lines:
    print(line)
  f.close()

• strip(): 파일을 읽을 때 줄 끝의 줄 바꿈(\n) 문자를 제거하고 사용해야 할 경우.

  f = open("C:/doit/새파일.txt", 'r')
  lines = f.readlines()
  for line in lines:
    line = line.strip()  # 줄 끝의 줄 바꿈 문자를 제거한다.
    print(line)
  f.close()

• readline()은 더 이상 읽을 줄이 없을 경우, 빈 문자열('')을 반환한다.
  

read 함수

• read(): 파일의 내용 전체를 문자열로 반환.

  f = open("C:/doit/새파일.txt", 'r')
  data = f.read()
  print(data)
  f.close()

  
  

파일 객체를 for 문과 함께 사용

• 파일 객체는 기본적으로 for 문과 함께 사용하여 파일을 줄 단위로 읽을 수 있다.

  f = open("C:/doit/새파일.txt", 'r')
  for line in f:
    print(line)
  f.close()

  
  

▶︎파일에 새로운 내용 추가

• 원래 있던 값을 유지하면서 단지 새로운 값만 추가해야 할 경우도 있다. 이런 경우에는 파일을 추가 모드('a')로 열면 된다.

  f = open("C:/doit/새파일.txt",'a')
  for i in range(11, 20):
    data = "%d번째 줄입니다.\n" % i
    f.write(data)
  f.close()

  
  

▶︎with 문과 함께 사용

• with: 파일을 열고 닫는 것을 자동으로 처리. with 블록(with 문에 속해 있는 문장)을 벗어나는 순간, 열린 파일 객체가 자동으로 닫힌다.
• with 문 내에서 선언된 변수는 with 블록을 벗어난 후에도 접근할 수 있다.

  with open("foo.txt", "w") as f:
    f.write("Life is too short, you need python")

  
  

▶︎스코프(Scope) 규칙

함수 스코프

• 함수 안에서 선언된 변수는 함수 밖에서 접근할 수 없다.

  def my_function():
    func_var = "함수 안의 변수"
  

my_function()

print(func_var) # 오류! 함수 밖에서는 접근 불가

<br/>

## 블록 스코프
- if, for, while, with 등의 블록 안에서 선언된 변수는 블록 밖에서도 접근할 수 있다.
```python
# if 문 블록의 예
if True:
    if_var = "if 블록 안의 변수"

print(if_var)  # 정상 작동! "if 블록 안의 변수" 출력

# for 문 블록의 예  
for i in range(3):
    loop_var = "반복문 안의 변수"

print(i)         # 정상 작동! 2 출력
print(loop_var)  # 정상 작동! "반복문 안의 변수" 출력

# with 문에서 변수 사용 예제
with open("test.txt", "w") as f:
    content = "Hello, Python!"  # with 블록 내에서 변수 선언
    f.write(content)

print(content) # with 블록을 벗어난 후에도 변수에 접근 가능 # "Hello, Python!" 출력

▶︎파일 처리 시 주의사항

• 한글이 포함된 파일을 다룰 때는 인코딩을 명시하는 것이 좋다.
• 인코딩을 명시하지 않으면 운영체제마다 다른 기본 인코딩을 사용하여 한글이 깨질 수 있다.

  # 한글 파일 쓰기
  with open("한글파일.txt", "w", encoding="utf-8") as f:
    f.write("안녕하세요, 파이썬!")
  

한글 파일 읽기

with open("한글파일.txt", "r", encoding="utf-8") as f: content = f.read() print(content)

```

• 인코딩(Encoding): 문자를 컴퓨터가 이해할 수 있는 숫자로 변환하는 방식.
  • 예) '가'라는 한글 문자를 어떤 숫자로 저장할지 정하는 규칙.
  • UTF-8: 전 세계 모든 문자(한글, 영어, 중국어, 일본어, 특수문자 등)를 표현할 수 있는 가장 널리 사용되는 인코딩 방식.

▶︎input()

• 사용자가 입력한 값을 어떤 변수에 대입하고 싶을 때 사용.
• input은 사용자가 키보드로 입력한 모든 것을 문자열로 저장한다.
• 사용자에게 입력받을 때 ‘숫자를 입력하세요’나 ‘이름을 입력하세요’라는 안내 문구 또는 질문을 보여 주고 싶을 때, input()의 괄호 안에 안내 문구를 입력하여 프롬프트를 띄워 주면 된다.

  a = input() # 사용자가 입력: Life is too short, you need python
  a # Life is too short, you need python
  

input("안내_문구") # 안내문구가 프롬프트로 나타남.

<br/>

# ▶︎자료형 변환
## 정수로 변환 int() 
- int() 함수는 문자열이나 실수를 정수로 변환하는 파이썬 내장 함수이다.
```python
age = input("나이를 입력하세요: ")
# 나이를 입력하세요: 25
age = int(age)  # 문자열을 정수로 변환
print(age + 1) # 26

실수로 변환 float()

• float() 함수는 문자열이나 정수를 실수로 변환하는 파이썬 내장 함수이다.

  height = input("키를 입력하세요(cm): ")
  # 키를 입력하세요(cm): 175.5
  height = float(height)  # 문자열을 실수로 변환
  print(height / 100)  # 미터 단위로 변환 # 1.755

  
  

한 번에 변환

• float() 함수는 문자열이나 정수를 실수로 변환하는 파이썬 내장 함수이다.

  age = int(input("나이를 입력하세요: "))
  # 나이를 입력하세요: 25
  print(type(age)) # <class 'int'>

  
  

▶︎print()

큰따옴표로 둘러싸인 문자열은 + 연산과 동일

• float() 함수는 문자열이나 정수를 실수로 변환하는 파이썬 내장 함수이다.

  print("life" "is" "too short")  # lifeistoo short
  print("life"+"is"+"too short")  # lifeistoo short

  
  

문자열 띄어쓰기는 쉼표로

• 쉼표(,)를 사용하면 문자열을 띄어 쓸 수 있다.

  print("life", "is", "too short") # life is too short

  
  

sep 매개변수로 구분자 설정

• print 함수의 sep 매개변수를 사용하면 출력할 값들 사이의 구분자를 지정할 수 있다.

  print("2025", "08", "17", sep="-") # 2025-08-17
  print("점프", "투", "파이썬", sep=" TO ") # 점프 TO 투 TO 파이썬

  
  

한 줄에 결괏값 출력

• 기본적으로 print()는 한 줄씩 출력한다. 기본 end값이 \n이다.
• 한 줄에 결괏값을 계속 이어서 출력하려면 매개변수 end를 사용해 끝 문자를 지정해야 한다.

  for i in range(10):
    print(i, end=' ')
  

0 1 2 3 4 5 6 7 8 9 >>>

```

▶︎함수란?

• 입력값을 가지고 어떤 일을 수행한 후 그 결과물을 내어 놓는 것.
• 반복되는 부분이 있을 경우, ‘반복적으로 사용되는 가치 있는 부분’을 한 뭉치로 묶어 ‘어떤 입력값을 주었을 때 어떤 결괏값을 반환해 준다’라는 식의 함수로 작성.
• 작성한 프로그램을 기능 단위의 함수로 분리해 놓으면 프로그램 흐름을 일목요연하게 볼 수 있다.
  

▶︎파이썬 함수의 구조

def 함수_이름(매개변수):
    수행할_문장1
    수행할_문장2
    ...

• def: 함수를 만들 때 사용하는 예약어.

매개변수와 인수

• 매개변수: 함수에 입력으로 전달된 값을 받는 변수.
• 인수: 함수를 호출할 때 전달하는 입력값.

  def add(a, b):  # a, b는 매개변수
    return a+b
  

print(add(3, 4)) # 3, 4는 인수

<br/>

## 매개변수를 지정하여 호출하기
- 함수를 호출할 때 매개변수를 지정할 수도 있다.
- 매개변수를 지정하면 순서에 상관없이 사용할 수 있다는 장점이 있다.
```python
def add(a, b):  
    return a+b

result = sub(b=5, a=3)  # b에 5, a에 3을 전달
print(result) # -2

입력값이 몇 개일지 모를 때

가변 매개변수

def 함수_이름(*매개변수):
    수행할_문장
    ...

• *매개변수 사용.
• 변수 이름 앞에 *을 붙이면 입력값을 전부 모아 튜플로 만들어준다.
• 사용 예)

  def add_many(*args): 
      result = 0 
      for i in args: 
          result = result + i   # *args에 입력받은 모든 값을 더한다.
      return result 

  • args는 인수를 뜻하는 영어 단어 arguments의 약자이며 관례적으로 자주 사용한다.

📍키워드 매개변수, kwargs

def print_kwargs(**kwargs):
    수행할_문장
    ...

• 키워드 매개변수는 함수 호출 시 키워드=값 형태로 전달하는 매개변수를 받을 때 사용한다.

• 키워드 매개변수를 사용할 때는 매개변수 앞에 별 2개(**)를 붙인다.

• 사용 예)

  def print_kwargs(**kwargs):
      print(kwargs)
  
  print_kwargs(a=1) # {'a': print_kwargs(name='foo', age=3) # {'age': 3, 'name': 'foo'}

  순서

• 일반 매개변수, 가변 매개변수(args), 키워드 매개변수(*kwargs)를 모두 함께 사용할 수도 있다.

• 이때 순서는 반드시 다음과 일반 매개변수, 가변 매개변수(args), 키워드 매개변수(*kwargs)야 한다.

  def mixed_function(name, *args, **kwargs):
    print(f"이름: {name}")
    print(f"추가 인수들: {args}")
    print(f"키워드 인수들: {kwargs}")
  

mixed_function('홍길동', 1, 2, 3, age=25, city='서울')

<br/>

# ▶︎함수의 반환값은 언제나 하나
```python
def add_and_mul(a,b): 
    return a+b, a*b

result = add_and_mul(3,4) # (7, 12) 

• 함수의 반환값은 언제나 1개.
• 따라서 add_and_mul 함수의 반환값 a+b와 ab는 튜플값 하나인 (a+b, ab)로 리턴된다.
  

def add_and_mul(a,b): 
    return a+b, a*b

result1, result2 = add_and_mul(3, 4)
result1 # 7
result2 # 12

• 만약 이 하나의 튜플 값을 2개의 값으로 분리하여 받고 싶다면 함수를 위와 같이 호출.
  

def add_and_mul(a,b): 
    return a+b 
    return a*b 

result = add_and_mul(2, 3) # 5

• 함수는 return 문을 만나는 순간, 반환값을 반환한 다음 함수를 빠져나가게 된다.
• 특별한 상황일 때 함수를 빠져나가고 싶다면 return을 단독으로 써서 함수를 즉시 빠져나갈 수 있다.
  

▶︎매개변수에 초깃값 미리 설정하기

• 매개변수에 초깃값을 미리 설정하기.
• 초깃값이 없는 매개변수는 초깃값이 있는 매개변수 뒤에 사용할 수 없다.

  def say_myself(name, age, man=True): 
    print("나의 이름은 %s 입니다." % name) 
    print("나이는 %d살입니다." % age) 
    if man: 
        print("남자입니다.")
    else: 
        print("여자입니다.")
  

say_myself 함수는 2가지 방법으로 사용할 수 있다.

say_myself("박응용", 27) say_myself("박응용", 27, True)

<br/>

# ▶︎함수 안에서 선언한 변수의 효력 범위
- 함수 안에서 사용하는 매개변수는 함수 안에서만 사용하는 ‘함수만의 변수’이다. 함수 밖에서는 사용되지 않는다.
```python
a = 1
def vartest(a):
    a = a + 1

vartest(a) # 2
print(a) # 1

함수 안에서 함수 밖의 변수를 변경하는 방법

return 사용하기

a = 1 
def vartest(a): 
    a = a +1 
    return a

a = vartest(a) 
print(a)

global 명령어 사용하기

a = 1 
def vartest(): 
    global a 
    a = a+1

vartest() 
print(a)

• vartest 함수 안의 global a 문장은 함수 안에서 함수 밖의 a 변수를 직접 사용하겠다는 뜻이다. (바깥쪽에 있는 a를 가져온다)
• 하지만 global 명령어는 사용하지 않는 것이 좋다. 함수는 독립적으로 존재하는 것이 좋기 때문. 외부 변수에 종속적인 함수는 그다지 좋은 함수가 아니다.
  

리스트나 딕셔너리를 함수에 전달할 때는 원본이 변경될 수 있다

def change_list(my_list):
    my_list.append(4)  # 리스트에 값을 추가

a = [1, 2, 3]
change_list(a)
print(a) # [1, 2, 3, 4]

• 함수에서 리스트에 값을 추가했을 때 원래 리스트 a도 함께 변경되었다. 이는 리스트가 '변경 가능한(mutable)' 자료형이기 때문이다.
• 딕셔너리도 마찬가지로 함수 안에서 값을 변경하면 원래 딕셔너리도 함께 변경된다.
  

▶︎lambda 예약어

• lambda: 함수를 생성할 때 사용하는 예약어로 def와 동일한 역할을 한다
• 보통 함수를 한 줄로 간결하게 만들 때 사용.
• def를 사용해야 할 정도로 복잡하지 않거나 def를 사용할 수 없는 곳에 주로 쓰인다.
• 사용법: 함수_이름 = lambda 매개변수1, 매개변수2, ... : 매개변수를_이용한_표현식
• lambda로 만든 함수는 return 명령어가 없어도 표현식의 결괏값을 반환한다.

  add = lambda a, b: a+b
  result = add(3, 4)
  print(result) # 7

  
  

▶︎함수의 Docstring

• 독스트링: 함수에 대한 설명을 문서화하는 방법.

• 함수의 첫 번째 줄에 삼중 따옴표로 둘러싼 문자열을 작성.

  def add(a, b):
    """
    두 숫자를 더하는 함수
  
    Parameters:
    a (int, float): 첫 번째 숫자
    b (int, float): 두 번째 숫자
  
    Returns:
    int, float: 두 숫자의 합
    """
    return a + b
  

독스트링 확인하기

print(add.doc) ```

▶︎조건문

🌟if문

• 조건을 판단하여 해당 조건에 맞는 상황을 수행하는 데 쓴다.

  money = True
  if money:
    print("택시를 타고 가라")
  else:
    print("걸어 가라")
  

택시를 타고 가라

### if 문의 기본 구조
```python
if 조건문:
    수행할_문장1
    수행할_문장2
    ...
else:
    수행할_문장A
    수행할_문장B
    ...

• 조건문을 테스트해서 참이면 if 문 바로 다음 문장(if 블록)들을 수행하고 조건문이 거짓이면 else 문 다음 문장(else 블록)들을 수행한다.
• if 조건문 뒤에는 반드시 콜론(:)이 붙는다.
• 수행할 문장이 한 줄일 때 콜론(:) 뒤에 바로 적기 가능. if 조건문: 수행할_문장1

비교 연산자

• x < y
• x > y
• x == y
• x != y
• x >= y
• x <= y

and, or, not 연산자

• x or y
• x and y
• not x

📍in, not in

• x in (리스트, 튜플, 문자열)
• x not in (리스트, 튜플, 문자열)

  1 in [1, 2, 3] # True
  1 not in [1, 2, 3] # False
  'a' in ('a', 'b', 'c') # True
  'j' not in 'python' # True

📍pass

• 조건문에서 아무 일도 하지 않게 설정.

  pocket = ['paper', 'money', 'cellphone']
  

if 'money' in pocket: pass else: print("카드를 꺼내라")

### 📍elif
- 다중 조건 판단.
- elif는 이전 조건문이 거짓일 때 수행.
- elif는 개수에 제한 없이 사용할 수 있다.
```python
pocket = ['paper', 'cellphone']
card = True

# if문
if 'money' in pocket:
    print("택시를 타고가라")
else:
    if card:
        print("택시를 타고가라")
    else:
        print("걸어가라")

# elif 사용
if 'money' in pocket:
    print("택시를 타고가라")
elif card: 
    print("택시를 타고가라")
else:
    print("걸어가라")

조건부 표현식

• 조건에 따라 변수에 서로 다른 값을 대입하고 싶을 때.
• 조건부 표현식을 사용하면 한 줄로 표현할 수 있다.
• 기본 형태: 변수 = 참일_때_값 if 조건 else 거짓일_때_값

  score = 85
  if score >= 60:
    result = "합격"
  else:
    result = "불합격"
  

조건부 표현식 사용 시

result = "합격" if score >= 60 else "불합격"

- 너무 복잡한 조건이나 긴 표현식에는 가독성이 떨어질 수 있다.
<br/>

# ▶︎반복문
## 🌟while문
- 조건문이 참인 동안 while 문에 속한 문장들이 반복해서 수행.

### 기본 구조
```python
while 조건문:
    수행할_문장1
    수행할_문장2
    수행할_문장3
    ...

• 여러 가지 선택지 중 하나를 선택해서 입력받는 예제

  prompt = """
  1. Add
  2. Del
  3. List
  4. Quit
  
  Enter number: """
  
  number = 0
  while number != 4:
      print(prompt)
      number = int(input()) # input 함수는 사용자에게 입력값을 받음

  • 사용자가 값 4를 입력하지 않으면 계속해서 prompt를 출력한다.

break

• while 문 강제로 빠져나가기.

  coffee = 10
  

while True: money = int(input("돈을 넣어 주세요: ")) if money == 300: print("커피를 줍니다.") coffee = coffee -1 elif money > 300: print("거스름돈 %d를 주고 커피를 줍니다." % (money -300)) coffee = coffee -1 else: print("돈을 다시 돌려주고 커피를 주지 않습니다.") print("남은 커피의 양은 %d개 입니다." % coffee) if coffee == 0: print("커피가 다 떨어졌습니다. 판매를 중지 합니다.") break

### 📍continue
- while 문을 빠져나가지 않고 while 문의 맨 처음(조건문)으로 다시 돌아가기.
- 1부터 10까지의 숫자 중 홀수만 출력하는 예
  ```python
  a = 0
  while a < 10:
      a = a + 1
      if a % 2 == 0: continue
      print(a)

• a가 짝수이면 continue 문을 수행한다. 이 continue 문은 while 문의 맨 처음인 조건문(a < 10)으로 돌아가게 하는 명령어이기에 a가 짝수이면 print(a) 문장은 수행되지 않는다.

무한 루프

• 무한히 반복한다.

  while True: 
    수행할_문장1 
    수행할_문장2
    ...

📍while-else 문

• while 문이 정상적으로 종료되었을 때(break로 빠져나가지 않았을 때) else 절이 실행된다.

  count = 0
  while count < 3:
    print(f"카운트: {count}")
    count += 1
  else:
    print("while 문이 정상 종료되었습니다.")
  

카운트: 0

카운트: 1

카운트: 2

while 문이 정상 종료되었습니다.

- break 문으로 while 문을 빠져나가면 else 절은 실행되지 않는다.
```python
count = 0
while count < 5:
    if count == 2:
        break
    print(f"카운트: {count}")
    count += 1
else:
    print("while 문이 정상 종료되었습니다.")

# 카운트: 0
# 카운트: 1

중첩된 while 문

• while 문 안에 또 다른 while 문.
• 중첩된 while 문에서 break나 continue를 사용할 때는 가장 가까운 while 문에만 영향을 준다.

  i = 1
  while i <= 3:
    j = 1
    while j <= 3:
        print(f"i={i}, j={j}")
        j += 1
    i += 1

  
  

🌟for문

기본 구조

for 변수 in 리스트(또는 튜플, 문자열):
    수행할_문장1
    수행할_문장2
    ...

• 첫 번째 요소부터 마지막 요소까지 차례로 변수에 대입되어 ‘수행할_문장1’, ‘수행할_문장2’ 등이 수행된다.

전형적인 for 문

test_list = ['one', 'two', 'three'] 
for i in test_list: 
    print(i)

다양한 for 문의 사용

a = [(1,2), (3,4), (5,6)]
for (first, last) in a:
    print(first + last)

# 3
# 7
# 11

• a 리스트의 요솟값이 튜플이기 때문에 각각의 요소가 자동으로 (first, last) 변수에 대입된다.

for 문의 응용

marks = [90, 25, 67, 45, 80]   # 학생들의 시험 점수 리스트

number = 0   # 학생에게 붙여 줄 번호
for mark in marks:   # 90, 25, 67, 45, 80을 순서대로 mark에 대입
    number = number +1 
    if mark >= 60: 
        print("%d번 학생은 합격입니다." % number)
    else: 
        print("%d번 학생은 불합격입니다." % number)

📍for 문과 continue 문

• for 문 안의 문장을 수행하는 도중 continue 문을 만나면 for 문의 처음으로 돌아가게 된다.

  marks = [90, 25, 67, 45, 80]
  

number = 0 for mark in marks: number = number +1 if mark < 60: continue print("%d번 학생 축하합니다. 합격입니다. " % number)

- 60점 이상인 사람에게는 축하 메시지를 보내고 나머지 사람에게는 아무런 메시지도 전하지 않는다.

### 📍for 문과 range 함수
- range 함수
  ```python
  a = range(10)
  a # range(0, 10)

  b = range(1, 11)
  b # range(1, 11)

• range(10)은 0부터 10 미만의 숫자를 포함하는 range 객체를 만들어 준다.

• range(시작_숫자, 끝_숫자): 시작 숫자와 끝 숫자를 지정. 이때 끝 숫자는 포함되지 않는다.

  • for와 range 함수를 사용

    add = 0 
    for i in range(1, 11): 
    add = add + i 
    

  print(add) # 55 ```

• range(1, 11)은 숫자 1부터 10까지(1 이상 11 미만)의 숫자를 데이터로 가지는 객체로 i 변수에 숫자가 1부터 10까지 하나씩 차례로 대입되면서 add = add + i 문장을 반복적으로 수행하고 add는 최종적으로 55가 된다.

📍list comprehension

• 문법

  [표현식 for 항목 in 반복_가능_객체 if 조건문]
  
  # for 문을 2개 이상 사용하는 것도 가능
  [표현식 for 항목1 in 반복_가능_객체1 if 조건문1
        for 항목2 in 반복_가능_객체2 if 조건문2
        ...
        for 항목n in 반복_가능_객체n if 조건문n]

• a 리스트의 각 항목에 3을 곱한 결과를 result 리스트에 담기.

  a = [1,2,3,4]
  result = []
  
  for num in a:
      result.append(num*3)
  
  print(result) # [3, 6, 9, 12]
  
  

리스트 컴프리헨션을 사용

a = [1,2,3,4] result = [num * 3 for num in a] print(result) # [3, 6, 9, 12]

- 짝수에만 3을 곱하여 담기. -> 리스트 컴프리헨션 안에 ‘if 조건문’을 사용.
  ```python
  a = [1,2,3,4]
  result = [num * 3 for num in a if num % 2 == 0]
  print(result) # [6, 12]

for 문과 break 문

• for 문을 강제로 빠져나가고 싶을 때 사용.

  for i in range(10):
    if i == 5: break
    print(i)

for-else 문

• for 문이 정상적으로 종료되었을 때(break로 빠져나가지 않았을 때) else 절이 실행된다.

  for i in range(5):
      print(i)
  else:
      print("for 문이 정상 종료되었습니다.")
  
  # 0
  # 1
  # 2
  # 3
  # 4
  # for 문이 정상 종료되었습니다.

• break 문으로 for 문을 빠져나가면 else 절은 실행되지 않는다.

  for i in range(5):
      if i == 3:
          break
      print(i)
  else:
      print("for 문이 정상 종료되었습니다.")
  
  # 0
  # 1
  # 2

📍enumerate 함수 활용

• 리스트의 순서(인덱스)와 값을 함께 구하고 싶을 때는 enumerate 함수를 사용하면 편리하다.
• enumerate(리스트): 0부터 시작하는 인덱스 번호를 자동으로 생성해준다.
• enumerate(리스트, 시작번호): 시작 번호를 설정.

  fruits = ['apple', 'banana', 'orange']
  for i, fruit in enumerate(fruits, 1):  # 1부터 시작
    print(f"{i}: {fruit}")
  

1: apple

2: banana

3: orange

### 📍zip 함수로 여러 리스트 함께 순회
- 두 개 이상의 리스트를 동시에 순회하고 싶을 때는 zip 함수를 사용.
```python
names = ['홍길동', '김철수', '이영희']
korean = [85, 92, 78]
english = [90, 88, 95]

for name, kor, eng in zip(names, korean, english):
    print(f"{name}: 국어 {kor}점, 영어 {eng}점")

# 홍길동: 국어 85점, 영어 90점
# 김철수: 국어 92점, 영어 88점
# 이영희: 국어 78점, 영어 95점

▶︎변수 생성

• 변수_이름 = 변수에_저장할_값: 변수를 만들 때는 =(assignment) 기호를 사용한다.
• 다른 프로그래밍 언어인 C나 JAVA에서는 변수를 만들 때 자료형의 타입을 직접 지정해야 하지만, 파이썬은 변수에 저장된 값을 스스로 판단하여 자료형의 타입을 지정한다.

  a = 1
  b = "python"
  c = [1, 2, 3]

  
  

▶︎변수 명명 규칙

변수명 규칙

1. 영문자, 숫자, 언더스코어(_)만 사용할 수 있다.
2. 숫자로 시작할 수 없다.
3. 예약어는 사용할 수 없다.
4. 대소문자를 구분한다.

   # 올바른 변수명 예시
   name = "홍길동"
   age = 25
   user_name = "gildong"
   userName = "gildong"  # 카멜 케이스
   _private = "비공개"
   count1 = 10
   

잘못된 변수명 예시

1name = "홍길동" # 숫자로 시작 (오류)

user-name = "홍길동" # 하이픈 사용 (오류)

if = 10 # 예약어 사용 (오류)

<br/>

## 파이썬 예약어
- 파이썬에서는 특별한 의미로 사용되는 예약어들이 있으며, 이를 변수명으로 사용할 수 없다.
```python
False, None, True, and, as, assert, break, class, continue, def, 
del, elif, else, except, finally, for, from, global, if, import, 
in, is, lambda, nonlocal, not, or, pass, raise, return, try, 
while, with, yield

변수명 권장 사항

• 의미가 명확한 이름을 사용한다.
• snake_case (단어 사이에 언더스코어)를 권장한다.
• 너무 짧거나 긴 이름은 피한다.

  # 좋은 예
  student_name = "김철수"
  total_score = 95
  user_age = 20
  

피해야 할 예

a = "김철수" # 의미 불명확 studentNameFromKorea = "김철수" # 너무 긴 이름

<br/>

# ▶︎변수란?
- 파이썬에서 사용하는 변수는 객체를 가리키는 것이라고도 말할 수 있다.
```python
a = [1, 2, 3]
id(a) # 4303029896

• [1, 2, 3] 값을 가지는 리스트 데이터(객체)가 자동으로 메모리에 생성되고 변수 a는 [1, 2, 3] 리스트가 저장된 메모리의 주소를 가리키게 된다.
  • 메모리: 컴퓨터가 프로그램에서 사용하는 데이터를 기억하는 공간.
• a 변수가 가리키는 메모리의 주소는 id(a)로 확인.
  • id: 변수가 가리키고 있는 객체의 주소 값을 반환하는 파이썬의 내장 함수.
    

▶︎복사

같은 객체 참조

a = [1, 2, 3]
b = a

id(a) # 4303029896
id(b) # 4303029896

# a와 b가 가리키는 객체가 같을까?
a is b  # True

a[1] = 4
a # [1, 4, 3]
b # [1, 4, 3]

• b 변수에 a 변수를 대입하면 b는 a와 완전히 동일하다.
• [1, 2, 3]이라는 리스트 객체를 참조하는 변수가 a 변수 1개에서 b 변수가 추가되어 2개로 늘어났다.
• 동일한 객체를 참조.
  • is: 동일한 객체를 가리키고 있는지에 대해서 판단하는 파이썬 명령어.
  • 리스트의 두 번째 요소를 값 4로 바꾸었더니 a만 바뀌는 것이 아니라 b도 똑같이 바뀐다.
    

다른 객체 참조

• b 변수를 생성할 때 a 변수의 값을 가져오면서 a와는 다른 주소를 가리키도록 만드는 방법.

  1. [:] 슬라이싱

• 리스트 전체를 가리키는 [:]을 사용해서 복사.

  a = [1, 2, 3]
  b = a[:]
  

a[1] = 4 a # [1, 4, 3] b # [1, 2, 3]

- a 리스트 값을 바꾸더라도 b 리스트에는 아무런 영향이 없다.

### 2. copy 모듈
```python
from copy import copy

a = [1, 2, 3]
b = copy(a)

b is a # False

• b = copy(a)는 b = a[:]과 동일하다.
• b = a.copy(): 리스트 자료형의 자체 함수인 copy 함수를 사용해도 copy 모듈을 사용하는 것과 동일한 결과를 얻을 수 있다.
  

▶︎변수를 만드는 여러 가지 방법

• 튜플로 a, b에 값을 대입.

  • 튜플은 괄호를 생략해도 된다.

    a, b = ('python', 'life')
    (a, b) = 'python', 'life'

• 리스트로 변수를 만들 수도 있다.

  [a, b] = ['python', 'life']

• 여러 개의 변수에 같은 값을 대입.

  a = b = 'python'

  • 위 방법을 사용하여 두 변수의 값을 매우 간단하게 바꿀 수 있다.

    a = 3
    b = 5
    
    a, b = b, a
    
    a # 5
    b # 3

▶︎불

• 불(bool) 자료형이란 참(True)과 거짓(False)을 나타내는 자료형.
• True나 False는 파이썬의 예약어로, 첫 문자를 항상 대문자로 작성해야 한다.
  

🌟불 자료형의 사용

a = True
b = False

type(a) # <class 'bool'>
type(b) # <class 'bool'>

• 불 자료형은 조건문의 리턴값으로도 사용된다.

  1 == 1 # True
  2 > 1 # True
  2 < 1 # False

  
  

🌟자료형의 참과 거짓

🌟불 자료형의 사용

a = [1, 2, 3, 4]
while a:
    print(a.pop())

# 4
# 3
# 2
# 1

• 더 이상 끄집어 낼 것이 없으면 a가 빈 리스트([])가 되어 거짓이 된다. 따라서 while 문에서 조건문이 거짓이 되므로 while 문을 빠져나가게 된다.
  

🌟불 연산

bool('python') # True
bool('') # False

bool([1, 2, 3]) # True
bool([]) # False

bool(0) # False
bool(3) # True

🌟논리 연산자

📍and 연산자

• 양쪽 조건이 모두 참일 때만 True를 반환.

  True and True # True
  True and False # False
  False and True # False
  False and False # False

📍or 연산자

• 양쪽 조건 중 하나라도 참이면 True를 반환.

  True or True # True
  True or False # True
  False or True # True
  False or False # False

📍not 연산자

• 조건의 참/거짓을 뒤바꾼다.

  not True # False
  not False # True
  not 1 # False
  not 0 # True

▶︎집합

• 집합(set)은 수학의 집합 개념과 동일한 자료형.
• 중복을 허용하지 않고 순서가 없는 데이터들의 모임으로, 교집합, 합집합, 차집합 등의 집합 연산을 쉽게 처리할 수 있다.
  

🌟집합 자료형 생성

• set 키워드를 사용.

  • set()의 괄호 안에 리스트를 입력하여 만들거나 다음과 같이 문자열을 입력하여 만들 수도 있다.

    s1 = set([1, 2, 3])
    s1 # {1, 2, 3}
    

  s2 = set("Hello") s2 # {'e', 'H', 'l', 'o'} ```

• 중괄호({})를 사용해서 집합 자료형을 직접 만들 수도 있다.

  s3 = {1, 2, 3}
  s3 # {1, 2, 3}
  

s4 = {'a', 'b', 'c'} s4 # {'a', 'c', 'b'}

- 비어 있는 집합 자료형은 `s = set()`로 만들 수 있다. 
  - `s = {}`로 만들면 딕셔너리가 되므로 주의.

<br/>

## 🌟집합 자료형 특징
1. 중복을 허용하지 않는다.
2. 순서가 없다(Unordered).

- 집합은 중복을 허용하지 않는 특징 때문에 데이터의 중복을 제거하기 위한 필터로 종종 사용된다.
- 리스트나 튜플은 순서가 있기(ordered) 때문에 인덱싱을 통해 요솟값을 얻을 수있지만, 집합 자료형은 순서가 없기(unordered) 때문에 인덱싱을 통해 요솟값을 얻을 수 없다.
- 만약 집합 자료형에 저장된 값을 인덱싱으로 접근하려면 다음과 같이 리스트나 튜플로 변환한 후에 해야 한다.
```python
s1 = set([1, 2, 3])

# 리스트
l1 = list(s1)
l1 # [1, 2, 3]
l1[0] # 1

# 튜플
t1 = tuple(s1)
t1 # (1, 2, 3)
t1[0] # 1

🌟교집합, 합집합, 차집합 구하기

s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])

교집합 &

• ‘&’를 이용.

  s1 & s2 # {4, 5, 6}

• intersection 함수를 사용.

  s1.intersection(s2) # {4, 5, 6}

합집합 |

• ‘|’를 사용.

  s1 | s2 # {1, 2, 3, 4, 5, 6, 7, 8, 9}

• union 함수를 사용.

  s1.union(s2) # {1, 2, 3, 4, 5, 6, 7, 8, 9}

차집합 -

• -(빼기) 사용.

  s1 - s2 # {1, 2, 3}
  s2 - s1 # {8, 9, 7}

• difference 함수를 사용.

  s1.difference(s2) # {1, 2, 3}
  s2.difference(s1) # {8, 9, 7}

  
  

🌟집합 자료형 관련 함수

📍add

• 값 1개 추가.
• 이미 만들어진 집합에 값을 추가.

  s1 = set([1, 2, 3])
  s1.add(4)
  s1 # {1, 2, 3, 4}

📍update

• 값 여러 개 추가.
• 여러 개의 값을 한꺼번에 추가.

  s1 = set([1, 2, 3])
  s1.update([4, 5, 6])
  s1 # {1, 2, 3, 4, 5, 6}

📍remove

• 특정 값 제거.

  s1 = set([1, 2, 3])
  s1.remove(2)
  s1 # {1, 3}

📍discard

• 특정 값 제거.
• remove와 비슷하지만 존재하지 않는 값을 제거하려 할 때 오류가 발생하지 않는다.

  s1 = set([1, 2, 3])
  

s1.discard(2) s1 # {1, 3}

s1.discard(4)
s1 # {1, 3} # 없는 값이어도 오류가 발생하지 않음

### 📍clear
- 집합의 모든 값을 제거.
```python
s1 = set([1, 2, 3])
s1.clear()
s1 # set()

▶︎딕셔너리

• Key와 Value를 한 쌍으로 가지는 자료형.
• ‘연관 배열(associative array)’또는 ‘해시(hash)’라고도 한다.
• 리스트나 튜플처럼 순차적으로(sequential) 해당 요솟값을 구하지 않고 Key를 통해 Value를 얻는다.
  • 내용을 순차적으로 모두 검색하지 않는다.
• 파이썬 3.7 이전 버전에서는 딕셔너리에 데이터를 저장할 때 입력한 순서가 보장되지 않았다. 하지만 파이썬 3.7부터는 딕셔너리에 아이템을 삽입한 순서가 유지된다. 즉, 딕셔너리를 순회할 때 아이템이 추가된 순서대로 나온다.
  

🌟딕셔너리 생성

• 딕셔너리의 기본 모습: {Key1: Value1, Key2: Value2, Key3: Value3, ...}
  • Key와 Value의 쌍 여러 개가 {}로 둘러싸여 있다.
  • 각각의 요소는 Key: Value 형태로 이루어져 있고 쉼표(,)로 구분되어 있다.

    dic = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}

    
    

🌟딕셔너리 쌍 추가

a = {1: 'a'}
a[2] = 'b'
a # {1: 'a', 2: 'b'}
a['name'] = 'pey'
a # {1: 'a', 2: 'b', 'name': 'pey'}

🌟딕셔너리 요소 삭제

a = {1: 'a', 2: 'b', 'name': 'pey'}
del a[1]
a # {2: 'b', 'name': 'pey'}
del a['name']
a # {2: 'b'}

🌟딕셔너리에서 Key를 사용해 Value 얻기

• 리스트나 튜플, 문자열은 요솟값을 얻고자 할 때 인덱싱이나 슬라이싱 기법 중 하나를 사용하지만 딕셔너리는 Key를 사용해서 Value를 구한다.
• 어떤 Key의 Value를 얻기 위해서는 '딕셔너리_변수_이름[Key]'를 사용해야 한다.

  grade = {'pey': 10, 'julliet': 99}
  grade['pey'] # 10
  grade['julliet'] # 99

• 딕셔너리에서 Key는 고유한 값이므로 중복되는 Key 값을 설정해 놓으면 하나를 제외한 나머지 것들이 모두 무시된다. (딕셔너리에는 동일한 Key가 중복으로 존재할 수 없다.)

  a = {1:'a', 1:'b'}
  a # {1: 'b'}
  a[1] # 'b'

• 딕셔너리의 Key로 쓸 수 있는 것은 변하지 않는(immutable) 값만 가능.
  • Key에 리스트는 쓸 수 없다. 리스트는 그 값이 변할 수 있기 때문.
  • 하지만 튜플은 Key로 쓸 수 있다.
  • Value에는 변하는 값이든, 변하지 않는 값이든 아무 값이나 넣을 수 있다.

    a = {[1,2] : 'hi'}
    # TypeError: unhashable type: 'list'

    
    

🌟딕셔너리 관련 함수

📍keys

• Key 리스트 만들기.

  a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
  a.keys() # dict_keys(['name', 'phone', 'birth'])

• a.keys()는 딕셔너리 a의 Key만을 모아 dict_keys 객체를 반환.

📍values

• Value 리스트 만들기.

  a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
  a.values() # dict_values(['pey', '010-9999-1234', '1118'])

• a.keys()는 딕셔너리 a의 value만을 모아 dict_values 객체를 반환.

📍items

• Key, Value 쌍 얻기.

  a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
  a.items() # dict_items([('name', 'pey'), ('phone', '010-9999-1234'), ('birth', '1118')])

• items 함수는 Key와 Value의 쌍을 튜플로 묶은 값을 dict_items 객체로 반환

+) 파이썬 3.0 이후에는 dict 객체

• 파이썬 2.7 버전까지는 a.keys() 함수를 호출하면 dict_keys가 아닌 리스트를 반환한다.
• 리스트를 반환하기 위해서는 메모리 낭비가 발생하는데, 파이썬 3.0 이후 버전에서는 이러한 메모리 낭비를 줄이기 위해 dict_keys, dict_values, dict_items 객체를 반환하도록 변경되었다.

+) dict 객체

• dict_keys, dict_values, dict_items 객체는 리스트로 변환하지 않더라도 기본적인 반복 구문(예: for 문)에서 사용할 수 있다.

  for k in a.keys():
      print(k)
  # name
  # phone
  # birth

• 리스트를 사용하는 것과 별 차이는 없지만, 리스트 고유의 append, insert, pop, remove, sort 함수는 수행할 수 없다.
• 반환값으로 리스트가 필요한 경우에는 list(a.keys())를 사용하면 된다.

  list(a.keys()) # ['name', 'phone', 'birth']

📍clear

• Key: Value 쌍 모두 지우기.

  a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
  a.clear() 
  a # {}

• clear 함수는 딕셔너리 안의 모든 요소를 삭제.
• 빈 딕셔너리는 {}로 표현한다.

📍get

• Key로 Value 얻기.

  a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
  a.get('name') # 'pey'
  a.get('phone') #'010-9999-1234'
  a.get('nokey', '정보없음') # '정보없음'

• get(x) 함수는 x라는 Key에 대응되는 Value를 반환.
• a['nokey']: 딕셔너리에 존재하지 않는 키로 값을 가져오려고 할 경우, 오류를 발생.
• a.get('nokey'): 딕셔너리에 존재하지 않는 키로 값을 가져오려고 할 경우, None을 반환.
• 딕셔너리 안에 찾으려는 Key가 없을 경우, 미리 정해 둔 디폴트 값을 대신 가져오게 하고 싶을 때는 get(x, '디폴트 값')을 사용.

📍in

• 해당 Key가 딕셔너리 안에 있는지 조사.

  a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
  'name' in a # True
  'email' in a # False

• 'name' 문자열은 a 딕셔너리의 Key 중 하나이다. 따라서 'name' in a를 호출하면 참(True)을 반환.
• 'email'은 a 딕셔너리 안에 존재하지 않는 Key이므로 거짓(False)을 반환.

📍pop

• Key로 Value 얻기.

  a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}
  phone = a.pop('phone')
  phone # '010-9999-1234'
  a # {'name': 'pey', 'birth': '1118'}
  

email = a.pop('email', '정보없음') email # '정보없음'

- pop(x) 함수는 딕셔너리에서 **Key가 x인 항목을 삭제한 후 그 Value를 반환.** 
- get 함수와 달리 pop은 해당 항목을 딕셔너리에서 삭제한다는 차이가 있다. 
- 존재하지 않는 Key에 대해서는 디폴트 값을 지정할 수 있다.