1. 파일

📁  변수는 프로그램을 실행할 때 데이터를 저장하기 좋은 방법
        ➡️  그러나 프로그램을 종료한 후에도 데이터를 유지하고 싶다면, 파일 형태로 저장해야 함

1) 파일과 파일 경로

   ⚡️  파일에는 파일 이름과 경로라는 두 가지 주요속성이 있다.
          ex. 윈도우 운영체제를 사용하는 노트북 컴퓨터의 C:\Users\al\Documents 라는 경로에

                 project.docx 라는 이름의 파일이 있는 경우
                  ▶️  파일이름 project.docx는 워드 문서이고 Users, al, Documents는 모두 폴더(디렉토리)
                  ▶️  폴더 안에는 파일이나 다른 폴더가 들어 있을 수 있음

   ⚡️ 경로의 C:\는 루트 폴더를 나타내며 모든 폴더가 이 안에 들어 있음
          📌  윈도우에서 루트 폴더의 이름은 "C:\"이며, C 드라이브라고 부름.
          📌  맥os나 리눅스에서 루트 폴더는 "/"
          📌  윈도우, 맥os에서는 폴더이름이나 파일이름의 대소문자를 구분하지 않지만, 리눅스의 경우 이를 구분함

   ⚡️ 윈도우에서의 폴더 구분은 "\" 백슬러시를 사용하고, 맥 os나 리눅스에서는 "/" 슬러시를 사용함.

# 1) Path 객체 사용.
from pathlib import Path
path = Path('spam', 'bacon', 'eggs')  # 운영체제에 맞는 경로 체제를 만들어 줌.
print(path)  # spam/bacon/eggs

# 2) platform.system() 함수 사용.
import platform
my_os = platform.system()
print("OS in my system: ", my_os)  # OS in my system:  Darwin
if my_os == 'Darwin':
    print('Mac 운영체제 입니다.')
else:
    print('Mac 운영체제가 아닙니다.')

# 현재 작업 디렉토리
print(Path.cwd())  # /Users/Desktop/pycharm/pythonProject/part2

2) 절대 경로와 상대 경로

⚡️ 절대 경로 : 항상 루트 폴더에서 시작하는 경로
⚡️ 상대 경로 : 현재 작업 디렉토리에 대한 경로 
     📌  '.' : 현재 디렉토리
    📌  '..' : 상위 디렉토리

3) 새로운 디렉토리 만들기

⚡️ os.makedirs() 함수로 새로운 디렉토리를 만들 수 있음
⚡️ os.path.isdir(path) : path 인자의 디렉토리가 있는지 확인

import os
path = './test'
if not os.path.isdir(path):
    os.makedirs(path)  # 현재 작업 폴더 안에 test라는 폴더 생성.

4) 파일 크기와 폴더 내용 확인

⚡️ os.path.getsize(path) : path 인자에 해당하는 파일 크기 반환
⚡️ os.listdir(path) : path에 있는 파일 이름 리스트를 반환

path = './input'
print(os.path.getsize(f'{path}/hello.txt'))  # 53
list_dirs = os.listdir(path)
print(list_dirs)  # ['연락처.txt', 'hello.txt', '엄마돼지아기돼지.txt']

2. 파일 열기

📁  입출력 파일을 지정하는것을 의미 ( 파일 객체 생성 )
📁  파일 입력과 파일 출력 모두 반드시 파일 열기 작업을 가장 먼저 수행

파일객체 = open(파일명, 모드)

1) 파일명

🚀  입출력 작업을 수행할 파일을 의미
🚀  파일명만 작성할 수도 있고 경로를 함께 작성할 수도 있음

# 파일명만 작성하는 경우 : 파이썬 소스 파일과 같은 경로에 존재하는 경우
open('sample.txt')

# 전체 경로를 작성하는 경우 : 빈도가 적음.
open('C:/sample.txt')

# 현재 디렉터리(.)를 기준으로 경로를 결정
open('./sample.txt')
open('./input/hello.txt')

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

2) 모드

🚀  파일의 종류
     - t (text) 텍스트 파일 : 메모장으로 열 수 있는 파일
     - b (binary) 바이너리 파일 (텍스트 파일 외의 모든 파일)

3. 파일 닫기

👾  파일을 더 이상 사용하지 않거나 프로그램을 종료하고자 할 때

파일객체.close()

4. 파일 생성

file = open('./output/my_file.txt', 'wt')  # 빈파일 생성
print('my_file.txt 파일이 생성되었습니다.')
file.close()

# 텍스트 파일을 새로 만들 수 있는 모드인 wt 모드를 사용하여 my_file.txt라는 이름의
# 텍스트 파일을 output 이라는 디렉토리에 생성하는 코드

🚀   with문
    -  close() 메소드를 자동으로 호출할 수 있는 문법을 제공
    -  with문을 사용하면 with문이 끝날 때 언제나 close() 메소드가 자동으로 호출

         ➡️  별도의 예외 처리를 하지 않더라도 프로그램이나 파일의 에러로 close()가 호출이 안되는 상황을 방지

# 기본 구성
with open (파일명, 모드) as 파일객체:
    파일처리코드

with open('./output/my_file_1.txt', 'wt') as file:
    print('my_file_1.txt 파일이 생성되었습니다.')

5.  파일 입출력

📁  파일 입출력 : 컴퓨터에 저장된 파일을 읽어 들이는 것은 물론 파일을 생성해서 컴퓨터에 저장하는 것도 가능
    📌 파일 입력 input : 기존의 파일 내용을 읽어 들이는 것
    📌 파일 출력 output : 기존 파일에 새로운 내용을 추가하거나 새로운 파일을 생성하는 것

1) 파일 출력 output

# 1. 텍스트 파일 생성하기
file = open('./output/hello.txt', 'wt')

# hello.txt에 글 쓰기.
file.write('안녕하세요.')
file.write('\n')  # 줄 바꿈
file.write('반갑습니다.')
file.write('\n')
print('hello.txt 파일이 생성되었습니다.')  # 진행 상황을 알기 위해서 화면 출력.

file.close()

# 2. 텍스트 파일에 내용 추가하기
# 기존 파일에 내용을 추가할 수 있는 모드는 a 모드
file = open('./output/hello.txt', 'at')

file.write('Hello.\n')
file.write('Nice to meet you.\n')
print('hello.txt 파일에 새로운 내용이 추가되었습니다.')

file.close()

2) 파일 입력  input

1)  read() 메소드

📁  파일로부터 데이터를 읽어 들이는 메소드
📁  텍스트 모드와 바이너리 모드에서 다른 방식으로 동작

file.read(size)

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

file = open('./input/hello.txt', 'rt', encoding='cp949')

str = file.read()  # 파일 전체를 한 번에 읽어 들임
print(str, end='')

file.close()

    💡 'encoding = cp949' 는 맥 os 에서 파일 처리할 때 사용

2)  readline() 메소드

📁  텍스트 파일을 한 줄씩 읽어서 처리하는 메소드
📁  파일이 종료되어 더 이상 읽어 들일 글자가 없으면 빈 문자열('')을 읽어 들임
📁  반복문을 이용해서 여러 번 읽어 들어야 파일 전체를 읽어 들일 수 있음

file = open('./input/hello.txt', 'rt', encoding='cp949')

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

file.close()

3) readlines() 메소드

📁  라인 line 하나가 아니라 전체 라인 lines을 모두 읽어 각 라인 line 단위로 리스트에 저장하는 메소드

file = open('input/hello.txt', 'rt', encoding='cp949')

line_list = file.readlines()
print(line_list) # ['안녕하세요.\n', '반갑습니다.\n', 'Hello.\n', 'Nice to meet you.\n']
for line in line_list:
    print(line, end='')

file.close()

# enumrate() 함수를 이용하면 라인 번호 line number 도 함께 출력할 수 있다
file = open('input/hello.txt', 'rt', encoding='cp949')

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() 메소드를 사용하면 리스트와 같은 반복 가능한 객체의 각 요소를 한 줄씩 자동으로 출력

import sys

file = open('input/hello.txt', 'rt', encoding='cp949')

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

file.close()

6. pickle

📁  텍스트가 아닌 자료형 (리스트나 딕셔너리 자료형등)을 저장하기 위한 방식
📁  import pickle을 통하여 모듈 임포트가 필요
📁  pickle로 데이터를 저장하거나 불러올때는 파일을 바이너리 형식으로 읽거나 써야함 (wb, rb)
📁  모든 파이썬 데이터 객체를 저장하고 읽을 수 있음

import pickle
data = {
    'a': [1, 2.0, 3, 4 + 6j],
    'b': ("character string", "byte string"),
    'c': {None, True, False}
}
print(type(data))  # <class 'dict>

# 1. 일반 텍스트 파일 형식을 사용하는 경우.
# 저장
with open('./output/data.txt', 'w') as file:
    # file.write(data)  # TypeError: write() argument must be str, not dict
    file.write(str(data))  # write() 메서드의 인자는 문자열이어야 함.

# 읽기
with open('./output/data.txt', 'r') as file:
    data_output = file.read()
print(data_output)  
# {'a': [1, 2.0, 3, (4+6j)], 'b': ('character string', 'byte string'), 
# 'c': {False, True, None}}
print(type(data_output))  #  <class 'str'>

# 2. pickle 방식을 사용하는 경우
# 저장
with open('./output/data.my_pickle', 'wb') as file:
    pickle.dump(data, file)

# 읽기
with open('./output/data.my_pickle', 'rb') as file:
    data_output = pickle.load(file)  # 읽음.

print(data_output)  
# {'a': [1, 2.0, 3, (4+6j)], 'b': ('character string', 'byte string'), 
# 'c': {False, True, None}}
print(type(data_output))  # <class 'dict'>
print(data_output.get('a'))  # [1, 2.0, 3, (4+6j)]

[ 내용 참고 : IT 학원 강의 ]

1. 클래스 변수

🚀  클래스를 구현할 때 인스턴스마다 서로 다른 값을 가지는 경우에는 인스턴스 변수를 사용
🚀  모든 인스턴스 변수들은 self 키워드를 붙여서 사용
🚀  모든 인스턴스가 동일한 값을 사용할 때는 클래스 변수로 처리해서 모든 인스턴스들이 공유하도록 처리하는 것이 좋음
        ➡️  하나의 값을 모든 인스턴스가 공유하기 때문에 메모리 공간의 낭비를 막을 수 있음

     ⚡️  self
         - 관례적으로 모든 메서드의 첫 번째 매개변수 이름을 self로 지정.
         - self라는 명칭은 관례적으로 사용하는 단어.

# 클래스 변수 만들기
class 클래스 이름:
    클래스 변수 = 값
# 클래스 변수 접근
클래스 이름.변수 이름

class Korean:
    country = '한국'  # 클래스 변수 country

    def __init__(self, name, age, address):
        self.name = name  # 인스턴스 변수
        self.age = age
        self.address = address

print(Korean.country)  # 객체 생성전에도 사용 가능.

man = Korean('홍길동', 35, '서울')
print(man.name)
# print(Korean.name)  # AttributeError: type object 'Korean' has no attribute 'name'

print(man.country)  # 인스턴스 man을 통한 클래스 변수 접근
print(Korean.country)  # 클래스 Korean을 통한 클래스 변수 접근

print('객체 property 생성과 동일한 이름의 클래스 변수')
man.country = '중국'  # 객체의 인스턴스 변수 생성
print(man.country)  # 중국. 
# 클래스 변수가 아니라 인스턴스 변수를 불러옴. 
# man 객체의 country 라는 인스턴스 변수와 country 클래스 변수
print(man.__class__.country)  # 한국. 객체를 사용해서 클래스 변수 불러오기.
print(Korean.country)  # 한국.

print('객체를 이용해서 클래스 변수 값 변경')
man.__class__.country = '영국'
print(Korean.country)  # 영국

print('클래스를 이용해서 클래스 변수 값 변경')
Korean.country = '미국'  # 클래스 변수를 변경
print(Korean.country)  # 미국

man2 = Korean('홍길동2', 35, '서울')
print(man2.country)  # 미국
print(Korean.country)  # 미국

# 클래스 변수는 클래스를 통해서 접근하는 것이 권장사항

2. 클래스 메소드

🚀  클래스 변수를 사용하는 메소드를 의미
 

   ⚡️ 주요 특징
         a. 인스턴스 혹은 클래스로 호출
         b. 생성된 인스턴스가 없어도 호출할 수 있음
         c. @classmethod 데코레이터 decorator를 표시하고 작성
         d. 매개변수 self를 사용하지 않고 cls를 사용
         e. 클래스 메소드는 self를 사용하지 않기 때문에 인스턴스 변수에 접근할 수 없지만 cls를 통해서 클래스 변수에 접근할 수 있음

class Korean:
    country = '한국'  # 클래스 변수 country

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

Korean.trip('한국')  # 국내여행입니다.
Korean.trip('미국')  # 해외여행입니다.

3. 정적 메소드

🚀  인스턴스 또는 클래스로 호출
🚀  생성된 인스턴스가 없어도 호출 가능
🚀  @staticmethod 데코레이터 decorator를 표시하고 작성
🚀  반드시 작성해야 할 매개변수가  없음

    ⚡️  self와 cls를 모두 사용하지 않기 때문에 인스턴스 변수와 클래스 변수를 모두 사용하지 않는 메소드를 정의하는 경우에 적절
    ⚡️  정적 메소드는 클래스에 소속이 되어 있지만, 인스턴스에는 영향을 주지 않고 또 인스턴스로부터 영향을 받지도 않음

class Korean:
    country = '한국'  # 클래스 변수 country

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

Korean.slogan()  # Imagine your Korea

4. 상속  inheritance

1) 상속이란?

👾  어떤 클래스가 가지고 있는 기능을 그대로 물려받아서 사용할 수 있는 클래스를 만들 수 있다.
👾  다른 클래스의 기능을 물려받을 때 상속받는다는 표현을 사용
👾  상속 관계에 있는 클래스를 표현할 때 '부모 클래스와 자식 클래스'라는 말을 사용

    ⚡️ 부모 클래스 : 상속해 주는 클래스 / 슈퍼 클래스 super class , 기반 클래스 base class
    ⚡️ 자식 클래스 : 상속 받는 클래스 / 서브 클래스 sub class, 파생 클래스 derived class

2) 상속 관계 구현

👾  기본적으로 두 클래스가 상속 관계에 놓이려면 IS-A 관계가 성립해야 한다
👾  IS-A 관계란 '~은 ~ 이다'로 해설할 수 있는 관계를 의미
        ex. '학생은 사람이다 Student is a Person'처럼 해석되는 것이 IS-A 관계
                이때 Student 는 서브 클래스가 되고, Person은 슈퍼 클래스가 됨

👾  has-a 관계는  '그릇이 스쿱을 갖는다 Bowl has-a Scoop'
👾  has-a 관계는 상속이 아니라 구성 Composition으로 구현함

# 상속의 기본적인 형식
class 슈퍼 클래스:
    본문

class 서브 클래스(슈퍼 클래스):
    본문

  ⚡️  서브 클래스를 구현할 때는 괄호 안에 어떤 슈퍼 클래스를 상속 받는지 명시
  ⚡️  상속 관계에 놓인 서브 클래스는 마치 자신의 것처럼 슈퍼 클래스의 기능을 사용할 수 있음

class Person:  # 슈퍼 클래스
    def __init__(self, name):
        self.name = name

    def eat(self, food: str) -> None:
        print(f'{self.name}가 {food}를 먹습니다.')

class Student(Person):  # 서브 클래스
    def __init__(self, name: str, school: str) -> None:
        super().__init__(name)  # 슈퍼 클래스의 생성자 실행
        self.school = school

    def study(self) -> None:
        print(f'{self.name}는 {self.school}에서 공부를 합니다.')

potter = Student('해리포터', '호그와트')
potter.eat('감자')  # 해리포터가 감자를 먹습니다.
potter.study()  # 해리포터는 호그와트에서 공부를 합니다.

3) 서브 클래스의  __init__()

👾  서브 클래스의 생성자를 구현할 때는 반드시 슈퍼 클래스의 생성자를 먼저 호출하는 코드를 작성해야 함
👾  super라는 키워드는 슈퍼 클래스를 의미

class Computer:  # 슈퍼 클래스
    def __init__(self):
        print('슈퍼 클래스의 생성자가 실행되었습니다.')

class NoteBook(Computer):  # 서브 클래스
    def __init__(self):
        super().__init__()
        print('서브 클래스의 생성자가 실행되었습니다.')

4) 서브 클래스의 인스턴스 자료형

👾  슈퍼 클래스 객체는 슈퍼 클래스의 인스턴스
👾  그에 비해 서브 클래스 객체는 서브 클래스의 인스턴스이면서 동시에 수퍼 클래스의 인스턴스

    ⚡️ 서브 클래스 Student의 객체는 서브 클래스 Student의 인스턴스 이면서 동시에 슈퍼 클래스 Person의 인스턴스

👾  어떤 객체가 어떤 클래스의 인스턴스인지 확인하기 위해서 isinstance() 함수를 사용
        ➡️  객체가 인스턴스일 경우에는 True 아니면 False 반환

# isinstance(객체, 클래스)
print(isinstance(potter, Student))  # True
print(isinstance(potter, Person))  # True

[ 내용 참고 : IT 학원 강의 ]

1. 모듈 만들기

# test_module.py 파일
PI = 3.141592

def number_input():
    output = input("숫자 입력 >>> ")
    return float(output)

def get_circumference(radius):
    return 2 * PI * radius

def get_circle_area(radius):
    return PI * radius * radius

# test.py 파일
import test_module as test

radius = test.number_input()
print(test.get_circumference(radius))
print(test.get_circle_area(radius))

2.  __name__ =="__main__"

📁  프로그램의 진입점을 엔트리 포인트 entry point 또는 메인 main 이라고 부른다

      ➡️  엔트리 포인트 또는 메인 내부에서의 __name__ 은 "__main__"

📁  모듈 내부에서 __name__ 을 출력하면 모듈의 이름을 나타낸다.

# 엔트리 포인트 확인하는 모듈
PI = 3.141592

def number_input():
    output = input("숫자 입력 >>> ")
    return float(output)

def get_circumference(radius):
    return 2 * PI * radius

def get_circle_area(radius):
    return PI * radius * radius

# 현재 파일이 엔트리 포인트인지 확인하고, 엔트리 포인트일 때만 실행
if __name__ == '__main__':
    print('get_circumference(10):', get_circumference(10))
    print('get_circle_area(10)', get_circle_area(10))

3. __init__.py 파일

📁  해당 폴더가 패키지임을 알려주고, 패키지와 관련된 초기화 처리를 하는 파일

       ➡️  패키지 폴더 내부에 __init__.py 파일을 생성

📁  __all__ 이라는 이름의 리스트를 파일안에 만드는데, 이 리스트에 지정한 모듈들이 from<패키지이름> import * 를 할 때 전부 읽어 들여진다.

# "from <모듈이름> import *"로
# 모듈을 읽어 들일 때 가져올 모듈
__all__ = [사용시 읽어 들일 모듈의 목록]

[ 내용 참고 : 책 '혼자 공부하는 파이썬' ]

1.  외부 모듈의 이용

📁  외부 모듈은 다른 사람들이 만들어 배포하는 모듈을 말함

1) 패키지

    👾  모듈의 상위 개념으로 모듈의 집합을 의미
    👾  파이썬에서 기본적으로 제공하지 않더라도 외부에서 만들어진 패키지를 이용하면 패키지에 포함된 모듈을 사용할 수 있음

2) 패키지 관리자

    👾  외부 모듈을 사용하기 위해서는 우선 모듈이 포함된 패키지를 추가로 설치
    👾  pip라고 불리는 패키지 관리자를 사용해서 패키지를 추가, 삭제

3) 패키지 설치

💡  보통 관심있는 분야와 관련된 모듈을 검색해서 설치

       📌  맥os 에서는 터미널에 입력하여 설치

 pip install package

    👾  numpy 패키지는 수치해석과 통계에서 많이 사용

import numpy as np
print(np.sum([1, 2, 3, 4, 5]))  # 15

    👾  Beautiful Soup는 파이썬 웹 페이지 분석 모듈

# Beautiful Soup 모듈로 날씨 가져오기
from urllib import request
from bs4 import BeautifulSoup

# urlopen() 함수로 기상청의 전국 날씨 읽기
target = request.urlopen("http://www.kma.go.kr/weather/forecast/mid-term-rss3.jsp?stnId=108")

# 웹페이지 분석
soup = BeautifulSoup(target, "html.parser")

# location 태그 찾기
for location in soup.select("location"):
    # 내부 city, wf, tmn, tmx 태그를 찾아 출력
    print("도시:", location.select_one("city").string)
    print("날씨:", location.select_one("wf).string)
    print("최저기온:", location.select_one("tmn").string)
    print("최고기온:", location.select_one("tmx").string)
    print()
    
'''
도시: 서울
날씨: 구름많음
최저기온: 3
최고기온: 9

도시: 인천
날씨: 구름많음
최저기온: 2
최고기온: 8

도시: 수원
날씨: 구름많음
최저기온: 2
최고기온: 10
...생략...
'''

  📌  urllib는 URL 작업을 위한 여러 모듈을 모은 패키지 

  📌  태그를 여러개 선택할 때 select(), 한 개 선택할 때 select_one() 사용하여 값 추출

    👾  Django는 다양한 기능을 제공하는 웹 개발 프레임워크, Flask는 작은 기능만을 제공하는 웹 개발 프레임워크

pip install flask

from flask import Flask
app = Flask(__name__)

@app.rout("/")
def hello():
    return "<h1>Hello World!</h1>"
# @app.route() 는 데코레이터

# 맥 os 에서 Flask 코드 실행 방법
export FLASK_APP=파일 이름.py
flask run
# 터미널에 입력

    ⚡️  프로그램 종료할 때는 Ctrl + C

4) 패키지 삭제

pip uninstall package
ex. pip uninstall numpy

2. 라이브러리와 프레임워크

📁  라이브러리(library) : 정상적인 제어를 하는 모듈

📁  프레임워크(framework) : 제어 역전이 발생하는 모듈

1) 라이브러리

   - 개발자가 모듈의 기능을 호출하는 형태의 모듈

from math import sin, cos, tan, floor, ceil

2) 프레임워크

    - 모듈이 개발자가 작성한 코드를 실행하는 형태의 모듈 

         ex. Flask 모듈이 제공하는 명령어를 실행하면  Flask가 내부적으로 서버를 실행한 뒤 지정한 파일을 읽어 들여

               적절한 상황에 스스로 실행하게 됨

    - 개발자가 만든 함수를 모듈이 실행하는 것은 제어가 역전된 것

3. 데코레이터

1) 함수 데코레이터

⚡️  함수에 사용하는 데코레이터

       ➡️  대상 함수의 앞뒤에 꾸밀 부가적인 내용 혹은 반복할 내용을 데코레이터로 정의해서 손쉽게 사용할 수 있도록 한 것

# 함수 데코레이터 생성
def test(function):
    def wrapper():
        print("인사가 시작되었습니다.")
        function()
        print("인사가 종료되었습니다.")
    return wrapper
    
# 데코레이터를 붙여 함수를 만든다
@test
def hello():
    print("hello")
    
# 함수를 호출
hello()

'''
인사가 시작되었습니다.
hello
인사가 종료되었습니다.
'''

[ 내용 참고 : IT 학원 강의 및 책 '혼자 공부하는 파이썬' ]

1. 튜플  tuple

📁  리스트와 비슷한 자료형이나 한번 결정된 요소를 바꿀 수 없다는 것이 다르다.

       ➡️  이미 저장된 값 이외에는 추가, 수정, 삭제가 불가능

📁  리스트와 마찬가지로 각 요소를 구분하기 위한 인덱스가 부여되고 슬라이싱도 지원
📁  튜플은 소괄호() 나 tuple() 함수를 이용해서 생성
📁  값들을 콤마(,)로 분리하여 전달하면 자동으로 튜플이 생성

t1 = (1,2,3)
print(t1)  # (1,2,3)

# 괄호 없이 사용 가능
t2 = 1,2,3
print(t2)  #(1,2,3)

def sample():
   return (1,2)

print(sample())  #(1, 2)
# 값이 2개 반환된 것이 아니라 튜플을 자동으로 적용해서 반환함

# 리스트를 튜플로 변경
t3 = tuple([100, 3.14, 'hello'])
print(t3)  # (100, 3.14, 'hello')

# 값을 1개만 보관하는 튜플을 생성할 경우에는 값과 콤마(,)를 반드시 함께 작성
t4 = (100)
print(t4)  # 100  / 값으로 인식
print(type(t4))  # <class 'int'>

t5 = (100, )
print(t5)  # (100, ) / 튜플로 인식
print(type(t5))  # <class 'tuple'>

# 값을 swap 교환
a = 10
b = 20
print(a, b)  # 10 20
a, b = b, a  # (a, b) = (b, a)
print(a, b)  # 20 10

a, b = 100, '홍길동'
print(a)  # 100
print(b)  # 홍길동

2. 람다  lambda

📁  함수를 짧게 쓸 수 있는 파이썬의 문법

1)  콜백 함수  callback function

    ⚡️  함수의 매개변수에 사용하는 함수

# 매개변수로 받은 함수를 10번 호출하는 함수
def call_10_times(func):
    for i in range(10):
        func()
        
# 간단한 출력하는 함수
def print_hello():
    print("안녕하세요")
    
# 조합하기
call_10_times(print_hello)
# -> print_hello() 함수를 10번 실행

2) filter() 함수와 map() 함수

⚡️  함수를 매개변수로 사용하는 대표적인 표준함수

⚡️  map() 함수는 리스트의 요소를 함수에 넣고 리턴된 값으로 새로운 리스트를 구성

⚡️  filter() 함수는 리스트의 요소를 함수에 넣고 리턴된 값이 True인 것으로, 새로운 리스트를 구성

# map()
map(함수, 리스트)

# filter()
filter(함수, 리스트)

def power(item):
    return item * item
def under_3(item):
    return item < 3

list_input_a = [1, 2, 3, 4, 5]

# map() 사용
output_a = map(power, list_input_a)
print(output_a)  # <map object at 0x104c228f0>
print(list(output_a))  # [1, 4, 9, 16, 25]

# filter() 사용
output_b = filter(under_3, list_input_a)
print(output_b)  # <filter object at 0x104c22800>
print(list(output_b))  # [1, 2]

  👾  <map object> 와 <filter object> 를 제너레이터라고 부른다.

3) 람다의 개념

⚡️  간단한 함수를 쉽게 선언하는 방법을 뜻함

# 기본형식
lambda 매개변수: 리턴값

list_input_a = [1, 2, 3, 4, 5]

# map() 함수
output_a = map(lambda x: x * x, list_input_a)
print(output_a)  # <map object at 0x102d12860>
print(list(output_a))  # [1, 4, 9, 16, 25]

# filter() 함수
output_b = filter(lambda x: x < 3, list_input_a)
print(output_b)  # <filter object at 0x102d61810>
print(list(output_b))  # [1, 2]

3. 제너레이터  generator

📁  이터레이터를 직접 만들 때 사용하는 코드

📁  함수 내부에 yield 키워드를 사용하면 해당 함수는 제너레이터 함수가 된다.

📁  일반 함수와 달리 함수를 호출해도 함수 내부의 코드가 실행되지 않는다.

def test():
    print("함수가 호출되었습니다")
    yield "test"
    
print("A 지점 통과")  # A 지점 통과
test()

print("B 지점 통과")  # B 지점 통과
test()
print(test())  # <generator object test at 0x104ceda10>

  📌  위 예제에서 test()함수는 출력되지 않고, 제너레이터를 리턴한다.

  📌  제너레이터 객체는 next() 함수를 사용해 함수 내부 코드를 실행한다.

          ➡️  이때 yield 키워드 부분까지만 실행하며, next() 함수의 리턴값으로 yield 키워드 뒤에 입력한 값이 출력된다

def test():
    print("A 지점 통과")
    yield 1
    print("B 지점 통과")
    yield 2
    print("C 지점 통과")
  
output = test()

# next() 함수 호출
print("D 지점 통과")
a = next(output)
print(a)
print("E 지점 통과")
b = next(output)
print(b)
print("F 지점 통과")
c = next(output)
print(c)

next(output)

📌  next() 함수를 호출할 때마다 함수 내부의 내용이 진행

📌  next() 함수를 호출한 이후 yield 키워드를 만나지 못하고 함수가 끝나면 StopIteration 이라는 예외가 발생

[ 내용참고 : 책 '혼자 공부하는 파이썬' ]

1. 재귀함수

1) 팩토리얼  factorial

 👾  이러한 팩토리얼을 구하는 방법은 2가지로 구분

       a. 반복문 사용

       b. 재귀 함수 사용

A. 반복문으로 팩토리얼 구하기

def factorial(n):
    output = 1
    for i in range(1, n+1):
        output *= i
    return output

print("1!:", factorial(1))
print("2!:", factorial(2))
print("3!:", factorial(3))
print("4!:", factorial(4))
'''
1!: 1
2!: 2
3!: 6
4!: 24
'''

B. 재귀 함수로 팩토리얼 구하기

   - 재귀 recursion 란 '자기 자신을 호출하는 것'을 의미

f(4) = 4 * f(3)
     = 4 * 3 * f(2)
     = 4 * 3 * 2 * f(1) * f(0)
     = 4 * 3 * 2 * 1 * 1

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)
        
print("1!:", factorial(1))
print("2!:", factorial(2))
print("3!:", factorial(3))
print("4!:", factorial(4))

2. 피보나치 수열  Fibonacci numbers

👩🏻‍💻  피보나치 수를 처음 연구한 것은 레오나르도 피오나치로 토끼 수의 증가에 대해서 이야기하면서 이 수에 대해 언급했다 

  📌  n 번째 달의 토끼 수는

• 첫 달에는 새로 태어난 토끼 한 쌍만이 존재한다.
• 두 달 이상이 된 토끼는 번식 가능하다.
• 번식 가능한 토끼 한 쌍은 매달 새끼 한 쌍을 낳는다.
• 토끼는 죽지 않는다.

    📌  1번째 수열 = 1

           2번째 수열 = 1

           n번째 수열 = (n-1)번째 수열 + (n-2)번째 수열

def fibonacci(n):
    if n == 1:
        return 1
    if n == 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)
        
print("fibonnaci(1):", fibonacci(1))
print("fibonnaci(2):", fibonacci(2))
print("fibonnaci(3):", fibonacci(3))
print("fibonnaci(4):", fibonacci(4))
'''
fibonnaci(1): 1
fibonnaci(2): 1
fibonnaci(3): 2
fibonnaci(4): 3
'''

count = 0

def fibonacci(n):
    print("fibonacci({})를 구합니다.".format(n))
    global count
    count += 1
    
    if n == 1:
        return 1
    if n == 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)
        
 fibonacci(10)
 print("---")
 print("fibonacci(10) 계산에 활용된 덧셈 횟수는 {}번입니다.".format(count))
 '''
fibonacci(10)를 구합니다.
fibonacci(9)를 구합니다.
...생략...
fibonacci(1)를 구합니다.
fibonacci(2)를 구합니다.
---
fibonacci(10) 계산에 활용된 덧셈 횟수는 109번입니다.
'''

💡  위와 같이 덧셈 횟수가 기하급수적으로 늘어나는 이유

 👾  다음과 같은 형태의 그림을 트리 tree 라고 한다.

 👾  트리에 있는 각각의 지점을 노드 node, 마지막 단계의 노드를 리프 leaf 

     ➡️  트리 내부에 있는 각각의 노드 값을 계산하려면 덧셈을 한 번씩 해야 함

      ➡️  한 번 구한 값은 그것으로 계산이 끝나는 게 아니라,

            한 번 구했던 값이라도 처음부터 다시 계산해야 함

      ➡️  이 때문에 계산 횟수가 기하급수적으로 늘어나는 것

💡 위의 예제에서 global count를 쓰는 이유

    - 파이썬은 함수 내부에서 함수 외부에 있는 변수를 참조하지 못한다.

    - 함수 내부에서 함수 외부에 있는 변수라는 것을 설명하려면 다음과 같은 구문을 사용해야 UnboundLocalError가 발생하지 않는다.

global 변수 이름

3. 메모화

👩🏻‍💻  한 번 계산한 값을 저장해 놓은 후, 이후에 다시 계산하지 않고 저장된 값을 활용하는 기술

# 메모 변수 생성
dic = {
    1: 1,
    2: 1
}

def fibonacci(n):
    if n in dic:
        # 메모가 되어 있으면 메모된 값을 리턴
        return dic[n]
    else:
        # 메모가 되어 있지 않으면 값을 구함
        output = fibonacci(n-1) + fibonacci(n-2)
        dic[n] = output
        return output
# 함수 호출        
print("fibonnaci(10):", fibonacci(10))
print("fibonnaci(20):", fibonacci(20))
print("fibonnaci(30):", fibonacci(30))
print("fibonnaci(40):", fibonacci(40))

👾  딕셔너리를 사용해서 한 번 계산한 값을 저장, 이를 메모한다고 표현

👾  딕셔너리에 값이 메모되어 있으면 처리를 수행하지 않고 곧바로 메모된 값을 돌려주면서 코드 속도를 빠르게 만든다.

4. 리스트 평탄화

👩🏻‍💻  중첩된 리스트가 있을 때 중첩을 모두 제거하고 풀어서 1차원 리스트로 만드는 것을 의미

def flatten(data):
    output = []
    for item in data:
        if type(item) == list:
            output += flatten(item)
        else:
            output.append(item)
    return output
    
 example = [[1,2,3], [4,[5,6]], 7, [8, 9]]
 print(flatten(example))
 # [1, 2, 3, 4, 5, 6, 7, 8, 9]

  ⚡️  append() 함수는 매개변수 하나를 리스트의 마지막 요소로 추가

         ➡️ append(리스트_자료형) 형태로 리스트를 전달하면 리스트 전체가 하나의 요소로서 추가됨

  ⚡️  += 연산자는 오른쪽에 있는 '리스트의 요소'를 하나하나 리스트에 추가

[ 내용 참고 : 책 '혼자 공부하는 파이썬']