스터디노트(자료구조 5~9)

zoe·2023년 3월 20일
data structure
0

리스트 나머지 기능들

  • 리스트를 곱셈 연산하면 아이템이 반복된다
  • index(아이템) : 리스트의 item의 인덱스 반환
  • count() : 리스트의 특정 아이템의 개수 반환
  • del : 리스트의 특정 아이템 삭제, 슬라이싱 같이 이용 가능
students = ['홍길동', '박찬호', '이용규']
print(students*3)

studentsMul = students * 3
print('studentsMul : {}' .format(studentsMul))
numbers = [2, 50, 0.12, 1, 9]
print('numbers : {}' .format(numbers))

numbersMul = numbers*2
print('numbersMul : {}' .format(numbersMul))

students = ['홍길동', '강호동', '박찬호', '이용규', '박승철','강호동', '김지은']

print('students : {}' .format(students))

searchIdx = students.index('강호동')
print('searchIdx : {}' .format(searchIdx))

searchIdx = students.index('강호동', 2, 6) #idx = 2 - 6 사이의 아이템 찾기 ★
print('searchIdx : {}' .format(searchIdx))
numbers = [2, 50, 0.12, 1, 9]
searchIdx = numbers.index(0.12)
print('searchIdx : {}' .format(searchIdx))

1부터 10까지의 정수가 중복되지 않고 섞여 있을 때 행운의 숫자 7의 위치를 찾기

# 1부터 10까지의 정수가 중복되지 않고 섞여 있을 때 행운의 숫자 7의 위치를 찾기

import random

sampleList = random.sample(range(1, 11),10) # 1~ 10까지의 10개의 난수 추출 ★

selectIdx = int(input('숫자 7의 위치 입력 : '))
searchIdx = sampleList.index(7)

if searchIdx == selectIdx:
    print('빙고!')
else:
    print('ㅜㅜ')

print('sampleList : {}' .format(sampleList))
print('searchIdx : {}' .format(searchIdx))
students = ['홍길동', '강호동', '박찬호', '이용규', '박승철','강호동', '김지은']

searchCnt = students.count('홍길동')
print(f'searchCnt : {searchCnt}')

searchCnt = students.count('강호동')
print(f'searchCnt : {searchCnt}')

searchCnt = students.count('김아무개')
print(f'searchCnt : {searchCnt}')

하루 동안 헌혈을 진행한 후 혈액형 별 개수를 파악하는 프로그램을 생성

# 하루 동안 헌혈을 진행한 후 혈액형 별 개수를 파악하는 프로그램을 생성

import random

types = ['A', 'B', 'AB', 'O']
todayData = []
typeCnt = []

for i in range(100):
    type = types[random.randrange(len(types))] # ★
    todayData.append(type)

print('todayData : {}' .format(todayData))
print('todayData length : {}' .format(len(todayData)))

for type in types:
    print(f'{type}형 \t : {todayData.count(type)}개')

튜플(Tuple)

  • 튜플(Tuple) : 리스트(List)와 비슷하지만 아이템 변경이 불가능
  • '()'를 이용해서 선언하고, 데이터 구분은 ','를 이용
    - 숫자, 문자(열), 논리형 등 모든 기본 데이터 같이 저장 가능
    - 튜플에 또 다른 컨테이너 자료형 데이터 저장 가능
students = ('홍길동', '박찬호', '이용규', '박승철', '김지은')
print('student : {}' .format(students))
print('students type : {}' .format(type(students)))

studentsList = ['홍길동', '박찬호', '이용규', '박승철', '김지은']
print('student : {}' .format(studentsList))

numbers = (10, 20, 30, 40, 50, 60, 70)
print('numbers : {}' .format(numbers))
print('numbers type : {}' .format(type(numbers)))

strs = (3.14, '십', 20, 'one', '3.141592')

datas = (10, 20, 30, (40, 50, 60))

가족 이름을 튜플에 저장하고 출력

#  가족 이름을 튜플에 저장하고 출력

myFamilyNames = ('홍아빠','홍엄마','홍길동','홍동생')
print('myFamilyNames : {}' .format(myFamilyNames))

#myFamilyNames[2] = '홍홍홍'

오늘 일정을 튜플에 저장하고 출력

# 오늘 일정을 튜플에 저장하고 출력

todaySchedule = ('10시 - 업무회의',
                '12시 - 친구와의 점심약속',
                '3시 - 자료정리',
                '6시 - 운동', '9시 - TV시청')
print('todaySchedule : {}' .format(todaySchedule))

튜플 아이템 조회

  • 튜플도 리스트와 마찬가지로 아이템에 자동으로 부여되는 번호표 존재
  • 튜플 아이템도 인덱스를 이용해서 조회 가능
students = ('홍길동', '박찬호', '이용규', '박승철', '김지은')

print('students[0] : {}' .format(students[0]))
print('students[1] : {}' .format(students[1]))
print('students[2] : {}' .format(students[2]))
print('students[3] : {}' .format(students[3]))
print('students[4] : {}' .format(students[4]))

#print('students[5] : {}' .format(students[5]))
numbers = (10, 20, 30, 40, 50)
print('numbers[0] : {}' .format(numbers[0]))
print('numbers[1] : {}' .format(numbers[1]))
print('numbers[2] : {}' .format(numbers[2]))
print('numbers[3] : {}' .format(numbers[3]))
print('numbers[4] : {}' .format(numbers[4]))

5명의 학생 이름을 튜플에 저장하고 인덱스가 홀수인 학생과 짝수(0포함)인 학생을 구분해서 인덱스와 학생 이름을 출력, 위의 출력 방법을 for문으로 변경

students = ('김성예', '신경도', '박기준', '최승철', '황동석')

print('--- 인덱스가 짝수인 학생 ---')
print('students[0] : {}' .format(students[0]))
print('students[2] : {}' .format(students[2]))
print('students[4] : {}' .format(students[4]))
print('--- 인덱스가 홀수인 학생 ---')
print('students[1] : {}' .format(students[1]))
print('students[3] : {}' .format(students[3]))
print()

for i in range(len(students)):
    if i % 2 == 0:
        print('인덱스 짝수 : students[{}] : {}' .format(i, students[i]))
    else:
        print('인덱스 홀수 : students[{}] : {}'.format(i, students[i]))

in과 not in 키워드

  • in, not in : 아이템의 존재 유/무 확인
    - 문자열에서도 사용 가능
studentsTuple = ('홍길동', '박찬호', '이용규', '박승철', '김지은')

searchName = input('학생 이름 입력 : ')
if searchName in studentsTuple:
    print('{} 학생은 우리반 학생입니다.' .format(searchName))
else:
    print('{} 학생은 우리반 학생이 아닙니다.' .format(searchName))
pythonStr = '파이썬(영어: Python)은 1991년 네덜란드계 소프트웨어 엔지니어인 귀도 반 로섬이' \
            ' 발표한 고급 프로그래밍 언어로, 플랫폼에 독립적이며 인터프리터식, ' \
            '객체지향적, 동적 타이핑(dynamically typed) 대화형 언어이다. ' \
            '파이썬이라는 이름은 귀도가 좋아하는 코미디인〈Monty Python\'s Flying Circus〉에서' \
            ' 따온 것이다. '

print('{} : {}' .format('Python', 'Python' in pythonStr))
print('{} : {}' .format('python', 'python' in pythonStr))

print('{} : {}' .format('파이썬', '파이썬' in pythonStr))
print('{} : {}' .format('파이선', '파이선' in pythonStr))

print('{} : {}' .format('귀도', '귀도' in pythonStr))
print('{} : {}' .format('객체지향적', '객체지향적' in pythonStr))

컴퓨터가 1부터 10까지 5개의 난수를 생성한 후, 사용자가 입력한 숫자가 있는지 또는 없는지를 출력하는 프로그램을 생성

# 컴퓨터가 1부터 10까지 5개의 난수를 생성한 후, 사용자가 입력한 숫자가 있는지
# 또는 없는지를 출력하는 프로그램을 생성

import random

randomNumbers = random.sample(range(1, 11), 5)

userNumber = int(input('숫자 입력(확률 50%) : '))
if userNumber in randomNumbers:
    print('빙고!')
else:
    print('다음 기회에~')

print('randomNumbers : {}' .format(randomNumbers))
print('userNumber : {}' .format(userNumber))

문장에서 비속어가 있는지 알아내는 프로그램을 생성

# 문장에서 비속어가 있는지 알아내는 프로그램을 생성

wrongWord = ['쩔었다','짭새','꼽사리','먹튀','지린','쪼개다','뒷담 까다']
sentence = '짭새 등장에 강도들은 모두 쩔었다. 그리고 강도 들은 지린 듯 도망갔다.'

for word in wrongWord: # ★
    if word in sentence:
        print('비속어 : {}' .format(word))

튜플 길이

  • 튜플 길이 : 리스트와 마찬가지로, 튜플에 저장된 아이템의 개수
  • len()과 반복문을 이용하면 튜플의 아이템 조회 가능
students = ('홍길동', '박찬호', '이용규', '박승철', '김지은')
sLength = len(students)
print('length of students : {}' .format(sLength))
for i in range(len(students)):
    print('i : {}' .format(i))
    print('students[{}] : {}' .format(i, students[i]))
print()
n = 0
sLength = len(students)
while n < sLength:
    print('i : {}' .format(n))
    print('students[{}] : {}' .format(n, students[n]))
    n += 1
print()

for s in students:
    print('student : {}' .format(s))
print()

좋아하는 운동 종목을 튜플에 저장하고 반복문을 이용해서 출력

# 좋아하는 운동 종목을 튜플에 저장하고 반복문을 이용해서 출력

myFavoriteSports = ('수영', '배구', '야구', '조깅')

for i in range(len(myFavoriteSports)):
    print('myFavoriteSports[{}] : {}' .format(i, myFavoriteSports[i]))
print()

for f in myFavoriteSports:
    print('myFavoriteSports : {}' .format(f))
print()

튜플 길이

  • +를 이용하여 두 개의 튜플 결합 가능
    - 리스트에 사용할 수 있는 extend() 함수는 튜플에서 사용 불가
studentTuple1 = ('홍길동', '박찬호', '이용규')
studentTuple2 = ('박승철', '김지은', '강호동')
print('studentTuple1 : {}' .format(studentTuple1))
print('studentTuple2 : {}' .format(studentTuple2))


studentTuple3 = studentTuple1 + studentTuple2
print('studentTuple3 : {}' .format(studentTuple3))


#studentTuple4 = studentTuple1.extend(studentTuple2)

💡 튜플을 이용해서 나와 친구가 좋아는 번호를 합치되 번호가 중복되지 않게 하는 프로그램을 생성

# 튜플을 이용해서 나와 친구가 좋아는 번호를 합치되 번호가 중복되지 않게 하는 프로그램을 생성

myFavoriteNumbers = (1, 3, 5, 6, 7)
friendFavoriteNumbers = (2, 3, 5, 8, 10)

print('myFavoriteNumbers : {}' .format(myFavoriteNumbers))
print('friendFavoriteNumbers : {}' .format(friendFavoriteNumbers))

for number in friendFavoriteNumbers:
    if number not in myFavoriteNumbers:
        myFavoriteNumbers = myFavoriteNumbers + (number,) # (값,) :  더하려는 값을 튜플 형태로 만들어주어야 함 ★★★

print('myFavoriteNumbers : {}' .format(myFavoriteNumbers))

튜플 슬라이싱

  • 리스트와 마찬가지로 [n:m]을 이용하면 원하는 아이템 추출 가능
  • 💡 튜플은 슬라이싱을 이용하여 아이템을 변경할 수 없다
  • 리스트에 튜플 아이템으로 변경 가능
  • slice() : 아이템 슬라이싱 가능
students = ('홍길동', '박찬호', '이용규','강호동', '박승철', '김지은')

print('students : {}' .format(students))
print('students[2:4] : {}' .format(students[2:4]))
print('students[:4] : {}' .format(students[:4]))
print('students[2:] : {}' .format(students[2:]))
print('students[2:-2] : {}' .format(students[2:-2]))
print('students[-5:-2] : {}' .format(students[-5:-2]))
numbers = (2, 50, 0.12, 1, 9, 7, 17, 35, 100, 3.14)
print('numbers : {}' .format(numbers))
print('numbers : {}' .format(numbers[2:4]))
print('numbers : {}' .format(numbers[-5:-2]))
print('numbers : {}' .format(numbers[2:-2]))
print('numbers : {}' .format(numbers[2:-2:2]))
print('numbers : {}' .format(numbers[:-2:2]))
print('numbers : {}' .format(numbers[::2]))
students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은']
students[1:4] = ('park chanho', 'lee younggyu', 'gang hodong')
print('students : {}' .format(students))
print(type(students)) # 타입은 리스트
students = ('홍길동', '박찬호', '이용규','강호동', '박승철', '김지은')
print('students : {}' .format(students))

print('students : {}' .format(students[slice(2, 4)]))
print('students : {}' .format(students[slice(4)]))
print('students : {}' .format(students[slice(2, len(students))]))
print('students : {}' .format(students[slice(2, len(students)-2)]))
print('students : {}' .format(students[slice(len(students)-5,len(students)-2)]))

리스트와 튜플

  • 튜플은 리스트와 달리 아이템 추가, 변경, 삭제가 불가
  • 튜플은 선언 시 괄호 생략 가능
  • 리스트와 튜플은 자료형 변환 가능
students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은']

students.append('강호동')
print('student : {}' .format(students))
students[3] = '유재석'
print('students[3] = {}' .format(students[3]))
students.pop()
print('student : {}' .format(students))

students = ('홍길동', '박찬호', '이용규','강호동', '박승철', '김지은')

# students.append('강호동')
# print('student : {}' .format(students))
# students[3] = '유재석'
# print('students[3] = {}' .format(students[3]))
# students.pop()
# print('student : {}' .format(students))
students = ['홍길동', '박찬호', '이용규','강호동']
print(students)
print(type(students))

students = ('홍길동', '박찬호', '이용규','강호동')
print(students)
print(type(students))

students = '홍길동', '박찬호', '이용규','강호동'
print(students)
print(type(students))
students = ['홍길동', '박찬호', '이용규','강호동']
print(students)
print(type(students))

students = tuple(students)
print(students)
print(type(students))

students = list(students)
print(students)
print(type(students))

튜플을 이용한 점수표에서 최저 및 최고 점수를 삭제한 후 총점과 평균을 출력

playerScore = (9.5, 8.9, 9.2, 9.8, 8.8, 9.0)
print('playerScore : {}' .format(playerScore))
print(type(playerScore))

playerScore = list(playerScore)
print(type(playerScore))
print('playerScore : {}' .format(playerScore))
playerScore.sort()
playerScore.pop(0)
playerScore.pop(len(playerScore)-1)
playerScore = tuple(playerScore)
print('playerScore : {}' .format(playerScore))
print(type(playerScore))

sum = 0
avg = 0
for score in playerScore:
    sum += score
print('총점 : {}' .format(round(sum,2)))
avg = sum / len(playerScore)
print('총점 : {}' .format(round(avg,2)))

튜플 아이템 정렬

  • 튜플은 수정이 불가하여 리스트로 변환 후 정렬해야 한다
  • sort() 함수를 이용하여 아이템 정렬
    - list() → sort(reverse = True) → tuple() : 내림차순 정렬
  • sorted() : 튜플도 정렬 가능, 리스트 자료형 반환
students = ('홍길동', '박찬호', '이용규','강호동', '박승철', '김지은')

print('students type : {}' .format(type(students)))
print('students : {}' .format(students))

students = list(students)
students.sort()
print('students type : {}' .format(type(students)))
print('students : {}' .format(students))

students = tuple(students)
print('students type : {}' .format(type(students)))
print('students : {}' .format(students))
numbers = list(numbers)
numbers.sort()
print('numbers type : {}' .format(type(numbers)))
print('numbers : {}' .format(numbers))

numbers = tuple(numbers)
print('numbers type : {}' .format(type(numbers)))
print('numbers : {}' .format(numbers))
students = ('홍길동', '박찬호', '이용규','강호동', '박승철', '김지은')
sortedStudents = sorted(students) # ★
print('sortedStudents type : {}' .format(type(sortedStudents)))
print('sortedStudents : {}' .format(sortedStudents))

튜플과 for문

  • for문을 이용하면 튜플의 아이템 자동 참조 가능
cars = '그렌저', '소나타', '말리부', '카니발', '쏘렌토'

for i in range(len(cars)):
    print(cars[i])
print()

for car in cars:
    print(car)
print()
studentCnt = (1, 19), (2, 20), (3, 22), (4, 18), (5, 21)

for classNo, cnt in studentCnt:
    print('{}학급 학생 수 : {}' .format(classNo, cnt))
print()

for i in range(len(studentCnt)):
    print('{}학급 학생 수 : {}'.format(studentCnt[i][0], studentCnt[i][1]))

아래 표와 튜플을 이용해서 학급별 학생 수와 전체 학생 수 그리고 평균 학생수를 출력

# 아래 표와 튜플을 이용해서 학급별 학생 수와 전체 학생 수 그리고 평균 학생수를 출력

studentCnts = (1, 18), (2, 19), (3, 23), (4, 21), (5, 20), (6, 22), (7, 17)
sum = 0
avg = 0


for classNo, cnt in studentCnts:
    print('{}학급 학생 수 : {}' .format(classNo, cnt))
    sum += cnt
print('전체 학생 수 : {}' .format(sum))
avg = sum / len(studentCnts)
print('평균 학생 수 : {}' .format(avg))

for문과 if문을 이용해서 과락 과목 출력

# for문과 if문을 이용해서 과락 과목 출력

minScore = 60
scores = (('국어',58),
          ('영어',77),
          ('수학',89),
          ('과학',99),
          ('국사',50))

for item in scores:
    if item[1] < minScore: # ★
        print('과락 과목 : {}, 점수 : {}' .format(item[0], item[1])) # ★
print()

for subject, score in scores:
    if score < minScore:
        print('과락 과목 : {}, 점수 : {}'.format(subject, score))
print()

for subject, score in scores:
    if score >= minScore: continue
    print('과락 과목 : {}, 점수 : {}'.format(subject, score))
print()

사용자가 국어, 영어, 수학, 과학, 국사 점수를 입력하면 과락 과목과 점수를 출력하는 프로그램을 생성

# 사용자가 국어, 영어, 수학, 과학, 국사 점수를 입력하면 과락 과목과 점수를 출력하는 프로그램을 생성

minScore = 60
korScore = int(input('국어 점수 : '))
engScore = int(input('영어 점수 : '))
matScore = int(input('수학 점수 : '))
sciScore = int(input('과학 점수 : '))
hisScore = int(input('국사 점수 : '))

scores = (('국어', korScore),
          ('영어', engScore),
          ('수학', matScore),
          ('과학', sciScore), 
          ('국사', hisScore))

for subject, score in scores:
    if score < minScore:
        print('과락 과목 : {}, 점수 : {}'.format(subject, score))

아래의 표와 튜플을 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

# 아래의 표와 튜플을 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

studentCnts = ((1, 18), (2, 19), (3, 23),
               (4, 21), (5, 20), (6, 22), (7, 17))

minClassNo = 0
maxClassNo = 0
minCnt = 0
maxCnt = 0

for classNo, cnt in studentCnts:
    if minClassNo == 0 or cnt < minCnt:
        minClassNo = classNo
        minCnt = cnt

    if cnt > maxCnt:
        maxClassNo = classNo
        maxCnt = cnt
print('학생 수가 가장 적은 학급(학생 수) : {}학급({}명)' .format(minClassNo, minCnt))
print('학생 수가 가장 많은 학급(학생 수) : {}학급({}명)' .format(maxClassNo, maxCnt))

튜플과 while문

  • while문을 이용하면 아이템 조회 가능
cars = '그렌저', '소나타', '말리부', '카니발', '쏘렌토'

n = 0
while n < len(cars):
    print(cars[n])
    n += 1
print()

n = 0
flag = True
while flag:
    print(cars[n])
    n += 1

    if n == len(cars):
        flag = False
print()

n = 0
while True:
    print(cars[n])
    n += 1

    if n == len(cars):
        break

아래 표와 튜플을 이용해서 학급별 학생 수와 전체 학생 수 그리고 평균 학생수를 출력

#  아래 표와 튜플을 이용해서 학급별 학생 수와 전체 학생 수 그리고 평균 학생수를 출력

studentCnts = (1, 18), (2, 19), (3, 23), (4, 21), (5, 20), (6, 22), (7, 17)

sum = 0
avg = 0
n = 0

while n < len(studentCnts):
    classNo = studentCnts[n][0]
    cnt = studentCnts[n][1]
    print('{} 학급 학생 수 : {}명'.format(classNo, cnt))
    sum += cnt
    n += 1
print('전체 학생 수 : {}명' .format(sum))
avg = sum / len(studentCnts)
print(f'평균 학생 수 : {avg}')

while문과 if문을 이용해서 과락 과목 출력

# while문과 if문을 이용해서 과락 과목 출력


minScore = 60
scores = (('국어',58),
          ('영어',77),
          ('수학',89),
          ('과학',99),
          ('국사',50))

n = 0
while n < len(scores):
    if scores[n][1] < minScore:
        print('과락 과목 : {}, 점수 : {}' .format(scores[n][0], scores[n][1]))
    n += 1
print()
minScore = 60
scores = (('국어',58),
          ('영어',77),
          ('수학',89),
          ('과학',99),
          ('국사',50))

n = 0

while n < len(scores):
    if scores[n][1] >= minScore :
        n += 1 # ★
        continue # ★

    print('과락 과목 : {}, 점수 : {}'.format(scores[n][0], scores[n][1]))
    n += 1 # ★
print()

while문을 이용해서 사용자가 국어, 영어, 수학, 과학, 국사 점수를 입력하면 과락 과목와 점수를 출력하는 프로그램을 생성

# while문을 이용해서 사용자가 국어, 영어, 수학, 과학, 국사 점수를 입력하면
# 과락 과목와 점수를 출력하는 프로그램을 생성

minScore = 60
korScore = int(input('국어 점수 : '))
engScore = int(input('영어 점수 : '))
matScore = int(input('수학 점수 : '))
sciScore = int(input('과학 점수 : '))
hisScore = int(input('국사 점수 : '))

scores = (('국어', korScore),
          ('영어', engScore),
          ('수학', matScore),
          ('과학', sciScore),
          ('국사', hisScore))

n = 0
while n < len(scores):
    if scores[n][1] >= minScore:
        n += 1
        continue
    print('과락 과목 : {}, 점수 : {}'.format(scores[n][0], scores[n][1]))
    n += 1
print()

학급별 학생 수가 다음과 같이 정의되어 있을 때, while 문을 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

# 학급별 학생 수가 다음과 같이 정의되어 있을 때, while 문을 이용해서
# 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

studentCnts = ((1, 18), (2, 19), (3, 23),
               (4, 21), (5, 20), (6, 22), (7, 17))

minClassNo = 0
maxClassNo = 0
minCnt = 0
maxCnt = 0

n = 0
while n < len(studentCnts):
    if minCnt == 0 or minScore > studentCnts[n][1]:
        minClassNo = studentCnts[n][0]
        minCnt = studentCnts[n][1]
    if maxCnt < studentCnts[n][1]:
        maxClassNo = studentCnts[n][0]
        maxCnt = studentCnts[n][1]
    n += 1
print('학생 수가 가장 적은 학급(학생 수) : {}학급({}명)' .format(minClassNo, minCnt))
print('학생 수가 가장 많은 학급(학생 수) : {}학급({}명)' .format(maxClassNo, maxCnt))
print()

딕셔너리

  • 키(key)와 값(value)를 이용하여 자료를 관리
    - 키(key) 값은 중복되면 안됨, 값(value)는 가능
  • '{}'를 이용해서 선언하고, '키:값'의 형태로 아이템을 정의
    - key와 value에는 숫자, 문자(열), 논리형 뿐만 아니라 컨테이너 자료형도 가능
    - 단, key에 변할 수 없는 값은 올 수 있지만 변할 수 있는 값은 올 수 없다
students = {'s1':'홍길동', 's2':'박찬호', 's3':'이용규', 's4':'박승철','s5':'김지은'}
print(students)

memInfo = {'이름' : '홍길동', '메일' : 'gildong@gmail.com', '학년': 3, '취비' : ['농구','게임']}
print(memInfo)

student1 = {'이름' : '홍길동', '메일' : 'gildong@gmail.com', '학년': 3}
student2 = {'이름' : '박찬호', '메일' : 'chango@gmail.com', '학년': 2}
student3 = {'이름' : '이용규', '메일' : 'younggyu@gmail.com', '학년': 1}

studentInfo = {1:student1, 2:student2, 3:student3}
print(studentInfo)

정보(이름, 전공, 메일, 주소 등)를 딕셔너리에 저장하고 출력

# 나의 정보(이름, 전공, 메일, 주소 등)를 딕셔너리에 저장하고 출력

myInfo = {'이름':'박경진',
          '전공':'computer',
          '메일':'jin@naver.com',
          '학년':3,
          '주소':'대한민국 서울',
          '취미':['요리','여행']}
print('myInfo : {}' .format(myInfo))

딕셔너리 조회

  • 딕셔너리는 키(key)를 이용해서 값(value)를 조회
    - 존재하지 않는 키를 이용한 조회 시 에러(error) 발생
  • get(key) : 딕셔너리 값 조회
    - get(key)는 key가 없어도 에러가 발생하지 않는다, None 반환
students = {'s1':'홍길동', 's2':'박찬호', 's3':'이용규', 's4':'박승철','s5':'김지은'}
print(students)

print('students[\'s1\'] : {}' .format(students['s1']))
print('students[\'s2\'] : {}' .format(students['s2']))
print('students[\'s3\'] : {}' .format(students['s3']))
print('students[\'s4\'] : {}' .format(students['s4']))
print('students[\'s5\'] : {}' .format(students['s5']))
print()
#print('students[\'s6\'] : {}' .format(students['s6']))
students = {'s1':'홍길동', 's2':'박찬호', 's3':'이용규', 's4':'박승철','s5':['박세리','박공주']}
print(students)
print(students['s5'][0])
print(students['s5'][1])
print()
students = {'s1':'홍길동', 's2':'박찬호', 's3':'이용규', 's4':'박승철','s5':'김지은'}
print(students)

print('students.get(\'s1\') : {}' .format(students.get('s1')))
print('students.get(\'s2\') : {}' .format(students.get('s2')))
print('students.get(\'s3\') : {}' .format(students.get('s3')))
print('students.get(\'s4\') : {}' .format(students.get('s4')))
print('students.get(\'s5\') : {}' .format(students.get('s5')))

print('students.get(\'s6\') : {}' .format(students.get('s6'))) # ★

나의 정보(이름, 전공, 메일, 주소 등)를 딕셔너리에 저장하고 ‘[ ]’와 ‘get()’함수를 이용해서 조회하고 출력

# 나의 정보(이름, 전공, 메일, 주소 등)를 딕셔너리에 저장하고 ‘[ ]’와 ‘get()’함수를
# 이용해서 조회하고 출력

myInfo = {'이름':'박경진',
          '전공':'computer',
          '메일':'jin@naver.com',
          '학년':3,
          '주소':'대한민국 서울',
          '취미':['요리','여행']}
print('myInfo : {}' .format(myInfo))

print('myInfo[\'이름\'] : {}' .format(myInfo['이름']))
print('myInfo[\'전공\'] : {}' .format(myInfo['전공']))
print('myInfo[\'메일\'] : {}' .format(myInfo['메일']))
print('myInfo[\'주소\'] : {}' .format(myInfo['주소']))
print('myInfo[\'취미\'] : {}' .format(myInfo['취미']))
print()


print('myInfo.get[\'이름\'] : {}' .format(myInfo.get('이름')))
print('myInfo.get[\'전공\'] : {}' .format(myInfo.get('전공')))
print('myInfo.get[\'메일\'] : {}' .format(myInfo.get('메일')))
print('myInfo.get[\'주소\'] : {}' .format(myInfo.get('주소')))
print('myInfo.get[\'취미\'] : {}' .format(myInfo.get('취미')))

딕셔너리 추가

  • 딕셔너리이름[키(key)] = 값(value) 형태로 아이템을 추가
  • 추가하려는 키가 이미 있다면 기존 값이 변경된다
myInfo = {'이름':'박경진',
          '전공':'computer',
          '메일':'jin@naver.com',
          '학년':3,
          '주소':'대한민국 서울',
          '취미':['요리','여행']}
print(myInfo)

myInfo['메일'] = 'gyeongjin@naver.com'
print(f'myInfo : {myInfo}')

학생 정보(이름, 학년, 메일, 주소)를 입력받아 딕셔너리에 추가

# 학생 정보(이름, 학년, 메일, 주소)를 입력받아 딕셔너리에 추가

studentInfo = {}

studentInfo['name'] = input('이름 입력 : ')
studentInfo['grade'] = input('학년 입력 : ')
studentInfo['mail'] = input('메일 입력 : ')
studentInfo['addr'] = input('주소 입력 : ')

print(f'studentInfo : {studentInfo}')

💡 0부터 10까지의 각각의 정수에 대한 팩토리얼을 딕셔너리에 추가

# 0부터 10까지의 각각의 정수에 대한 팩토리얼을 딕셔너리에 추가

factorialDic = {}

for i in range(0, 11):
    if i == 0:
        factorialDic[i] = 1
    else:
        for j in range(1, i+1): # ★
            factorialDic[i] = factorialDic[i-1] * j 

print(f'factorialDic : {factorialDic}')

딕셔너리 수정

  • 딕셔너리이름[키(key)] = 값(value) 형태로 아이템을 수정
myInfo = {}

myInfo['이름'] = '박경진'
myInfo['전공'] = 'computer'
myInfo['메일'] = 'jin@naver.com'
myInfo['학년'] = 3
myInfo['주소'] = '대한민국 서울'
myInfo['취미'] = ['요리', '여행']
print(myInfo)

myInfo['전공'] = 'sports'
myInfo['학년'] = '4'
print(myInfo)

학생의 시험 점수가 60점 미만이면 ‘F(재시험)’으로 값을 변경

# 학생의 시험 점수가 60점 미만이면 ‘F(재시험)’으로 값을 변경

scores = {'kor' : 88, 'eng' : 55, 'mat' : 85, 'sci' : 57, 'his' : 82}
print(f'scores : {scores}')

minScore = 60
fStr = 'F(재시험)'

if scores['kor'] < minScore: scores['kor'] = fStr
if scores['eng'] < minScore: scores['eng'] = fStr
if scores['mat'] < minScore: scores['mat'] = fStr
if scores['sci'] < minScore: scores['sci'] = fStr
if scores['his'] < minScore: scores['his'] = fStr
print(f'scores : {scores}')

하루에 몸무게(kg)와 신장(m)이 각각 -0.3kg, +0.001m씩 변한 다고 할 때, 30일 후의 몸무게와 신장의 값을 저장하고 BMI 값도 출력하는 프로그램을 만들어보자.
(현재 신체정보는 아래의 딕셔너리에 저장되어 있다.)

# 하루에 몸무게(kg)와 신장(m)이 각각 -0.3kg, +0.001m씩 변한 다고 할 때, 30일 후의
# 몸무게와 신장의 값을 저장하고 BMI 값도 출력하는 프로그램을 만들어보자.
# (현재 신체정보는 아래의 딕셔너리에 저장되어 있다.)

myBodyInfo = {'이름':'gildong', '몸무게':83.0, '신장':1.8}
myBMI = myBodyInfo['몸무게'] / (myBodyInfo['신장'] ** 2)

print(f'myBodyInfo : {myBodyInfo}')
print(f'myBMI : {round(myBMI,2)}')

date = 0
while True:
    myBodyInfo['몸무게'] = round(myBodyInfo['몸무게'] - 0.3,2)
    print('몸무게 : {}' .format(myBodyInfo['몸무게']))

    myBodyInfo['신장'] = round(myBodyInfo['신장'] + 0.001, 3)
    print('신장 : {}'.format(myBodyInfo['신장']))

    myBMI = myBodyInfo['몸무게'] / (myBodyInfo['신장'] ** 2)
    print('BMI : {}' .format(round(myBMI,2)))

    date += 1

    if date >= 30:
        break

💡 keys()와 values()

  • keys() : 전체 key값 조회, (모양만 리스트 형태)
  • values() : 전체 value값 조회, (모양만 리스트 형태)
  • items() : 전체 key값, value값 조회, (모양만 튜플형태)
memInfo = {'이름':'홍길동',
          '메일':'gildong@gmail.com',
          '학년':3,
          '취미':['농구','게임']}
print(memInfo)

ks = memInfo.keys()
print(f'ks : {ks}')
print(f'ks type : {type(ks)}')
print()

vs = memInfo.values()
print(f'vs : {vs}')
print(f'vs type : {type(vs)}')
print()

items = memInfo.items()
print(f'items : {items}')
print(f'vs type : {type(items)}')
print()


ks = memInfo.keys()
ks = list(ks)
print(f'ks : {ks}')
print(f'ks type : {type(ks)}')
print()

vs = memInfo.values()
vs = list(vs)
print(f'ks : {vs}')
print(f'ks type : {type(vs)}')
print()

items = memInfo.items()
items = list(items)
print(f'ks : {items}')
print(f'ks type : {type(items)}')
print()


ks = memInfo.keys()
for key in ks:
    print(f'key : {key}')

vs = memInfo.values()
for value in vs:
    print(f'value : {value}')

items = memInfo.items()
for item in items:
    print(f'item : {item}')


for key in memInfo.keys():
    print(f'key : {key}')

💡 학생의 시험 점수가 60점 미만이면 ‘F(재시험)’으로 값을 변경하는 코드를 keys()를 이용해서 작성

# 학생의 시험 점수가 60점 미만이면 ‘F(재시험)’으로 값을 변경하는 코드를 keys()를 이용해서 작성

scores = {'kor' : 88, 'eng' : 55, 'mat' : 85, 'sci' : 57, 'his' : 82}
print(f'scores : {scores}')

minScore = 60
fStr = 'F(재시험)'
fDic = {}

for key in scores.keys():
    if scores[key] < minScore:
        scores[key] = fStr
        fDic[key] = fStr

print(f'scores : {scores}')
print(f'fDic : {fDic}')

딕셔너리 삭제

  • del 딕셔너리이름[키(key)] : del과 key를 이용하여 item(key, value) 삭제
  • 딕셔너리이름.pop('키(key)') : pop()과 key를 이용하여 item(key, value) 삭제
memInfo = {'이름':'홍길동',
          '메일':'gildong@gmail.com',
          '학년':3,
          '취미':['농구','게임']}
print(memInfo)

del memInfo['메일']
print(f'memInfo : {memInfo}')

del memInfo['취미']
print(f'memInfo : {memInfo}')
memInfo = {'이름':'홍길동',
          '메일':'gildong@gmail.com',
          '학년':3,
          '취미':['농구','게임']}
print(memInfo)

returnValue = memInfo.pop('이름')
print(f'memInfo : {memInfo}')
print(f'returnValue : {returnValue}')
print(f'returnValue type : {type(returnValue)}')

returnValue = memInfo.pop('취미')
print(f'memInfo : {memInfo}')
print(f'returnValue : {returnValue}')
print(f'returnValue type : {type(returnValue)}')

💡 딕셔너리에 저장된 점수 중 최저 및 최고 점수를 삭제하는 프로그램을 생성

scores = {'score1' : 8.9, 'score2' : 8.1,
          'score3' : 8.5, 'score4' : 9.8, 'score5' : 8.8}

minScore = 10; minScoreKey = ''
maxScore = 0; maxScoreKey = ''

for key in scores.keys():
    if scores[key] < minScore: # ★
        minScore = scores[key] # ★
        minScoreKey = key # ★
    if scores[key] > maxScore: # ★
        maxScore = scores[key] # ★
        maxScoreKey = key # ★

del scores[minScoreKey]
del scores[maxScoreKey]

print(f'scores : {scores}')

딕셔너리 유용한 기능

  • in, not in : 키(key)의 존재 유/무 판단(True / False)
  • len() : 딕셔너리 길이(아이템 개수)
  • 💡 clear() : 모든 아이템 삭제
memInfo = {'이름':'홍길동',
          '메일':'gildong@gmail.com',
          '학년':3,
          '취미':['농구','게임']}
print(memInfo)

print('이름 : {}' .format('이름' in memInfo))
print('메일 : {}' .format('메일' in memInfo))
print('학년 : {}' .format('학년' in memInfo))
print('취미 : {}' .format('취미' in memInfo))
print()

print('이름 : {}' .format('name' not in memInfo))
print('메일 : {}' .format('mail' not in memInfo))
print('학년 : {}' .format('grade' not in memInfo))
print('취미 : {}' .format('hobby' not in memInfo))
print()
memInfo = {'이름':'홍길동',
          '메일':'gildong@gmail.com',
          '학년':3,
          '취미':['농구','게임']}
print(memInfo)
print('len(memInfo) : {}' .format(len(memInfo)))
print()
memInfo = {'이름':'홍길동',
          '메일':'gildong@gmail.com',
          '학년':3,
          '취미':['농구','게임']}
print(memInfo)

memInfo.clear()
print('memInfo : {}' .format(memInfo))

💡 개인 정보에 ‘연락처’와 ‘주민등록번호’가 있다면 삭제하는 코드를 작성

# 개인 정보에 ‘연락처’와 ‘주민등록번호’가 있다면 삭제하는 코드를 작성

myInfo = {'이름' : 'Hong Gildong',
          '나이' : '30',
          '연락처' : '010-1234-5678',
          '주민등록번호' : '840315-1234567',
          '주소': '대한민국 서울'}
print(myInfo)

deleteItems = ['연락처', '주민등록번호']

for item in deleteItems: # ★
    if item in myInfo.keys(): # key값을 가지고 비교
        del myInfo[item]

print(myInfo)

💻 출처 : 제로베이스 데이터 취업 스쿨

profile
zoe
#데이터분석 #퍼포먼스마케팅 #데이터 #디지털마케팅
이전 포스트

스터디노트(자료구조 1~4)

다음 포스트

스터디노트(자료구조 문제풀이 1~3)

0개의 댓글