[5일차] 컬렉션 타입(튜플, 세트, 딕셔너리), 제어문(조건문, 반복문)

# 튜플 tuple

• 여러 가지 데이터 타입의 값을 저장할 수 있는 변경 불가능( immutable)한 순서가 있는 컬렉션
• 튜플은 괄호 ( ) 를 사용하여 생성
• 항목들은 쉼표(,)로 구분

1. 튜플 만들기

• 빈 튜플을 만들 일이 거의 없을 것임. 튜플은 변경 불가능해서 요소 추가가 불가능
• 요소가 1개일 경우 끝에 콤마를 꼭! 붙여야 함
• 연산자 우선순위에 의해 먼저 계산할 때 쓰는 소괄호로 인식

tu1 = ()
print(tu1)      # ()
print(type(tu1))    # <class 'tuple'>

tu1 = (1,)
print(tu1)  # (1,)
print(type(tu1))    # <class 'tuple'>

tu1 = (1)
print(tu1)  # 1
print(type(tu1))    # <class 'int'>

tu2 = (1, 3, 5, 7)
print(tu2)
print(type(tu2))

tu3 = tuple([1, 3, 5, 7])
print(tu3)
print(type(tu3))

li3 = list(tu3)
print(li3)      # [1, 3, 5, 7]
print(type(li3))        # <class 'list'>

tu4 = 1, 3, 5, 7        # 패킹
print(tu4)
print(type(tu4))

 

2. 패킹과 언패킹

• 한 변수가 여러 개의 값을 받아 컬렉션 타입이 되고, 이때 자동으로 생성된 것이 튜플

num1 = 10
num2 = 20
num3 = 30
tu4 = num1, num2, num3      # 패킹
print(tu4)

result1, result2, result3 = tu4     # 언패킹
print(result1)
print(result2)
print(result3)

 

3. 튜플의 인덱싱과 슬라이싱

tu5 = ('apple', 'banana', ('🍎', '🍌'))     # 리스트와 똑같음
#tu5[0] = 'orange'       # TypeError: 'tuple' object does not support item assignment 요소를 바꿀 수 없음
# tu5 = 'orange'        # 이건 가능
print(tu5)
print(type(tu5))
print(tu5[0])
print(type(tu5[0]))
print(tu5[2][0])
print(type(tu5[2][0]))

 

tu5 = ('apple', 'banana', ['🍎', '🍌'])
print(tu5)
print(type(tu5))
print(tu5[2])
print(type(tu5[2]))
tu5[2][0] = '❤'        # 이건 가능
print(tu5)
# tu5[2] = '🎃' # TypeError: 'tuple' object does not support item assignment

# 튜플의 슬라이싱은 결과도 튜플로 반환
tu6 = (1, 2, 'apple', 'banana')
print(tu6[1:])
print(tu6[1:3])

 

4. 튜플의 정렬

tu9 = (10, 30, 100, 90, 50)
# tu9.sort() # 튜플은 sort 메서드가 존재하지 않음
result = sorted(tu9, reverse=True) # 내림차순하여 리스트로 반환
print(result)
print(tu9) # 변경되지 않았음
result = tuple(result)
print(result)

---

# 세트 set

• 세트는 중복되지 않는 항목들의 순서가 없는 컬렉션
• 중괄호 {} 를 사용하여 생성하거나 set() 생성자 사용 가능

1. 세트 만들기

s1 = {1, 3, 5, 7}
print(s1)
print(type(s1))

s2 = {}
print(s2)
print(type(s2))     # 중괄호에 값이 없으면 자동으로 dict으로 생각

s3 = set([1, 3, 5, 7])  # list -> set
print(s3)
print(type(s3))

li4 = [1, 2, 3, 4]
print(type(li4))
s4 = set(li4)       # list -> set
print(s4)
print(type(s4))

s5 = {1, 3, 5, 3, 7, 9, 1, 5, 10, 7}        # 중복 자료 자동으로 날아감
print(s5)

li6 = [1, 3, 5, 3, 7, 9, 1, 5, 10, 7]
print(li6)
s6 = set(li6)
print(s6)

 

2. 세트의 메소드

• add() : 순서 상관 없이 세트의 요소를 추가

s1 = {1, 3, 5, 7}

s1.add(2)
s1.add(4)
s1.add(7)
print(s1)		# {1, 2, 3, 4, 5, 7}

 

• update() : 세트에 여러 요소를 추가

s1 = {1, 3, 5, 7}

s1.update([2, 4, 6, 8, 10])
print(s1)		# {1, 2, 3, 4, 5, 6, 7, 8, 10}

 

• remove() : 세트의 요소를 제거. 단 요소가 없으면 에러 발생

s1 = {1, 3, 5, 7}

s1.remove(3)
print(s1)
# s1.remove(3) # KeyError: 3

 

• discard() : 세트의 요소를 제거. 단 요소가 없어도 에러 발생하지 않음

s1 = {1, 3, 5, 7}

s1.discard(3)
print(s1)		# {1, 5, 7}
s1.discard(3)
print(s1)		# {1, 5, 7}

 

• copy() : 세트를 복사

s1 = {1, 3, 5, 7}

s2 = s1 # 메모리 주소를 복사 (같은 주소를 가리킴)
print(id(s1))       # id() : 메모리 주소 반환
print(id(s2))

s2 = s1.copy() # 값을 복사 (s1 set를 복사해서 다른 메모리 주소에 만들어서 s2가 가리키도록 만듦)
print(s1)
print(s2)
print(id(s1))
print(id(s2))

 

• union() : 합집합을 계산하여 반환

s3 = {10, 20, 30, 40, 50}
s4 = {30, 40, 50, 60, 70}

result1 = s3.union(s4)
print(result1)		# {70, 40, 10, 50, 20, 60, 30}

result2 = s3 | s4       # set or set (| 연산도 동일한 결과)
print(result2)		# {70, 40, 10, 50, 20, 60, 30}

 

• intersection() : 교집합을 계산하여 반환

result1 = s3.intersection(s4)
print(result1)		# {40, 50, 30}

result2 = s3 & s4       # set and set (& 연산도 동일한 결과)
print(result2)		# {40, 50, 30}

 

• difference() : 차집합을 계산하여 반환

result1 = s3.difference(s4)	
print(result1)		# {10, 20}

result2  = s3 - s4
print(result2)		# {10, 20}

 

• symmetric_difference() : 대칭 차집합을 계산하여 반환

result1 = s3.symmetric_difference(s4)
print(result1)		# {20, 70, 10, 60}

result2 = s3 ^ s4
print(result2)		# {20, 70, 10, 60}

---

# 딕셔너리

• key-value 쌍을 저장하는 순서 없는 변경 가능한(mutable) 컬렉션
  (Python 3.7 이전까지는 순서없음. 3.7이후는 입력 순서를 유지하지만 '논리적으로는' 순서없음으로 간주)
• 딕셔너리는 중괄호 {}를 사용하여 생성
• 키-값 쌍들은 쉼표(,)로 구분
• 각 키-값 쌍은 콜론(:)으로 구분

1. 딕셔너리 만들기

dic1 = {}
print(dic1)		# {}
print(type(dic1))		# <class 'dict'>

dic2 = {1:'김사과', 2:'반하나', 3:'오렌지', 4:'이메론'}
print(dic2)
print(type(dic2))

print(dic2[1])		# 김사과
print(dic2[3])		# 오렌지

dic3 = {'no':1, 'userid':'apple', 'name':'김사과', 'hp':'010-1111-1111'}
# key를 string으로 (중복만 아니면 됨)
print(dic3)		# {'no': 1, 'userid': 'apple', 'name': '김사과', 'hp': '010-1111-1111'}
print(dic3['userid'])		# apple
print(dic3['hp'])		# 010-1111-1111

 

2. 딕셔너리 수정하기

• 딕셔너리에 키-값 쌍을 추가, 삭제, 변경 가능
• 단, 딕셔너리의 키는 변경 불가능한 (immutable) 타입 (기본형4가지 + 튜플)
  ex. 문자열, 정수, 튜플은 딕셔너리의 키로 사용가능. 리스트는 키로 사용 불가능
• 하지만 딕셔너리의 값은 어떤 타입이든 상관 없음

dic3 = {'no':1, 'userid':'apple', 'name':'김사과', 'hp':'010-1111-1111'}
print(dic3)

# 추가
# 해당 key의 값 없으면 새로 생성
dic3['gender'] = 'female'
print(dic3)

# 변경
dic3['no'] = 10
print(dic3)

# 추가 (리스트)
dic3['score'] = [100, 90, 40]
print(dic3)

# 삭제
del dic3['no']
print(dic3)

# key에 list 사용하면? -> 불가능
# TypeError: unhashable type: 'list'
# dic3[[10, 20, 30]] = ['십', '이십', '삼십']     

# key에 tuple 사용하면? -> 가능
dic3[(10, 20, 30)] = ['십', '이십', '삼십']
print(dic3)

dic3['과일'] = {'사과':'🍎', '딸기':'🍓', '수박':'🍉'}
print(dic3)

# key에 dict 사용하면? -> 불가능
# TypeError: unhashable type: 'dict'
# 어쨋든 value 값이 수정가능하기 때문에
# dic3[{'자동차':'car'}] = ['아반떼', '소나타', '그랜져']

 

3. 함수와 메서드

• keys() : 딕셔너리의 모든 키 반환
• values() : 딕셔너리의 모든 값 반환
• items() : 딕셔너리의 모든 키-값을 튜플로 반환

dic3 = {'no':1, 'userid':'apple', 'name':'김사과', 'hp':'010-1111-1111'}
print(dic3)

print(dic3.keys())      # dict_keys(['no', 'userid', 'name', 'hp'])
print(dic3.values())	# dict_values([1, 'apple', '김사과', '010-1111-1111'])
print(dic3.items())     # dict_items([('no', 1), ('userid', 'apple'), ('name', '김사과'), ('hp', '010-1111-1111')])

 

• get() : 특정 키에 대한 값을 반환. 만약 키가 없으면 None 반환
  None을 치환할 수 있는 문자열 설정 가능

dic3 = {'no':1, 'userid':'apple', 'name':'김사과', 'hp':'010-1111-1111'}

print(dic3['useris'])
# print(dic3['gender']) 		# KeyError : 'gender' (없는 key는 에러나겠죠?)
print(dic3.get('userid')		# apple
print(dic3.get('gender')		# None
print(dic3.get('gender', '성별 알수없음')		# 성별 알수없음
print(dic3.get('name', '이름 알수없음')		# 김사과 (해당 value 존재하면 출력)

 

• pop() : 특정 키에 대한 값을 제거하고 제거된 값을 반환. 키가 없다면 에러발생

temp = dic3.pop('hp')		# 값만 반환하기 때문에 값을 temp 변수에 저장
print(dic3)		# {'no':1, 'userid': 'apple', 'name': '김사과'}
print(temp)		# 010-1111-1111

 

• in : 딕셔너리에 특정 '키'가 있는지 확인 (True or False로 반환)

dic3 = {'no':1, 'userid':'apple', 'name':'김사과', 'hp':'010-1111-1111'}

print('hp' in dic3)     # True
print('010-1111-1111' in dic3)      # False (저건 value니까)

---

# 조건문

• 프로그램의 실행 흐름을 제어하기 위한 문법
• 기본적으로 if, elif, else를 사용하여 조건의 참과 거짓에 따라 다른 코드 실행 가능
• 또한 간단한 조건에 대해서 조건부 표현식을 사용해 한 줄로 값을 선택 가능
• Python 3.10부터는 match~case 문법을 활용한 구조적 패턴 매칭을 통해 값 뿐만 아니라 컬렉션 타입의 데이터 구조를 기준으로 분기 처리 가능
• 이처럼 상황에 따라 다양한 방식의 조건문을 제공하여 간단한 분기부터 복잡한 처리까지 유연하게 구현 가능

---

# if, elif, else

1. if문

• 가장 기본적인 조건문
• 특정 조건이 True일 경우에만 해당 불록 내의 코드 실행
• 조건 : True 또는 False로 평가될 수 있는 표현식
• 조건이 True로 평가되면 if문 바로 아래의 코드 블록이 실행
• 그렇지 않으면 그 코드 블록 건너뜀

if 조건:
    실행할 코드

if True:
    print('결과는 참입니다')
print('프로그램을 종료합니다')

if False:
    print('결과는 참입니다')    # 실행x
print('프로그램을 종료합니다')

if '안녕하세요':
    print('결과는 참입니다')
print('프로그램을 종료합니다')

if '':
    print('결과는 참입니다')    # 실행x
print('프로그램을 종료합니다')

if '안녕하세요':print('결과는 참입니다')
print('프로그램을 종료합니다')

 

• 입력한 나이가 19 초과일 경우, '성인입니다 입력한 나이 : 20'
• 입력한 나이가 19 이하일 경우, '입력한 나이 : 15'
• if 아래의 블록을 실행하는 것이기 때문에 여러 코드가 있으면 여러 코드 실행

age = int(input('나이를 입력하세요: '))

if age > 19:
    print('성인입니다')
    print('넷플릭스 성인영화를 감상할 수 있습니다')

print('입력한 나이: ', age)

 

2. else문

• 조건문에서 특정 조건이 충족되지 않을 때 실행할 코드 블록을 정의

if 조건:
    코드 블록1      # True
else:
    코드 블록2      # False

 

• 입력한 나이가 19 초과일 경우, '성인입니다 넷플릭스 성인영화를 감상할 수 있어요 입력한 나이 : 20'
• 입력한 나이가 19 이하일 경우, '미성년입니다 디즈니플러스를 보세요 입력한 나이 : 18'

age = int(input('나이를 입력하세요'))

if age > 19:
    print('성인입니다')
    print('넷플릭스 성인영화를 감상할 수 있어요')
else:
    print('미성년입니다')
    print('디즈니플러스를 보세요')
print('입력한 나이: ', age)

 

• 로그인 프로그램 만들기
• 아이디 : admin, 비밀번호 : 1234
• 잘못된 아이디 또는 비밀번호 입력한 경우, '아이디 또는 비밀번호를 확인하세요'
• 올바른 아이디와 비밀번호 입력한 경우, '로그인 되었습니다'

userid = input('아이디를 입력하세요')
userpw = input('비밀번호를 입력하세요')

if userid == 'admin' and userpw == '1234':
    print('로그인 되었습니다')
else:
    print('아이디 또는 비밀번호를 확인하세요')

 

• 주민등록번호에 의한 성별을 판별하는 프로그램 만들기
• 0010113068518
• 인덱스 6이 1 | 3 | 5 | 7 | 9 일 경우, '남자'
• 인덱스 6이 그 외의 숫자일 경우, '여자'

juminNo = input('주민등록번호 13자리를 -없이 입력하세요')

if juminNo[6] == '1' or juminNo[6] == '3' or juminNo[6] == '5' or juminNo[6] == '7' or juminNo[6] == '9':
    print('남자')
else:
    print('여자')

 

• 입력받은 문자열의 길이가 3 미만일 경우, '아이디가 너무 짧습니다. (입력한 글자 수 : 2)'
• 입력받은 문자열의 길이가 3 이상일 경우, '아이디 admin는 사용 가능합니다.'

text = input("아이디를 입력하세요: ")

# length = len(text)
# if length < 3:

if (length := len(text)) < 3:
    print(f"아이디가 너무 짧습니다. (입력한 글자 수: {length})")
else:
    print(f"아이디 '{text}'는 사용 가능합니다.")

 

* 왈러스 연산자 :=

• 값의 할당과 동시에 그 값을 표현식 안에서 사용 가능하도록 해주는 할당 표현식(assignment expression)
• 기존에는 값을 변수에 저장한 뒤 다시 사용하는 두 단계 과정이 필요했지만
  := 연산자를 사용하면 조건문, 반복문, 컴프리헨션 등에서 값을 한 번 계산하면서 변수에 저장하고 바로 활용할 수 있어 더 간결해짐

3. elif문

• if-else 구조에서 추가적인 조건 검사를 하기 위해 사용
• else if의 줄임말
• 주어진 여러 조건 중에서 하나만 참일 때 실행되는 코드 블록을 정의
• if 없이 단독으로 사용 불가능
• 필요에 따라 여러 번 사용 가능
• else는 선택적. 사용될 경우 항상 if나 elif 뒤에 오도록.

if 조건1:
    코드 블록1
elif 조건2:
    코드 블록2
elif 조건3:
    코드 블록3
else:
    코드 블록4

age = int(input("나이를 입력하세요: "))

if age > 19:
	print("성인입니다")
elif age > 14:
	print("청소년입니다")
elif age > 6:
	print("어린이입니다")
elif age > 0:
	print("유아입니다")
# else:
#     print("입력을 확인하세요')

print("입력한 나이: ", age)

 

• 중첩도 가능

print("MBTI 간단 성격 유형 검사에 오신 걸 환영합니다!")

# 첫 번째 질문: 외향/내향
answer1 = input("Q1. 새로운 사람들과 만나는 걸 좋아하시나요? (y/n): ")
if answer1.lower() == 'y':      # .lower() : 소문자로
    # 외향형으로 진행
    print("외향형으로 분석 중...")
    answer2 = input("Q2. 주변 환경에 대해 자주 인지하고 있나요? (y/n): ")
    
    if answer2.lower() == 'y':
        # 감각형(외향, 감각)
        answer3 = input("Q3. 계획을 세우는 것을 좋아하시나요? (y/n): ")
        if answer3.lower() == 'y':
            print("당신의 성격 유형은 ESTJ입니다!")
        else:
            print("당신의 성격 유형은 ESFP입니다!")
    else:
        # 직관형(외향, 직관)
        answer3 = input("Q3. 큰 그림을 보는 것을 좋아하시나요? (y/n): ")
        if answer3.lower() == 'y':
            print("당신의 성격 유형은 ENFP입니다!")
        else:
            print("당신의 성격 유형은 ENTJ입니다!")
                
else:
    # 내향형으로 진행
    print("내향형으로 분석 중...")
    answer2 = input("Q2. 구체적인 정보나 사실을 중요하게 생각하시나요? (y/n): ")
    
    if answer2.lower() == 'y':
        # 감각형(내향, 감각)
        answer3 = input("Q3. 일정을 엄격하게 관리하는 것을 좋아하시나요? (y/n): ")
        if answer3.lower() == 'y':
            print("당신의 성격 유형은 ISTJ입니다!")
        else:
            print("당신의 성격 유형은 ISFP입니다!")
    else:
        # 직관형(내향, 직관)
        answer3 = input("Q3. 논리적인 문제 해결을 좋아하시나요? (y/n): ")
        if answer3.lower() == 'y':
            print("당신의 성격 유형은 INTP입니다!")
        else:
            print("당신의 성격 유형은 INFJ입니다!")

---

# if 여러 개 vs. if-elif-else

1. if-elif-else

• 조건을 위에서부터 검사하다가
• 처음 True가 나오면 그 이후는 전부 무시

score = 85

if score >= 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 70:
    print("C")
else:
    print("F")

 

2. if 여러 번

• 각각 독립적으로 검사
• 여러 개가 동시에 실행될 수 있음

score = 85

if score >= 90:
    print("A")
if score >= 80:
    print("B")
if score >= 70:
    print("C")

---

# 조건부 표현식 (Conditional Expression)

• 조건의 참과 거짓에 따라 값을 선택하는 한 줄짜리 조건문
• 간단한 분기 로직을 간결하게 표현
• 다만 조건이 복잡하거나 여러 줄의 처리가 필요한 경우 일반적인 if문 사용이 가독성 좋음

# if~elif~else로 작성
age = int(input('나이를 입력하세요'))

if age > 19:
    print('성인입니다')
elif age > 14:
    print('청소년입니다')
elif age > 6:
    print('어린이입니다')
elif age > 0:
    print('유아입니다')
else:
    print('다시 입력해주세요')
print('입력한 나이: ', age)

# 조건부 표현식으로 작성
# 가독성👎
age = int(input('나이를 입력하세요'))
print('성인입니다') if age > 19 else print('청소년입니다') if age > 14 else print('어린이입니다') if age > 6 else print('유아입니다') if age > 0 else print('다시 입력해주세요')

---

# 구조적 패턴 매칭 match-case

• if-elif-else 구문을 좀 더 간결하게 만든 분기문
• Java/C의 switch-case와 비슷하지만 훨씬 더 강력한 기능

match 값:
    case 패턴1:
        실행할 코드1
    case 패턴2:
        실행할 코드2
    case _:
        기본 실행 코드 (default)

month = int(input("월을 입력하세요 (1~12): "))

match month:
    case 1 | 3 | 5 | 7 | 8 | 10 | 12:
        print(f"{month}월은 31일까지 있습니다.")
    case 4 | 6 | 9 | 11:
        print(f"{month}월은 30일까지 있습니다.")
    case 2:
        print("2월은 28일 또는 윤년이면 29일까지 있습니다.")
    case _:
        print("잘못된 월입니다. 1~12 사이의 숫자를 입력해주세요.")

 

• 리스트와 튜플은 서로 다른 타입이지만, 구조적 패턴 매칭에서는 "시퀀스 패턴"으로 인해 비슷하게 매칭 가능
• 타입을 명확히 구분하려면 list(), tuple() 패턴을 사용

# scores = [95, 88, 76]     # 리스트
# scores = (95, 88, 76)       # 튜플 (아래 설명 때문에 첫번째 case문에 걸림. 만약 요소 개수가 다르면 건너 뜀)
scores = {"국어":95, "영어":88, "수학":76}        # 딕셔너리 (딕셔너리는 딕셔너리형으로)

match scores:
    case [korean, english, math]:       # 리스트
        print(f"1. 국어: {korean}, 영어: {english}, 수학: {math}")
    case (korean, _, math):     # 튜플
        print(f"2. 국어: {korean}, 수학: {math}")
    case {"국어": korean, "영어": english, "수학": math}:       # 딕셔너리
        print(f"3. 국어: {korean}, 영어: {english}, 수학: {math}")

# scores = {"국어":95, "영어":88, "수학":76}
scores = [95, 88, 76]
# scores = (95, 88, 76)

match scores:
    # 타입 먼저 구분
    case list():
        match scores:
            case [korean, english, math]:
                print(f"리스트 → 국어: {korean}, 영어: {english}, 수학: {math}")

    case tuple():
        match scores:
            case (korean, _, math):
                print(f"튜플 → 국어: {korean}, 수학: {math}")

    case dict():
        match scores:
            case {"국어": korean, "영어": english, "수학": math}:
                print(f"딕셔너리 → 국어: {korean}, 영어: {english}, 수학: {math}")

---

# 반복문

• 특정 코드를 여러 번 실행하기 위해 사용하는 제어문
• 대표적으로 for, while문
• for문은 iterable(리스트, 문자열 등) 객체의 요소를 순차적으로 반복할 때 사용
• while문은 조건이 True인 동안 계속 실행
• 또한 break, continue를 통해 반복 흐름 제어 가능
• 들여쓰기를 통해 반복 범위 구분

---

# while문

• 주어진 조건이 참인 동안 반복적으로 코드 블록을 실행
• 조건이 거짓이 되면 반복을 멈춤
• 조건은 결과가 참 또는 거짓이 될 수 있는 표현식
• 조건이 참일 때 코드 블록이 실행된 후 다시 조건을 검사. 이 과정을 조건이 거짓일 될 때까지 반복

while 조건:
	조건이 참인 동안 실행될 코드

while True:
    print('Hello Python') # 무한루프

while False:
    print('Hello Python')

i = 1

while i <= 5:
    print('Hello Python')
    i += 1

# 1부터 10까지의 총합
i = 1
sum = 0

while i <= 10:
    sum += i
    i += 1

print(f'1부터 10까지의 합: {sum}')

# 1부터 100까지 짝수의 합
i = 1
sum = 0

while i <= 100:
    if i % 2 == 0:
        sum += i
    i += 1

print(f'1부터 100까지의 짝수의 합: {sum}')

---

# for문

• 시퀀스(리스트, 튜플, 문자열 등) 각 항목에 대해 반복 작업 수행
• 지정된 범위 내에서 반복할 때 사용
• 반복할 요소들이 미리 정해져 있는 경우 유용
• 요소: 반복할 시퀀스의 각 항목이 for 문의 실행 도중에 할당되는 변수

for 요소 in 시퀀스:
    요소에 대한 작업 수행

for s in "Hello":
	print(s)

list1 = [10, 20, 30, 40]

for li in list1:
    print(li)

# score 리스트에 저장된 점수가 60점 이상인 학생이 몇명인지 확인
score = [90, 30, 50, 60, 80, 70, 100, 40, 20, 10]
count = 0

for i in score:
    if i >= 60:
        count += 1

print(f'60점 이상인 학생의 수는 {count}명입니다')

# 리스트에서 길이가 5 이상인 문자열만 출력
words = ["apple", "hi", "banana", "go", "mango"]

for word in words:
    if (length := len(word)) >= 5:
        print(f"{word} (길이: {length})")

---

 

 

* 튜플을 은근히 많이 사용함

* 딕셔너리는 내부적으로 set으로 구성. 즉 key에 중복 값이 들어온다고 에러나는 것이 아니라 원래 있던 값을 변경하도록 함

* 딕셔너리 많이 사용하니까 잘 익히기

* if-else문 : 조건의 범위가 존재할 때 (ex. 성적 90~100, 80~89 ...)

* match-case문 : 값이 딱 일치하는 것이 존재할 때 (ex. 1~12월 운세)

* AI는 패턴 분석에서 왔다고 볼 수 있음. 패턴 분석으로 어떤 것을 유추해내는 것.