[01] Python 데이터구조 list, tuble, set, Dictionary- 데이터구조란
데이터를 활용 방식에 따라 조금 더 효율적으로 이용할 수 있도록
컴퓨터에 저장하는 여러 방법들
- Python의 데이터 구조는 list, tuble, set, Dictionary
1. list
- 파이썬 프로그래밍 언어 내에서 가장 많이 쓰이는 구조
- 목록은 어떠한 파이썬 자료형이라도 저장할 수 있다.
>>> # 빈 목록을 정의
>>> my_list = []
>>> my_list = list() # 가끔 사용됨
>>> # 하나의 원소를 가진 목록
>>> my_list = [1]
>>> my_list # 번역기에서 변수를 출력하기 위해서 print를 사용할 필요가 없다
[1]
>>> # 문자열 값의 목록을 정의
>>> my_string_list = ['Hello', 'Jython' ,'Lists']
>>> # 복수의 자료형을 포함하는 목록을 정의
>>> multi_list = [1, 2, 'three', 4, 'five', 'six']
>>> # 목록을 포함하는 목록을 정의
>>> combo_list = [1, my_string_list, multi_list]
>>> # 목록을 포함하는 목록을 한 줄로 정의
>>> my_new_list = ['new_item1', 'new_item2', [1, 2, 3, 4], 'new_item3']
>>> print my_new_list
['new_item1', 'new_item2', [1, 2, 3, 4], 'new_item3']
>>> # 목록에서 원소를 얻기
>>> my_string_list[0]
'Hello'
>>> my_string_list[2]
'Lists'
>>> # 음수 인덱스는 목록의 마지막 원소에서 시작하여 첫 항목 쪽으로 거슬러 감
>>> my_string_list[-1]
'Lists'
>>> my_string_list[-2]
'Jython'
>>> # 썰기(썰기는 시작 인덱스의 원소는 포함하고 끝 인덱스의 원소는 제외한다는 점에 유의)
>>> my_string_list[0:2]
['Hello', 'Jython']
>>> # 썰기를 통해 목록의 얕은 사본을 생성
>>> my_string_list_copy = my_string_list[:]
>>> my_string_list_copy
['Hello', 'Jython', 'Lists']
>>> # 목록에서 모든 다른 원소를 반환
>>> new_list=[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
>>> # 시작인덱스:끝인덱스:간격
>>> # 이 예제는 한 칸 씩 이동(step)
>>> new_list[0:10:1]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
>>> # 그리고 여기서는 두 칸 씩 이동
>>> new_list[0:10:2]
[2, 6, 10, 14, 18]
>>> # 시작 인덱스를 비워두면 기본값이 0을 지정한 것과 같이 동작하며,
>>< # 끝 인덱스에 대해서는 목록의 길이가 기본값임
>>> new_list[::2]
[2, 6, 10, 14, 18]
>>> # 목록의 원소를 수정. 이 경우는 9번 위치에 있는 원소를 수정함
>>> new_list[9] = 25
>>> new_list
[2, 4, 6, 8, 10, 12, 14, 16, 18, 25]
>>> # append 메소드를 사용하여 목록에 값들을 추가
>>> new_list=['a','b','c','d','e','f','g']
>>> new_list.append('h')
>>> print new_list
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> # 다른 목록을 기존 목록에 추가
>>> new_list2=['h','i','j','k','l','m','n','o','p']
>>> new_list.extend(new_list2)
>>> print new_list
['a', 'b', 'c', 'd', 'e', 'f', 'g', ‘h’,'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
>>> # 인덱스를 통해 특정 위치에 값을 삽입.
>>> # 이 예제에서는 'c'를 목록에서 3 번째 위치에 추가
>>> # (목록의 인덱스는 0부터 시작하므로, 인덱스 2가 실제로는 세번째 자리를 가리킴을 기억하라)
>>> new_list.insert(2,'c')
>>> print new_list
['a', 'b', 'c', 'c', 'd', 'e', 'f', 'g', 'h', ‘h’,'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
>>> # 인덱스를 통해 특정한 위치로 목록을 삽입
>>> another_list = ['a', 'b', 'c']
>>> another_list.insert(2, new_list)
>>> another_list
['a', 'b', [2, 4, 8, 10, 12, 14, 16, 18, 25], 'c']
>>> # 썰기 표기법을 사용하여 목록 또는 순서의 일부를 덮어씀
>>> new_listA=[100,200,300,400]
>>> new_listB=[500,600,700,800]
>>> new_listA[0:2]=new_listB
>>> print new_listA
[500, 600, 700, 800, 300, 400]
>>> # 빈 썰기 표기법을 사용하여 목록을 다른 목록에 할당
>>> one = ['a', 'b', 'c', 'd']
>>> two = ['e', 'f']
>>> one
['a', 'b', 'c', 'd']
>>> two
['e', 'f']
>>> # 시작과 종료 위치를 동일하게 하여 목록으로부터 빈 조각을 만들어낸다.
>>> # 시작과 끝 위치를 동일하게 쓰는 한, 어느 위치든 상관 없음.
>>> one[2:2]
[]
>>> # 그 자체로는 별로 재미가 없다 - 빈 목록은 아주 쉽게 만들 수 있다.
>>> # 이것에 대해 유용한 점은 이것을 빈 조각에 할당할 수 있다는 것이다.
>>> # 이제, 'two' 목록을 'one'목록의 빈 조각에 할당함으로써 실제로는 'two' 목록을 'one' 목록에 삽입한다.
>>> one[2:2] = two # 'one' 목록의 원소 1과 2 사이를 'two' 목록으로 대체
>>> one
['a', 'b', 'e', 'f', 'c', 'd']
>>> # del 구문을 사용하여 값 또는 값의 범위를 목록으로부터 제거
>>> # 모든 다른 원소가 이동하여 빈 공간을 채움에 유의
>>> new_list3 = ['a','b','c','d','e','f']
>>> del new_list3[2]
>>> new_list3
['a', 'b', 'd', 'e', 'f']
>>> del new_list3[1:3]
>>> new_list3
['a', 'e', 'f']
>>> # del 구문을 사용하여 목록을 제거
>>> new_list3=[1,2,3,4,5]
>>> print new_list3
[1, 2, 3, 4, 5]
>>> del new_list3
>>> print new_list3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'new_list3' is not defined
>>> # pop과 remove 함수를 사용하여 목록으로부터 값을 제거
>>> print new_list
['a', 'b', 'c', 'c', 'd', 'e', 'f', 'g', 'h',’h’, 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
>>> # 인덱스가 2인 원소를 pop
>>> new_list.pop(2)
'c'
>>> print new_list
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',’h’, 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
>>> # 목록에서 처음으로 나타나는 'h' 문자를 제거
>>> new_list.remove('h')
>>> print new_list
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
>>> # pop() 함수를 사용하는 유용한 예제
>>> x = 5
>>> times_list = [1,2,3,4,5]
>>> while times_list:
... print x * times_list.pop(0)
...
5
10
15
20
25
꺼내온 뒤에 내용 없어짐(pop)
2. list 함수 사용하기
>>> # 어떤 주어진 값에 대한 인덱스를 반환 >>> new_list=[1,2,3,4,5,6,7,8,9,10]
>>> new_list.index(4)
3
>>> # 인덱스가 4인 원소의 값을 변경
>>> new_list[4] = 30
>>> new_list
[1, 2, 3, 4, 30, 6, 7, 8, 9, 10]
>>> # 이제, 값을 원상태로 되돌려놓자.
>>> new_list[4] = 5
>>> new_list
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> # 이 목록에 중복된 값을 추가하고 인덱스를 반환
>>> # 처음 나타나는 값의 인덱스를 반환함에 유의
>>> new_list.append(6)
>>> new_list
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 6]
>>> new_list.index(6)
5
>>> # 주어진 값과 동등한 원소의 갯수를 반환하도록 count() 함수를 사용
>>> new_list.count(2)
1
>>> new_list.count(6)
2
>>> # 목록의 값들을 정렬
>>> new_list.sort()
>>> new_list
[1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 10]
>>> # 목록의 값들의 순서를 반대로
>>> new_list.reverse()
>>> new_list
[10, 9, 8, 7, 6, 6, 5, 4, 3, 2, 1]3. tuple
- 변경할 수 없는 lit형
- list형은 일반적으로 동일한 자료형으로 이루어진 항목들을
list내에서 순차적으로 추출하는 용도로 사용되는 반면
- tuple형은 서로다른 종류의 데이터형으로 이루어진 항목들을
바로 풀어쓰는 언패킹 또는 색인을 매기는 용도로 사용한다.
- []아닌 ()기호로 감싸거나 아예 감싸지 않는 방법으로 선언한다.
>>> # 빈 튜플 생성
>>> myTuple = ()
>>> # 튜플 생성하고 사용하기
>>> myTuple2 = (1, 'two',3, 'four')
>>> myTuple2
(1, 'two', 3, 'four')
>>> # 마지막에 쉼표를 써서 한 항목짜리 튜플을 생성하기
>>> myteam = 'Bears',
>>> myteam
('Bears',)
- tuple은 변경할 수 없는 자료형(Immutable)이지만 튜폴항목의
list데이터 형은 변경이 가능한 데이터형이라면 해당 객체 내의
변경이 가능하다.
>>>t2 = [1,2,3],[4,5,6]
>>>t2
([1, 2, 3], [4, 5, 6])
>>>t2[0]
[1, 2, 3]
>>>t2[0] = [7,8,9]
Traceback (most recent call last):
File "C:\Users\lecture\AppData\Local\Enthought\Canopy\User\lib\site-packages\IPython\core\interactiveshell.py", line 2885, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-56-28c2e5ed8f80>", line 1, in <module>
t2[0] = [7,8,9]
TypeError: 'tuple' object does not support item assignment
>>>t2[0][0] = 7
t2
([7, 2, 3], [4, 5, 6])
- 변수 movie에 4개의 서로 다른 자료형이 하나의 튜풀로 포장되었다.
이개념 튜플패키징이라고 하다.
>>>movie ='슈퍼맨',1234,'배트면',4321
>>>movie
- 반대로 아래 예제 처럼 튜플을 항목별로 각각 풀어서 할당하는 개념을 튜플
언패킹이라고 한다.
>>>a,b,c,d = movie
>>>a
>>>b
>>>c
>>>d
4. SET
- 색인에 대한 순서가 없고 중복이 허용되지 않는 데이터들의 집합
- set()함수로만 set생성이 가능하다.
>>> # 집합을 사용하기 위해서는 우선 모듈을 들여와야한다.
>>> from sets import Set
>>> # 다음의 구문을 써서 집합을 생성한다
>>> myset = Set([1,2,3,4,5])
>>> myset
Set([5, 3, 2, 1, 4])
>>> # 집합에 값을 추가. 자세한 내용은 표 2-7을 참조
>>> myset.add(6)
>>> myset
Set([6, 5, 3, 2, 1, 4])
>>> # 중복되는 원소의 추가를 시도
>>> myset.add(4)
>>> myset
Set([6, 5, 3, 2, 1, 4])
>>> # 두 개의 집합을 생성
>>> s1 = Set(['jython','cpython','ironpython'])
>>> s2 = Set(['jython','ironpython','pypy'])
>>> # 집합의 사본을 만듦
>>> s3 = s1.copy()
>>> s3
Set(['cpython', 'jython', 'ironpython'])
>>> # s1에는 속하지만 s2에는 속하지 않는 모든 원소를 포함하는 새로운 집합을 구함
>>> s1.difference(s2)
Set(['cpython'])
>>> # 각 집합의 모든 원소를 포함하는 새로운 집합을 구함
>>> s1.union(s2)
Set(['cpython', 'pypy', 'jython', 'ironpython'])
>>> # 각 집합에 속하되 양쪽 모두에는 속하지 않는 원소로 이루어진 새로운 집합을 구함
>>> s1.symmetric_difference(s2)
Set(['cpython', 'pypy'])
>>> # 세 개의 집합을 생성
>>> s1 = Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> s2 = Set([5, 10, 15, 20])
>>> s3 = Set([2, 4, 6, 8, 10])
>>> # s2로부터 임의의 원소를 제거
>>> s2.pop()
20
>>> s2
Set([5, 15, 10])
>>> # s1에 3과 동일한 원소가 존재하는 경우 폐기
>>> s1.discard(3)
>>> s1
Set([6, 5, 7, 8, 2, 9, 10, 1, 4])
>>> # s1과 s2 양쪽 모두에 속하는 원소들만을 가지도록 s1을 갱신
>>> s1.intersection_update(s2)
>>> s1
Set([5, 10])
>>> s2
Set([5, 15, 10])
>>> # s2의 모든 원소를 제거
>>> s2.clear()
>>> s2
Set([])
>>> # 집합 s3의 모든 원소를 포함하도록 s1을 갱신
>>> s1.update(s3)
>>> s1
Set([6, 5, 8, 2, 10, 4])
5. Dictionary- 전체항목이 정렬되지 않는 키(key)와 값(Value)의 쌍으로 구성된 집합
>>> # 빈 사전 및 채워진 사전을 생성
>>> myDict={}
>>> myDict.values()
[]
>>> # 사전에 열쇠-값 쌍을 할당
>>> myDict['one'] = 'first'
>>> myDict['two'] = 'second'
>>> myDict
{'two': 'second', 'one': 'first'}
>>> # 빈 사전을 생성하고 사전을 채움
>>> mydict = {}
>>> # 사전에서 열쇠를 찾아봄
>>> 'firstkey' in mydict
False
>>> # 사전에 열쇠/값 쌍을 추가
>>> mydict['firstkey'] = 'firstval'
>>> 'firstkey' in mydict
True
>>> # 사전의 값들을 나열
>>> mydict.values()
['firstval']
>>> # 사전의 열쇠들을 나열
>>> mydict.keys()
['firstkey']
>>> # 사전의 길이(열쇠/값 쌍이 얼마나 들어있는지)를 표시
>>> len(mydict)
1
>>> # 사전의 내용을 출력
>>> mydict
{'firstkey': 'firstval'}
>>> # 원본 사전을 문자열 기반 열쇠를 가진 사전으로 대체
>>> # 다음의 사전은 하키 팀을 표현
>>> myDict = {'r_wing':'Josh','l_wing':'Frank','center':'Jim','l_defense':'Leo','r_defense':'Vic'}
>>> myDict.values()
['Josh', 'Vic', 'Jim', 'Frank', 'Leo']
>>> myDict.get('r_wing')
'Josh'
>>> myDict['r_wing']
'Josh'
>>> # 존재하지 않는 열쇠에 대한 값을 얻기 위해 시도
>>> myDict['goalie']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'goalie'
>>> # get()을 사용하여 존재하지 않는 열쇠에 대한 값을 얻기 시도
>>> myDict.get('goalie')p
>>>
>>> # 열쇠가 존재하지 않는 경우 기본 메시지를 표시
>>> myDict.get('goalie','Invalid Position')
'Invalid Position'
>>> # 사전의 항목들에 대하여 반복
>>> for player in myDict.iteritems():
... print player
...
('r_wing', 'Josh')
('r_defense', 'Vic')
('center', 'Jim')
('l_wing', 'Frank')
('l_defense', 'Leo')
>>> # 열쇠와 값을 독립적인 개체에 할당한 다음 출력
>>> for key,value in myDict.iteritems():
... print key, value
...
r_wing Josh
r_defense Vic
center Jim
l_wing Frank
l_defense Leo