python

'''

* 리스트의 탐색과 정렬

1. index(): 리스트에서 특정 값이 저장된 인덱스를 반환합니다.

2. count(): 리스트 내부에 저장된 특정 요소의 개수를 반환합ㄴ디ㅏ.

3. sort(): 리스트를 오름차 정렬합니다.

4. reverse(): 리스트 데이터를 역순으로 배치합니다.

'''

points = [99, 14, 78, 43, 19, 100, 44, 55, 20]

perfect = points.count(100)

print(f'만점자는 {perfect}명입니다.')

print(f'87점을 획득한 학생은 {points.index(43) + 1}번째입니다.')

# 내장함수 len(), max(), min()

print(f'학생 수는 {len(points)}명입니다.')

print(f'최고 점수는 {max(points)}점입니다.')

print(f'최고 점수는 {min(points)}점입니다.')

# 오름차 정렬 sort()

print('-' * 40)

print(points)

points.sort()

points.reverse()

print(points)

# 리스트 내의 요소의 유무를 검사하려면 in 키워드를 사용합니다.

food_menu = ['김밥', '닭강정', '라면', '김말이']

name = input('음식명을 입력하세요: ')

if name in food_menu:

    print(f'{name} 음식이 주문되었습니다.')

else:

    print(f'{name}은(는) 없는 음식입니다.')

 

 

'''

* 리스트 내부 요소 삭제

1. remove(): 삭제할 값을 직접 지정하여 삭제

2. 내장함수 del(): 삭제할 요소의 인덱스를 통해 삭제

3. clear(): 리스트 내부 요소 전체 삭제

'''

points = [88, 92, 34, 67, 89]

points.remive(92)

print(points)

del(points[2])

print(points)

points.clear()

print(points)

 

# 리스트를 이용한 간단한 연락처 관리 프로그램

# namelist에 이름, phonelist에 전화번호를 저장해서

# 이름과 전화번호 리스트의 인덱스가 동일하게 증가할 수 있도록 조작합니다.

namelist = []

phonelist = []

while True:

    print('\n---------------- 연락처 관리 프로그램 ----------------')

    print('1. 연락처 등록')

    print('2. 연락처 검색')

    print('3. 연락처 삭제')

    print('4. 모든 연락처 조회')

    print('5. 프로그램 종료')

    print('n------------------------------------------------------')

    menu = int(input('메뉴를 입력하세요: '))

if menu == 1:

        print('-' * 20)

        print('연락처 등록을 시작합니다.')

        name = input('이름: ')

        phone = input('전화번호: ')

        # 입력받은 이름과 전화번호 데이터를 각각의 리스트에 추가하세요.

        # 추가 완료 시 "XXX님 연락처 저장 완료!" 를 출력하세요.

        namelist.append(name)

        phonelist.append(phone)

        print(f'{name}님 연락처 저장 완료했습니다.')

    elif menu == 2:

        name = input('찾을 이름을 입력하세요: ')

        # 입력한 이름이 리스트 내부에서 발견된다면 해당 이름을 통해

        # 인덱스 번호를 추출하여 인덱스를 통해 리스트의 전화번호를 얻어옵니다.

        # 출력예시: "홍길동의 전화번호는 010-1234-5678입니다."

        if name in namelist:

            idx = namelist.index(name)

            print(f'{name}님 연락처는 {phonelist[idx]}입니다.')

        else:

            print(f'{name}님은 연락처 목록에 없습니다.')

    elif menu == 3:

        # 이름을 입력받아서 해당 이름과 전화번호를 동시에 삭제해 주세요.

        # 이름이 없다면 없다고도 얘기 해 주세요.

        name = input('삭제할 이름을 입력하세요.')

        if name in namelist:

            idx = namelist.index(name)

            del namelist[idx]

            del phonelist[idx]

            print(f'{name}님의 정보가 정상적으로 삭제되었습니다.')

        else:

            print(f'{name}님은 연락처 목록에 없습니다.')

    elif menu == 4:

        # for문을 통해 리스트 내부의 모든 인덱스에 접근하여 모든 이름과

        # 연락처 정보를 출력하는 코드를 작성합니다.

        # 홍길동 : 010-1234-5678

        # 김철수 : 010-5678-1234...

        # for name in namelist:

        #    print(f'{name} : {phonelist[phonelist.index(name)]}')

        for idx in range(len(namelist)):

            print(f'{namelist[idx]} : {phonelist[idx]}')

    elif menu == 5:

        print('프로그램을 종료합니다.')

        break # while True break

   

    else:

        print('메뉴를 다시 입력해 주세요.')

 

'''

* 튜플 (tuple)

- 튜플은 값의 집합이라는 측면에서 리스트와 유사하지만

 값을 한 번 저장한 후에는 내부 요소의 편집이 불가능합니다.

- 튜플은 상수리스트라고도 부르며 ()를 사용하여 표현합니다.

- 튜플도 문자열과 리스트와 마찬가지로 시퀀스 자료형입니다.

'''

points = (87, 97, 23, 45, 67)

print(type(points))

sum = 0

for p in points:

    sum += p

print(f'총점: {sum}점, 평균: {sum/len(points)}점')

# 튜플을 만들 때는 ()를 생략할 수 있습니다.

print('-' * 30)

tu = 1, 3, 5, 7, 9

print(type(tu))

# 튜플을 리스트와 마찬가지로 unpackaging이 가능합니다.

n1, n2, n3, n4, n5 = tu

print(n1, n2, n3, n4, n5)

# 튜플로 가능한 문법 (내부 요소값을 바꾸지 않는 행위)

print(tu[2])

print(tu[1:3])

print(tu + (10, 11))

print(tu * 2)

print('원분 튜플의 값: ', tu)

# 튜플로 불가능한 문법 (내부 요소값을 바꾸는 행위)

# tu[2] = 10 (x)

# tu.append(10) (x)

# del(tu[0]) (x)

# tuple이 지원하는 메서드는 index, count 뿐입니다.

'''

* 튜플을 사용하는 이유

- 튜플로 가능한 일은 리스트로도 모두 가능합니다.

 리스트는 튜플에 비해 요소를 편집하는 행위도 가능합니다.

- 결국, 리스트는 튜플의 기능을 모두 포괄하는 더 큰 범위의

타입이지만, 튜플을 사용해야 하는 이유는 존재합니다.

1. 비용의 차이: 리스트는 변경의 가능성을 항상 대비해야 하기 때문에

더 많은 메모리 공간을 차지하고, 속도도 그만큼 느립니다.

이에 비해, 튜플은 값의 집합만 표현할 뿐, 바뀔 일이 없으므로

내부 구조가 더 단순하고 속도도 더 빠릅니다.

2. 데이터 안정성: 리스트는 실수로 내부 데이터가 의도치 않게

 바뀔 위험이 있지만, 튜플은 한 번 정해지면 바뀔 수가 없기 때문에

 실수할 위험이 적습니다.

데이터베이스나 네트워크에서 얻은 데이터는 단순히 참조만 하면

될 뿐, 편집할 일이 많지 않습니다.

그렇기 때문에 리스트로 관리하는 것보다 튜플로 처리하는 것이

안전합니다.

3. 리스트와 상호 변경이 자유로움: 리스트와 튜플은

값 변경 가능성 여부만 다를 뿐, 구조가 상당히 유사합니다.

리스트를 튜플로 변환할 때는 내장함수 list()를 사용하고,

튜플을 리스트로 변환할 때는 내장함수 tuple()을 사용합니다.

'''

print('-' * 30)

p = [2, 3, 4, 5, 6]

p = tuple(p)

# p[1] = 3 (x) 튜플에서는 값의 변경이 불가능

p = list(p)

p[3] = 100

p.append(17)

print(p)

'''

* 사전 (Dictionary)

- 사전은 키(key)와 값(value)의 쌍을 저장하는 대용량의 자료 구조

- 사전은 Map이라고도 부르며 연관배열이라고도 부릅니다.

- 사전을 정의하는 기호는 {}이고, 괄호 안에 데이터를 key:value 형태로 나열하여 저장합니다.

'''

students = {'멍멍이':'김철수', '야옹이':'박영희', '짹짹이':'홍길동'}

print(type(students))

'''

- 사전에 사용되는 key 값은 중복값을 가질 수 없고, 변경도 안됩니다.

- 반면에 value값은 중복을 허용하고 데이터를 자유롭게 편집할 수도 있습니다.

'''

print(students['멍멍이'])

# print(students['메뚜기']) (x)

# in 키워드를 사용하여 key의 존재 유무를 파악할 수 있습니다.

print('멍멍이' in students)

 

'''

추가, 삭제, 수정 등의 편집을 자유롭게 진행할 수 있습니다.

데이터 추가하기(append처럼 동작합니다.)

사전 내부에 존재하지 않는 키(key)를 사용하여 데이터를 대입하면 key:value 쌍으로 사전에 저장됩니다.

'''

eng_kor = {'student':'학생', 'apple':'사과', 'book':'책'}

eng_kor['banana'] = '바나나' # 없는 키를 이용한 대입

print(eng_kor)

'''

* 사전에 데이터를 수정하기

- 사전 내부에 이미 존재하는 key를 사용하여 새로운 데이터를 대입하면

해당 key값에 맵핑되어 있는 value가 수정됩니다.

'''

eng_kor['book'] = '서적'

print(eng_kor)

'''

- 사전의 key 목록과 value 목록을 따로 추출하고 싶다면 사전의 메서드 keys(), values()를 사용합니다.

'''

print('-' * 30)

print(eng_kor.keys())

print(eng_kor.values())

# 사전의 반복문 처리

# for ~ in 뒤에 사전 데이터를 적으면 key만 반복 순회합니다.

for k in eng_kor:

    print(f'{k} : {eng_kor[k]}')

'''

* 사전의 데이터 삭제 (내장함수 del 사용)

del(사전이름[key])

key를 입력하면 같이 맵핑된 value도 함께 삭제됩니다.

'''

del(eng_kor['student'])

print(eng_kor)

# 빈 사전 만들기

 

'''

* 사전을 사용한 음식점 메뉴판 관리 프로그램.

- key: 음식명, value: 음식의 가격

'''

foods = {}

while True:

    print("\n\n====== 음식점 메뉴 관리 프로그램 ======")

    print("# 1. 신규 메뉴 등록하기")

    print("# 2. 메뉴판 전체보기")

    print("# 3. 프로그램 종료")

    print("===========================================")

    menu = int(input("# 메뉴 입력: "))

    if menu == 1:

        '''

        1. 메뉴명을 입력받아 해당 메뉴가 사전에 이미 존재한다면

         이미 등록된 메뉴라고 얘기해 주세요.

        2. 사전에 존재하지 않는 메뉴라면 가격을 입력받아

        key:value 쌍으로 맵핑하여 사전에 저장하세요.

        '''

        name = input('메뉴명: ')

        if name not in foods:

            price = input('가격: ')

            foods[name] = price

            print(f'신규 메뉴 {name}이(가) 등록되었습니다.')

        else:

            print(f'{name}은(는) 이미 등록된 메뉴입니다.')

       

    elif menu == 2:

        '''

        - 만약 2번을 선택했는데, 메뉴가 하나도 등록되어 있지 않다면

        먼저 등록하라고 메인 메뉴로 돌려보내 주세요.

        - 사전에 등록된 메뉴명과 가격을 전부 출력해 주세요.

        ex) 짜장면 : 4000원

            탕수육 : 18000원

            짬뽕 : 7000원 ...

        -----------------------------------------

        메뉴판 전체 출력 후 메뉴를 새롭게 입력받아 주세요.

        ex (1. 수정 | 2. 삭제 | 3. 나가기)

        새로운 메뉴를 입력받아서 수정과 삭제를 진행 해 주세요.

        # 수정 -> 가격을 변경할 메뉴의 이름을 먼저 입력받고

        해당 이름이 사전에 존재한다면 수정할 가격을 새롭게 입력받고

        수정을 진행 해 주세요. 이름이 없다면 없다고 출력.

        # 삭제 -> 삭제할 메뉴명을 입력받아서 삭제를 진행.

         이름이 없으면 없다고 출력.

        # 나가기 -> 메인메뉴로 나가시면 됩니다.

        '''

        if len(foods) != 0:

            print('\n================ 메뉴판 =================')

            for m in foods:

                print(f'{m} : {foods[m]}원')

                print('==================================')

                print('1. 수정 | 2. 삭제 | 3. 나가기')

                select = input('> ')

                if select == '1':

                    print('가격을 변경할 메뉴를 먼저 입력해 주세요.')

                    name = input('=> ')

                    if name in foods:

                        new_price = input('변경할 가격: ')

                        foods[name] = new_price

                        print(f'{name}의 가격이 {new_price}원으로 변경되었습니다.')

                    else:

                        print(f'{name}은(는) 등록된 음식이 아닙니다.')

                elif select == '2':

                    print('삭제할 음식명을 입력하세요.')

                    name = input('=> ')

                    if name in foods:

                        del(foods[name])

                        print(f'{name}이(가) 삭제되었습니다.')

                    else:

                        print(f'{name}은(는) 등록된 음식이 아닙니다.')

                elif select == '3':

                    continue # 3번은 아예 작성하지 않아도 어차피 처음으로 이동합니다.

            else:

                print('등록된 메뉴가 없습니다. 메뉴부터 먼저 등록해 주세요.')

    elif menu == 3:

        '''

        ("# 프로그램을 종료하시겠습니까? [Y / N]")

        프로그램 종료 여부를 한번 더 물어봐 주세요.

        만약 y 이외의 값이 들어온다면 종료 의지가 없다고 판단하고

        종료를 취소하도록 하겠습니다.

        '''

       

        print('# 프로그램을 종료하시겠습니까? [Y / N]')

        quit = input('=> ').lower()

        if quit == 'y':

            print('프로그램을 종료합니다.')

            break

        else:

            print('종료를 취소합니다.')

     

    else:

        print("메뉴를 잘못 입력하셨습니다.")

    print("\n메뉴를 보시려면 Enter키를 입력하세요...")

    input()

 

'''

*집합 (set)

- 집합은 여러 값들의 모임이며, 저장순서가 보장되지 않고

 중복값의 저장을 허용하지 않습니다.

- 집합은 사전과 마찬가지로 {}로 표현하지만, key:value

 쌍이 아닌 데이터가 하나씩 들어간다는 점이 사전과는 다릅니다.

- set()함수는 공집합을 만들기도 하며, 다른 컬렉션 자료를

 집합 형태로 변환할 수도 있습니다.

'''

# [] - list(), tuple(), {}-dict(), set()

names = {'홍길동', '김철수', '박영희', '고길동', '홍길동'}

# 내장 함수 set()

s = set()

print(type(s))

print(s)

s1 = 'programming'

print(set(s1))

print(list(s1))

print(tuple(s1))

'''

- 집합은 변경 가능한 자료형이기 때문에 언제든지 데이터를 편집할 수 있습니다.

-집합에 요소를 추가할 때는 add(), 제거할 때는 remove() 사용합니다.

'''

print('-' * 30)

asia = {'korea', 'china', 'japan'}

print(asia)

asia.add('thailand')

asia.add('china')

asia.remove('japan')

print(asia)

# 집합의 결합은 update() 메서드를 사용합니다. (덧셈 연산 x)

asia2 = {'singapore', 'indonesia', 'korea'}

# print(asia + asia2) (x)

asia.update(asia2)

print(asia)

 

'''

* 집합의 연산

1. 합집합(|): 두 집합의 전체 요소들의 모음(중복 제거)

2. 교집합(&): 두 집합의 중복을 배제한 공통 요소들의 모음.

3. 차집합(-): 왼쪽 집합에서 오른쪽 집합 요소를 제거

4. 배타적 차집합(^): 합집합 - 교집합

5. 부분집합 (<=): 왼쪽 집합이 오른쪽 집합의 부분집합인지를 검사.

'''

A = {2, 4, 6, 8, 10, 12}

B = {3, 6, 9, 12, 15}

print('교집합: ' , A & B)

print('합집합: ' , A | B)

print('차집합(A - B): ' , A - B)

print('차집합(B - A): ' , B - A)

print('배타적 차집합: ' , A ^ B)

C = {4, 8, 12}

 

 

'''

- 서로 다른 정수가 담긴 두 개의 리스트를 비교하여

li 안에 있는 정수가 li2에도 담겨 있다면 그 정수를 배제하세요.

서로 겹치지 않는 정수만 담긴 새로운 리스트를 생성해 보세요.

'''

li = [1, 2, 3, 4, 5, 6, 7]

li2 = [1, 3, 8, 4, 5, 7, 101]

li3 = []

result = set(li) ^ set(li2)

print(result)

'''

for n in li:

    if n not in li2:

        li3.append(n)

for n in li2:

    if n not in li:

        li3.append(n)

print(li3)

'''