📝 자료구조

📌 리스트

✏ 리스트 나머지 기능

• 리스트를 곱셈 연산하면 아이템이 반복된다.

list = ['짱구', '짱아', '철수']
print('list : {}'.format(list))

mulList = list * 2
print('mulList : {}'.format(mulList))
↓
list : ['짱구', '짱아', '철수']
mulList : ['짱구', '짱아', '철수', '짱구', '짱아', '철수']

• index(item) 함수로 item의 인덱스를 알아낼 수 있다.

list = ['짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이']
print('list : {}'.format(list))

searchIdx = list.index('짱아',2,5)
print('searchIdx : {}'.format(searchIdx))
↓
list : ['짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이']
searchIdx : 4

• count() 함수를 이용하면 특정 아이템의 개수를 알아낼 수 있다.

list = ['짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이']
print('list : {}'.format(list))

searchCnt = list.count('짱아')
print('searchCnt : {}'.format(searchCnt))

searchCnt = list.count('짱구')
print('searchCnt : {}'.format(searchCnt))

searchCnt = list.count('봉미선')
print('searchCnt : {}'.format(searchCnt))
↓
list : ['짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이']
searchCnt : 2
searchCnt : 1
searchCnt : 0

• del 키워드를 이용하면 특정 아이템을 삭제할 수 있다.

list = ['짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이']
print('list : {}'.format(list))

del list[1]
print('list : {}'.format(list))
↓
list : ['짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이']
list : ['짱구', '철수', '유리', '짱아', '맹구', '훈이']


del list[1:4]
print('list : {}'.format(list))
↓
list : ['짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이']
list : ['짱구', '짱아', '맹구', '훈이']

📌 튜플

• 리스트(List)와 비슷하지만 아이템 변경이 불가하다.

✏ 튜플 선언

• '()'를 이용해서 선언하고, 데이터 구분은 ','를 이용한다.

character = ('짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이')
print('character : {}'.format(character))
print('character type : {}'.format(type(character)))
↓
character : ('짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이')
character type : <class 'tuple'>

✏ 튜플 아이템 조회

• 인덱스
  - 튜플도 리스트와 마찬가지로 아이템에 자동으로 부여되는 번호표가 있다.
  • 인덱스를 통해 아이템 조회 가능

character = ('짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이')
print('character : {}'.format(character))

for i in range(len(character)):

    print('character index: {}, value : {}'.format(i, character[i]))
    if i % 2 == 0:
        print('짝수 인덱스 : {}'.format(character[i]))
    else :
        print('홀수 인덱스 : {}'.format(character[i]))
↓
character : ('짱구', '짱아', '철수', '유리', '짱아', '맹구', '훈이')
character index: 0, value : 짱구
짝수 인덱스 : 짱구
character index: 1, value : 짱아
홀수 인덱스 : 짱아
character index: 2, value : 철수
짝수 인덱스 : 철수
character index: 3, value : 유리
홀수 인덱스 : 유리
character index: 4, value : 짱아
짝수 인덱스 : 짱아
character index: 5, value : 맹구
홀수 인덱스 : 맹구
character index: 6, value : 훈이
짝수 인덱스 : 훈이

✏ in, not in 키워드

• in, not in 키워드를 이용하면 아이템의 존재 유/무를 알 수 있다.

character = ('짱구', '짱아', '철수', '유리', '맹구', '훈이')
print('character : {}'.format(character))

searchCha = input('캐릭터 이름 입력 : ')

if searchCha in character :
    print('{}은(는) 떡잎 마을 사람입니다.'.format(searchCha))
else :
    print('{}은(는) 떡잎 마을 사람이 아닙니다.'.format(searchCha))
↓
character : ('짱구', '짱아', '철수', '유리', '맹구', '훈이')
캐릭터 이름 입력 : 철수
철수은(는) 떡잎 마을 사람입니다.

↓
캐릭터 이름 입력 : 루피
루피은(는) 떡잎 마을 사람이 아닙니다.

✏ 아이템 개수

• 리스트와 마찬가지로, 튜플에 저장된 아이템 개수를 튜플 길이라고 한다.
• len()과 반복문을 이용하면 튜플의 아이템 조회가 가능하다.

character = ('짱구', '짱아', '철수', '유리', '맹구', '훈이')

slength = len(character)
print('slength: {}'.format(slength))

for i in range(len(character)):
    print('i : {}'.format(i))
    print('character[{}] : {}'.format(i, character[i]))
↓
slength: 6
i : 0
character[0] : 짱구
i : 1
character[1] : 짱아
i : 2
character[2] : 철수
i : 3
character[3] : 유리
i : 4
character[4] : 맹구
i : 5
character[5] : 훈이

✏ 튜플 결합

• 두 개의 튜플을 결합할 수 있다.

cha1 = ('짱구', '짱아', '철수')
cha2 = ('유리', '맹구', '훈이')

cha3 = cha1 + cha2

print(cha3)
↓
('짱구', '짱아', '철수', '유리', '맹구', '훈이')

✏ 리스트 VS 튜플

• 리스트에서 사용할 수 있는 extend() 함수를 튜플에서는 사용할 수 없다.

cha1 = ('짱구', '짱아', '철수')
cha2 = ('유리', '맹구', '훈이')

try :
    cha1.extend(cha2)
except Exception as e:
    print(e)
↓
'tuple' object has no attribute 'extend'

✏ 튜플 슬라이싱

• 리스트와 마찬가지로 [n:m]을 이용하면 리스트에서 원하는 아이템만 뽑아낼 수 있다.

character = ('짱구', '짱아', '철수', '유리', '맹구', '훈이')
print('character : {}'.format(character))
print('character[2:5] : {}'.format(character[2:5]))
print('character[2:] : {}'.format(character[2:]))
print('character[2:-2] : {}'.format(character[2:-2]))
print('character[-5:-2] : {}'.format(character[-5:-2]))
↓
character : ('짱구', '짱아', '철수', '유리', '맹구', '훈이')
character[2:5] : ('철수', '유리', '맹구')
character[2:] : ('철수', '유리', '맹구', '훈이')
character[2:-2] : ('철수', '유리')
character[-5:-2] : ('짱아', '철수', '유리')

• 슬라이싱 단계 설정
  - 슬라이싱할 때 단계를 설정할 수 있다.

character = ('짱구', '짱아', '철수', '유리', '맹구', '훈이')
print('character : {}'.format(character))
print('character[1:5:2] : {}'.format(character[1:5:2]))
↓
character : ('짱구', '짱아', '철수', '유리', '맹구', '훈이')
character[1:5:2] : ('짱아', '유리')

• 튜플은 슬라이싱을 이용해서 아이템을 변경할 수 없다.

• slice() 함수를 이용해서 아이템을 슬라이싱할 수 있다.

✏ 리스트와 튜플

• 리스트와 튜플의 차이점
  - 튜플은 리스트와 달리 아이템 추가, 변경, 삭제가 불가하다.
  • 튜플은 선언 시 괄호 생략이 가능하다.
• 리스트와 튜플 변환
  - 리스트와 튜플은 자료형 변환이 가능하다.

character = ['짱구', '짱아', '철수', '유리', '맹구', '훈이']
print(type(character))
print(character)
character = tuple(character)
print(type(character))
print(character)
↓
<class 'list'>
['짱구', '짱아', '철수', '유리', '맹구', '훈이']
<class 'tuple'>
('짱구', '짱아', '철수', '유리', '맹구', '훈이')

✏ 튜플 아이템 정렬

• 튜플은 수정이 불가하기 때문에 리스트로 변환 후 정렬하자.
  - sorted() 함수를 이용하면 튜플로 정렬할 수 있다.

cha = ('짱구', '짱아', '철수', '유리', '맹구', '훈이')
print(cha)

cha = list(cha)
print(type(cha))
cha.sort()
print(cha)
cha = tuple(cha)
print(cha)
↓
('짱구', '짱아', '철수', '유리', '맹구', '훈이')
<class 'list'>
['맹구', '유리', '짱구', '짱아', '철수', '훈이']
('맹구', '유리', '짱구', '짱아', '철수', '훈이')


print(cha)
sortedCha = sorted(cha)
print(sortedCha)
sortedCha = tuple(sortedCha)
print(sortedCha)
↓
('짱구', '짱아', '철수', '유리', '맹구', '훈이')
['맹구', '유리', '짱구', '짱아', '철수', '훈이']
('맹구', '유리', '짱구', '짱아', '철수', '훈이')

✏ 튜플과 for문

• for문을 이용하면 튜플의 아이템을 자동으로 참조할 수 있다.

cha = ('짱구', '짱아', '철수', '유리', '맹구', '훈이')

for i in range(len(cha)):
    print(cha[i])
↓
짱구
짱아
철수
유리
맹구
훈이


for idx, value in enumerate(cha):
    print(f'cha index : {idx}, cha value : {value}')
↓
cha index : 0, cha value : 짱구
cha index : 1, cha value : 짱아
cha index : 2, cha value : 철수
cha index : 3, cha value : 유리
cha index : 4, cha value : 맹구
cha index : 5, cha value : 훈이

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

scores = (('국어', 59),
          ('수학', 50),
          ('영어', 79),
          ('과학', 58),
          ('국사', 81))
minScore = 60

for sub, score in scores:
    if score < minScore:
        print('과락 과목 : {}, 점수 : {}'.format(sub,score))
↓
과락 과목 : 국어, 점수 : 59
과락 과목 : 수학, 점수 : 50
과락 과목 : 과학, 점수 : 58

✏ 튜플과 while문

• while문을 이용한 조회

cha = ('짱구', '짱아', '철수', '유리', '맹구', '훈이')

n=0
while n < len(cha):
    print(cha[n])

    n+=1

flag = True

while flag :
    print(cha[n])
    if n == len(cha)-1:
        flag = False

    n+=1
↓
짱구
짱아
철수
유리
맹구
훈이

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

scores = (('국어', 59),
          ('수학', 50),
          ('영어', 79),
          ('과학', 58),
          ('국사', 81))
minScore = 60

n=0
while n < len(scores):
    result = scores[n]

    if result[1] < minScore:
        print('과락 과목 : {}, 점수 : {}'.format(result[0],result[1]))

    n+=1
↓
과락 과목 : 국어, 점수 : 59
과락 과목 : 수학, 점수 : 50
과락 과목 : 과학, 점수 : 58

📌 딕셔너리

• 키(key)와 값(value)를 이용해서 자료를 관리한다.
• 키는 중복 되면 안되지만 값은 중복 되어도 상관없음
• {}를 이용해서 선언하고, '키:값'의 형태로 아이템을 정의한다.
• key와 value에는 숫자, 문자(열), 논리형 뿐만 아니라 컨테이너 자료형도 올 수 있다.
  - 단, key에 immutable 값은 올 수 있지만 mutable 값은 올 수 없다.

✏ 딕셔너리 조회

• 딕셔너리는 키(key)를 이용해서 값(value)을 조회한다.

cha = {'s1':'짱구', 's2':'짱아', 's3':'철수'}

for key in cha:
    print('cha key : {}, value : {}'.format(key, cha[key]))
↓
cha key : s1, value : 짱구
cha key : s2, value : 짱아
cha key : s3, value : 철수    

• get()함수를 이용하여 조회 가능

cha = {'s1':'짱구', 's2':'짱아', 's3':'철수'}

for key in cha:
    print('cha key : {}, value : {}'.format(key, cha.get(key)))
↓
cha key : s1, value : 짱구
cha key : s2, value : 짱아
cha key : s3, value : 철수

✏ 딕셔너리 추가

• '딕셔너리이름[키(key)] = 값(value)'형태로 아이템을 추가한다.

cha = {}
n=0
flag = True
while flag :
    if n <= 3:
        getKey = input('key값 입력 : ')
        getVal = input('value값 입력 : ')

        cha[getKey] = getVal

        n+=1

    if n == 3:
        flag = False

print(cha)
↓
key값 입력 : s1
value값 입력 : 짱구
key값 입력 : s2
value값 입력 : 철수
key값 입력 : s3
value값 입력 : 맹구
{'s1': '짱구', 's2': '철수', 's3': '맹구'}

• 추가하려는 키가 이미 있다면 그 키에 해당하는 value가 바뀜

✏ 딕셔너리 수정

• '딕셔너리 이름[키(key)] = 값(value)'형태로 아이템을 수정한다.

scores = {'kor': 80,
          'eng': 77,
          'mat': 56,
          'sci': 49,
          'his': 91
          }
print(f'scores : {scores}')

minScore = 60
fStr = 'F(재시험)'
for key in scores:
    if scores[key] < minScore:
        scores[key] = fStr

for i in scores:
    print('{} : {}'.format(i, scores[i]))
↓
scores : {'kor': 80, 'eng': 77, 'mat': 56, 'sci': 49, 'his': 91}
kor : 80
eng : 77
mat : F(재시험)
sci : F(재시험)
his : 91

✏ keys()와 values()

• 전체 키와 값를 조회할 수 있다.

✏ 딕셔너리 삭제

• del

cha = {
    's1':'짱구',
    's2':'짱아',
    's3':'철수'
}

print(cha)

del cha['s1']
print(cha)

del cha['s3']
print(cha)
↓
{'s1': '짱구', 's2': '짱아', 's3': '철수'}
{'s2': '짱아', 's3': '철수'}
{'s2': '짱아'}

-pop()

cha = {
    's1':'짱구',
    's2':'짱아',
    's3':'철수'
}

print(cha)

returnValue = cha.pop('s3')
print(cha)
print('resturnValue : {}'.format(returnValue))
↓
{'s1': '짱구', 's2': '짱아', 's3': '철수'}
{'s1': '짱구', 's2': '짱아'}
resturnValue : 철수

✏ 딕셔너리 유용한 기능

• in, not in
  - 키 존재 유/무 판단
  주민번호, 연락처 삭제 코드

myInfo = {
    '이름':'hong gildong',
    '나이': '30',
    '연락처': '010-1234-5678',
    '주민번호': '922123-1234567',
    '주소': '서울'
}
print(myInfo)

delInfo = ['연락처', '주민번호']
for key in delInfo:
    if key in delInfo:
        del myInfo[key]

for item in myInfo:
    print('{} : {}'.format(item, myInfo[item]))

↓
{'이름': 'hong gildong', '나이': '30', '연락처': '010-1234-5678', '주민번호': '922123-1234567', '주소': '서울'}
이름 : hong gildong
나이 : 30
주소 : 서울

• len
  - 딕셔너리의 길이를 알 수 있다.

• clear()
  - 모든 아이템을 삭제