day2. 집합 자료형

이번 시간에는 집합 자료형에 대해 알아보려고 한다.

기본 자료형에는 문자열, 정수, 실수 등이 있었지만, 집합 자료형에는 리스트, 튜플, 딕셔너리, 집합이 있다.

 

제일 먼저 알아볼 자료형은 리스트이다.

리스트는 다른 여러 데이터 형으로 구성이 가능하며, 순차적 생성을 한다. 

리스트 선언은 리스트 변수 = [값1, 값2, ...] 의 구조로 한다.

 

fruits = ['apple', 'banana','peer']
print(fruits)
#['apple', 'banana', 'peer']

여기서 리스트에 요소 추가하는 문법을 간략하게 소개하겠다.

List.append(원소)

 

movieList = []
movieList.append('harry potter')
print(movieList)
#harry potter

 

앞서 말한 리스트 특징으로 서로 다른 데이터 형으로 리스트 정의가 가능하다.

myList = [1,'apple',True]
print(f'myList = {myList}')
# myList = [1, 'apple', True]

위의 예제에서 정수, 문자열, boolean 을 하나의 리스트에 넣었으며 정상적으로 출력이 가능하다는 것을 확인할 수 있었다.

 

이전시간에 간략하게 인덱싱에 대해 소개했지만, 리스트에서 인덱싱과 슬라이싱은 많이 쓰인다.

#인덱싱
#리스트 이름[숫자] : 0부터 시작
print(fruits[0], fruits[-1])#처음, 마지막

#apple , peer

인덱싱 -1은 요소의 맨 마지막 요소를 나타낸다.

#리스트 슬라이싱
#리스트 이름[start:end:step]
#리스트 이름[start:]
#리스트 이름[:end]
#리스트 이름[::] 전체리스트
numList = [1,2,3,4,5,6,7,8]
print(numList[0::3]) # [1, 4, 7]
print(f'numList[::] = {numList[::]}') # [1, 2, 3, 4, 5, 6, 7, 8]
print(f'numList[0::2] = {numList[0::2]}') # [1, 3, 5, 7]
print(f'numList[:-1:4] = {numList[:-1:4]}') # [1, 5]
print(f'numList[1::2] = {numList[1::2]}') # [2, 4, 6, 8]

하나의 숫자리스트를 생성하고 슬라이싱을 한 번 해보았다.

---

리스트 관련 함수로 앞서 언급한 append와 유사한 insert를 소개하고자 한다.

append는 리스트 끝에 원소를 추가하는 반면에, insert는 인덱스 위치와 원소값을 파라메터로 받는다.

insert(삽입위치, 값)

foods = ['라면']
foods.append('짜장면')
print(foods)
foods.insert(2,"볶음밥")
print(f'foods = {foods}')

# foods = ['라면', '짜장면', '볶음밥']

삽입에 대해서 알아봤으니, 이제 삭제에 관련한 함수를 알아보겠다.

기본적으로 remove, pop, clear, del 함수가 있다.

remove(값)
pop() 마지막 요소 삭제되면서 값이 반환
pop(위치값) 위치에 해당하는 요소가 삭제되면서 값이 반환
clear() : 리스트 안의 값이 모두 삭제
del 리스트 변수 : 리스트 자체 삭제

 

numList = [1,2,3,4,5,6,7,8]
print(f'numList = {numList}')
#numList = [1, 2, 3, 4, 5, 6, 7, 8]

numList.remove(3)
print(f'numList = {numList}')
#numList = [1, 2, 4, 5, 6, 7, 8]

numList.pop()
numList.clear()
print(f'numList ={numList}')
#numList =[]

---

 

리스트 값 정렬에는 sort()와 reverse()가 있다.

말 그대로 정렬과 역정렬의 기능이다.

sampleList1 = ['나', '가', '바', '차']
sampleList2 = ['나', True, 'abc', 100]
print(f'sampleList1 ={sampleList1}')
# sampleList1 =['나', '가', '바', '차']

sampleList1.sort()
print(f'sampleList1 ={sampleList1}')
# sampleList1 =['가', '나', '바', '차']

sampleList1.reverse()
print(f'sampleList1 ={sampleList1}')
#sampleList1 =['차', '바', '나', '가']
print(f'sampleList2 ={sampleList2}')
#sampleList2 =['나', True, 'abc', 100]


sampleList1.sort()
print(f'sampleList2 ={sampleList2}')
#sampleList2 =['나', True, 'abc', 100]

잠깐 복습하는 개념으로 인덱싱 관련해서 예제를 풀어보도록 하자.

 

Quiz1

2개의 리스트를 정의하고 다음과 같이 출력한다.
myList1 : ['홍길동', '신데렐라', '알라딘', '장화',
'홍련', '지니', '엘리스']
myList2 : ['토끼', '거북이', '물개', '펭귄']
2개의 리스트 합 : (결과값 출력 )
4개만 출력 : (결과값 출력 )
짝수번째만 출력 : (결과값 출력 )
홀수번째만 출력 : (결과값 출력 )
총 길이 : 11

 

해당 문제의 정답은 글의 맨 마지막에 작성하도록 하겠다.

---

문자열을 리스트로 바꾸는 split 함수에 대해서 알아보자.

기본 구조로는 문자열변수.split() 이며, 문자열변수.split(구분문자)인 경우에는 구분문자를 기준으로 해서 리스트화를 한다.

sampleTxt1 = '사과 포도 수박 딸기'
sampleTxt2 = '사과, 포도, 수박, 딸기'
print(f'sampleTxt1 = {sampleTxt1}') # sampleTxt1 = 사과 포도 수박 딸기
print(f'sampleTxt1의 데이터형 = {type(sampleTxt1)}') # sampleTxt1의 데이터형 = <class 'str'>
print(f'sampleTxt2 = {sampleTxt2}') # sampleTxt2 = 사과, 포도, 수박, 딸기
print(f'sampleTxt2의 데이터 형 = {type(sampleTxt2)}') sampleTxt2의 데이터 형 = <class 'str'>


sampleTxt1List = sampleTxt1.split()
print(f'sampleTxt1List = {sampleTxt1List}')
# sampleTxt1List = ['사과', '포도', '수박', '딸기']

print(f'sampleTxt1List의 데이터형 = {type(sampleTxt1List)}')
#sampleTxt1List의 데이터형 = <class 'list'>


sampleTxt2List = sampleTxt2.split(',')
print(f'sampleTxt2List = {sampleTxt2List}')
# sampleTxt1List2 = ['사', '과', ' ', '포', '도', ' ', '수', '박', ' ', '딸', '기']
print(f'sampleTxt2List의 데이터형 = {type(sampleTxt2List)}')
# sampleTxt1List2의 데이터형 = <class 'list'>

위의 코드는 문자열을 리스트로 캐스팅하는 예제로 구성되어 있으며, 이번에는 그 반대로, 리스트를 문자열로 캐스팅하는 방법에 대해 소개하겠다.

첫 번째로는 str()을 통한 캐스팅, 두 번째로는 ' '.join()을 통한 캐스팅이다. 구조로는 '구분자'.join(리스트 이름) 이다.

 

joblist2 = ['파이썬', 'DB', '플라스크']
result1 = str(joblist2)
result2 = ' / '.join(joblist2)
print(f'result1 의 데이터형은? {type(result1)}')
# result1 의 데이터형은? <class 'str'>
print(result2)
# 파이썬 / DB / 플라스크
print(f'result2 의 데이터형은? {type(result2)}')
# result2 의 데이터형은? <class 'str'>

---

리스트에 대해 알아보았으니, 그 다음으로 중첩리스트에 대해서도 알아보자.

쉽게 말해 리스트 안에 리스트가 있는 구조로써 리스트이름[index1][index2]... 이다.

리스트변수 = [[값1, 값2...],[값1, 값2...]] 의 구조로서 쉽게 이해하면 2차원, 3차원 배열로 만들 수도 있다.

listMulti1 = [1, 2, ['a','b','c'], ['포도','수박']]

print(f'listMulti1[0] = {listMulti1[0]}')
# listMulti1[0] = 1
print(f'listMulti1[2] = {listMulti1[2]}')
# listMulti1[2] = ['a', 'b', 'c']
print(f'listMulti1[2][1] = {listMulti1[2][1]}')
# listMulti1[2][1] = b
print(f'listMulti1[3][-1] = {listMulti1[3][-1]}')
# listMulti1[3][-1] = 수박

추가적으로 각각 1차원 리스트 선언 후, 1차원 리스트들로 중첩 리스트 구성이 가능하다.

userName = ['홍길동','박지민','이미연']
userAge = [20, 25,34]
userGender = ['남','남','여']

userAddr = [userName, userAge, userGender]

print(f'userAddr = {userAddr}')
# userAddr = [['홍길동', '박지민', '이미연'], [20, 25, 34], ['남', '남', '여']]
print(f'userAddr[2][1] = {userAddr[2][1]}')
# userAddr[2][1] = 남
print(f'userAddr[-1][-1] = {userAddr[-1][-1]}')
# userAddr[-1][-1] = 여

---

리스트 다음으로 이제는 튜플이다. 튜플과 리스트의 차이점이라고 하면, 튜플은 원소 수정이 불가능하다는 점이다.

튜플 생성의 방법으로는

#튜플 생성(초기값 지정)
#튜플 변수 = (값1, 값2...)
t1= (100, 200, 300,400,500)
t2= ('a', 'b', 'c')
print(f't1 = {t1}, type = {type(t1)}')
print(f't2 = {t2}, type = {type(t2)}')

#튜플 생성2(초기값 지정)
#튜플 변수 = 값1, 값2 ...
t3 = '가', '나', '다'
print(f't3={t3},type={type(t3)}')

#튜플 생성3(빈튜플)
#튜플 변수 = ()
t4 = ()
print(f't4 = {t4}, type = {type(t4)}')

 

위와 같은 방법들이 있다. 그리고 튜플도 역시 인덱싱이 가능하며 리스트 인덱싱과 동일하다.

튜플 값 새로 추가하기 위해서는 대입연산자 +=를 사용한다.

튜플끼리의 연산은 + (튜플끼리 더하기)와 *(튜플 요소 반복)이 있다.

 

print(f't4= {t4}')
t4+=('도',)
print(f't4={t4}')
t4 += ('레','미','파','솔')
print(f't4 = {t4}')
#t4 = ('도', '레', '미', '파', '솔')


t5 = ('가','나','다')
t6 = ('라','마','바')
print(f"t5={t5}")
# t5=('가', '나', '다')
print(f"t6={t6}")
# t6=('라', '마', '바')
print(t5+t6)
# ('가', '나', '다', '라', '마', '바')
print(f"t5*3 = {(t5*3)}")
# t5*3 = ('가', '나', '다', '가', '나', '다', '가', '나', '다')

튜플을 리스트 안에 넣으면 어떻게 될까?

foodT1 = ('오징어','계란')
foodT2 = ('고등어','참치')
foodList = [foodT1, foodT2]
print(foodList)
print(f'foodT1 = {foodT1}, type={type(foodT1)}')
# foodT1 = ('오징어', '계란'), type=<class 'tuple'>

print(f'foodList = {foodList},{type(foodList)}')
# foodList = [('오징어', '계란'), ('고등어', '참치')],<class 'list'>

print(f'foodList[0] = {foodList[0]}, type = {type(foodList[0])}')
# foodList[0] = ('오징어', '계란'), type = <class 'tuple'>

print(f'foodList[-1][-1] = {foodList[-1][-1]}, type = {type(foodList[-1][-1])}')
# foodList[-1][-1] = 참치, type = <class 'str'>

리스트 형태로 정의되며, 인덱싱 역시 가능하다.

 

---

리스트 다음으로 중요한 딕셔너리 구조에 대해 알아보자.

딕셔너리 변수 = {키 1: 값 1, 키2:값2...} 의 구조이며, Key, Value 값을 가진다.

키값은 문자형, 숫자형 둘다 가능하다.

 

딕셔너리 정의를 한 번 해보자.

dict1 = {100:'백', 200:'이백',300:'삼백'}
dict2 = {'a':'africa','c':'cat','d':'drama'}

print(f'dict1 = {dict1},type={type(dict1)}')
# dict1 = {100: '백', 200: '이백', 300: '삼백'},type=<class 'dict'>

print(f'dict2 = {dict2}, type={type(dict2)}')
# dict2 = {'a': 'africa', 'c': 'cat', 'd': 'drama'}, type=<class 'dict'>

딕셔너리 요소의 접근은 리스트 인덱싱 및 슬라이싱과 유사하다.

dict3['st1'] = '홍길동'
print(dict3)
#{'st1': '홍길동'}

dict3[100] = '이영애'
print(f'dict3 = {dict3}, {type(dict3)}')
#dict3 = {'st1': '홍길동', 100: '이영애'}, <class 'dict'>

딕셔너리 변수[키값] = 값 의 구조로 딕셔너리 요소 추가가 가능하다.

그리고 인덱싱은 딕셔너리변수[키값] 이다.

참고로 딕셔너리는 키값으로만 호출이 가능하고, 숫자 인덱싱이 불가능하다.

dict4 = {'a':'africa','c':'cat','c':'canada','d':'dry','ab':'africa'}

#딕셔너리 값 교체
#딕셔너리[키값] = 값
dict4['d'] = 'drama'
print(f'dict4={dict4}')
# dict4={'a': 'africa', 'c': 'canada', 'd': 'drama', 'ab': 'africa'}

'd'의 value값이 바뀐 것을 알 수가 있다.

딕셔너리 역시 요소의 삭제에 있어서 pop을 사용한다.

#딕셔너리 변수.pop(키값)

dict4.pop('a')
print(f'dict4={dict4}')
# dict4={'a': 'africa', 'c': 'canada', 'd': 'drama', 'ab': 'africa'}

지금까지는 리스트, 튜플과 비슷하게 요소 삭제, 추가와 관련되서 알아보았다면,

딕셔너리만 갖고있는 key와 value 조회할 수 있는 딕셔너리 함수에 대해서 알아보자.

 

딕셔너리변수.values() :값만 표시
딕셔너리변수.keys() : 키만 표시
딕셔너리변수.items()

 

dict5 = {'a':'africa','s':'say','c':'canada','d':'dry','ab':'africa'}
print(dict5.values())
# dict_values(['africa', 'say', 'canada', 'dry', 'africa'])

print(dict5.keys())
# dict_keys(['a', 's', 'c', 'd', 'ab'])

print(dict5.items())
# dict_items([('a', 'africa'), ('s', 'say'), ('c', 'canada'), ('d', 'dry'), ('ab', 'africa')])

 

key() 와 value()를 통해 딕셔너리의 key값과 value 값을 반환받을 수 있었고, 

items()를 통해 (key, value) 를 받을 수가 있었다.

 

 

 

딕셔너리를 리스트로 캐스팅하기 위해서는 list()를 이용해 캐스팅을 진행하면 되지만,

리스트를 딕셔너리를 캐스팅하기 위해서는 enumerate함수를 알아야한다.

enumerate는 열거형 함수로써 예를 들어 [1, 2, 3, 4]를 enumerate 함수에 적용시키게 되면,

0 1

1 3

2 2

3 4

이렇게 요소를 열거하게 된다.

즉, 리스트를 딕셔너리로 바꾸기 위해서는  리스트 -> enumerate(리스트, 문자열, 튜플)->dict 의 구조를 가져야한다.

myList = ['Red','Blue','Green']

#myDict = dict(myList)
temp = enumerate(myList)
print(f'temp={temp}')
print(f'myDict = {myList}')
'''
(0, 'Red')
(1, 'Blue')
(2, 'Green')
'''

---

마지막으로 집합, Set에 대해서 알아보고 마무리를 짓도록 하겠다.

집합의 생성은 집합 변수 = set(리스트/문자열/튜플) 의 구조를 가지며,

특징으로는 순서가 없고, 랜덤하게 출력되며 인덱싱과 슬라이싱이 불가능하다.

 

set1 = set('abcd')
set2 = set([100,200,400,500])
set3 = set(('장미','백합','개나리'))

print('set1 = {}'.format(set1), type(set1))
# set1 = {'a', 'c', 'b', 'd'} <class 'set'>
print('set2 = {}'.format(set2), type(set2))
# set2 = {200, 500, 100, 400} <class 'set'>
print('set3 = {}'.format(set3), type(set3))
# set3 = {'장미', '개나리', '백합'} <class 'set'>

#중복값 불가
set4 =set([100,200,100,50,100])
print('set4 = {}, {}'.format(set4, type(set4)))
# set4 = {200, 50, 100}, <class 'set'>

집합에 값을 추가하기 위해서는 add(값), update([값1, 값2 ...]) 의 형태로 추가해야한다.

print('set1 = {}'.format(set1))
#set1 = {'a', 'c', 'b', 'd'}

set1.add('abc')
print('set1 = {}'.format(set1))
#set1 = {'abc', 'd', 'c', 'a', 'b'}

set1.update(['python','mySQL'])
print('set1 = {}'.format(set1))
#set1 = {'abc', 'd', 'c', 'mySQL', 'a', 'python', 'b'}

집합의 연산으로 union - 합집합, intersection - 교집합이 있으며, 차집합으로는 '-'를 사용한다.

#집합변수3 = 집합변수1 | 집합변수2
#집합변수3 = 집합변수1.union(집합변수2)

userSet1 = set(['박','이','김','최'])
userSet2 = set(['신','김','선우','최'])


userSet3 = userSet1 | userSet2
print(userSet3)
# {'신', '김', '이', '선우', '최', '박'}

userSet4 = userSet1.union(userSet2)
print(userSet4)
# {'신', '김', '이', '선우', '최', '박'}


#교집합
#&, intersection
userSet5 = userSet1.intersection(userSet2)
print("userSet5 : {}".format(userSet5))
#userSet5 : {'최', '김'}

userSet6 = userSet1 & userSet2
print("userSet6 : {}".format(userSet6))
#userSet6 : {'최', '김'}



#차집합
#집합변수3 = 집합변수1 - 집합변수2
#집합변수3 = 집합변수1.difference(집합변수2)

userSet7 = userSet1.difference(userSet2)
print("userSet7 : {}".format(userSet7))
#userSet7 : {'이', '박'}

userSet8 = userSet1 - userSet2
print("userSet8 : {}".format(userSet8))
#userSet8 : {'이', '박'}

이로써 리스트, 튜플, 딕셔너리, 집합에 대해 알아보았다.

앞서 문제를 내었던 Quiz1의 정답을 공개하겠다.

myList1 = ['홍길동', '신데렐라', '알라딘','장화','홍련','지니','엘리스']
myList2 = ['토끼','거북이','물개','펭귄']
myListSum = myList1 + myList2 #리스트 연산
print(f'2개의 리스트 합 : {myListSum}')
print(f'4개만 출력 : {myListSum[:4]}')
print(f'짝수번째만 출력 : {myListSum[1::2]}')#[start:end:step]
print(f'홀수번째만 출력 : {myListSum[0::2]}')
print(f'총 길이 : {len(myListSum)}') # 문자열 길이 나타내는 len()함수 사용

글을 정리하기 앞서 Quiz 2도 한번 풀어보자.

Quiz2

다음 actor_info 딕셔너리 변수를 만들고, 홈페이지, 배우 이름, 최근 출연 영화 갯수를 다음과 같이 출력하세요

actor_info = {'actor_details': {'생년월일': '1971-03-01',
                   '성별': '남',
                   '직업': '배우',
                   '홈페이지': 'https://www.instagram.com/madongseok'},
 'actor_name': '마동석',
 'actor_rate': 59361,
 'date': '2017-10',
 'movie_list': ['범죄도시', '부라더', '부산행']}

배우 이름: 마동석
홈페이지: https://www.instagram.com/madongseok
출연 영화 갯수: 3

 

위와 같이 출력을 해보자.

딕셔너리 값에 접근하기 위해서는 키 값으로 접근을 해야한다.

print(f"배우이름 : {actor_info['actor_name']}")
print(f'홈페이지 : {actor_info["actor_details"]["홈페이지"]}')
print(f'출연 영화 개수 : {len(actor_info["movie_list"])}')

딕셔너리변수['키값'] 의 구조를 통해서 문제를 풀 수가 있었다.