리스트(List)

파이썬이 제공하는 시퀀스 자료구조인 리스트는 C언어 또는 Java언어에서 사용하는 배열(Array)과 가장 흡사하고, 스택(stack)과 큐(Queue)및 데크(Deque)를 구현할 때에도 자주 사용되는 자료구조이다.
list는 여러 element로 구성되어 있으며, 문자열처럼 각 element들에 순서가 있고, 그 순서를 인덱스(index)라 한다.
따라서 인덱싱을 통해 각 element들의 불러들어 올 수 있다.
접근 및 사용이 용이하도록 다양한 기능의 함수를 제공하고 그만큼 많이 쓰이는 자료구조이다.

List 표현

리스트는 대괄호'[]'으로 데이터들을 감싸며 표현하며, 감싸인 데이터들을 요소(element)라고 한다.

element가 없는 비어있는 list(즉, empty_list)도 표현가능하다.

element의 type이 Integer인경우 그대로 표현하고,

string 일 경우 쌍따옴표("") 또는 홀따옴표('')로 감싸서 표현한다.

element는 integer나 string등 같이 표현해도 되고, list안에 list로 element를 표현할 수 있다.

List의 특징을 다음과 같다

• '[ ]'으로 element를 둘러싼다.
• element들의 순서가 있다
• element들의 생성, 삭제, 수정이 가능하다.

>>> a = []
>>> a = list()
>>> b = [1, 2, 3]
>>> C = ['Life', 'is', 'too', 'short']
>>> d = [1, 2, 'Life', 'good']
>>> e = [1, 2, ['Life', 'good']]

List Indexing

List도 string 처럼 순서가 있고 index가 있기때문에, indexing과 sliding이 가능하다.
index번호는 '0'부터 시작한다

>>> a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[0]
1

indexing을 통해 출력한 element들의 value를 연산하여 출력도 가능하다.

>>> a[0] + a[2]
4

어떠한 List든, list의 맨 마지막 index는 '-1'이다

>>> a[-1]
3

복잡한 list에서 indexing도 가능하다

>>> a = [1, 2, 3, ['a' ,'b' ,'c']]
>>> a[0]
1

>>> a[-1]
['a' ,'b' ,'c']

>>> a[3]
['a' ,'b' ,'c']

>>> a[-1][0]
'a'

>>> a[-1][1]
'b'

>>> a[-1][2]
'c'

List Sliding

Sting과 마찬가지로 List에서도 sliding 기법을 적용할 수 있다.
Sliding은 '나눈다'라는 뜻을 가지고 있다.
변수뒤에 '[start:stop:step]'를 붙여 sliding한다
start : 시작index번호
stop : 끝나는 index번호(단, 포함하지 않음)
step : index간 step(간격)

>>> a = [1, 2, 3, 4, 5]
>>> a[0:2]
[1, 2]

>>> a[:2]
[1, 2]

>>> a[2:]
[3, 4, 5]

>>> a[:5]
[1, 2, 3, 4, 5]

>>> a[:4:2]
[1, 3]

List 연산

List 역시 연산기호를 사용하여 element의 값을 서로 연산하여 표현이 가능하다.
그러나 다른 type같에 결과는 TypeError로 연산하지 못한다.

List 더하기 '+'

# '+'
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]

List 반복하기 '*'

# '*'
>>> a = [1, 2, 3]
>>> a * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

List 연산 TypeError

a[2]에 저장된 값은 3이라는 정수인데 "hi"는 문자열이다. 정수와 문자열은 당연히 서로 더할 수 없기 때문에 형 오류가 발생한 것이다

# TypeError
>>> a = [1, 2, 3]
>>> a[2] + "hi"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

만약 숫자와 문자열을 더해서 '3hi'처럼 만들고 싶다면 숫자 3을 문자 '3'으로 바꾸어 주어야 한다. 다음과 같이 할 수 있다

>>> a = [1, 2, 3]
>>> str(a[2]) + "hi"
'3hi'

List 길이

len()함수

List의 길이를 구하기 위해서는 'len()'함수를 사용한다.
길이는 index와 다른개념이다

# len()
>>> a = [1, 2, 3]
>>> len(a)
3
# 길이는 3 , index는 0, 1, 2

List 관련 함수

List 수정

>>> a = [1, 2, 3]
>>> a[2] = 4
>>> a
[1, 2, 4]

del 함수

del a[x]는 x번째 요솟값을 삭제한다. 여기에서는 a 리스트에서 a[1]을 삭제하는 방법을 보여준다. del 함수는 파이썬이 자체적으로 가지고 있는 삭제 함수이며 다음과 같이 사용한다.

>>> a = [1, 2, 3]
>>> del a[1]
>>> a
[1, 3]

다음처럼 슬라이싱 기법을 사용하여 리스트의 요소 여러 개를 한꺼번에 삭제할 수도 있다.

>>> a = [1, 2, 3, 4, 5]
>>> del a[2:]
>>> a
[1, 2]

append()

append를 사전에서 검색해 보면 "덧붙이다, 첨부하다"라는 뜻이 있다. 이 뜻을 안다면 다음 예가 바로 이해될 것이다. append(x)는 리스트의 맨 마지막에 x를 추가하는 함수이다.

>>> a = [1, 2, 3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]

리스트 안에는 어떤 자료형도 추가할 수 있다.
다음 예는 리스트에 다시 리스트를 추가한 결과이다.

>>> a.append([5,6])
>>> a
[1, 2, 3, 4, [5, 6]]

sort()

sort 함수는 리스트의 요소를 순서대로 정렬해 준다.

>>> a = [1, 4, 3, 2]
>>> a.sort()
>>> a
[1, 2, 3, 4]

문자 역시 알파벳 순서로 정렬할 수 있다.

>>> a = ['a', 'c', 'b']
>>> a.sort()
>>> a
['a', 'b', 'c']

reverse()

reverse 함수는 리스트를 역순으로 뒤집어 준다. 이때 리스트 요소들을 순서대로 정렬한 다음 다시 역순으로 정렬하는 것이 아니라 그저 현재의 리스트를 그대로 거꾸로 뒤집는다.

>>> a = ['a', 'c', 'b']
>>> a.reverse()
>>> a
['b', 'c', 'a']

index()

index(x) 함수는 리스트에 x 값이 있으면 x의 위치 값을 돌려준다.

>>> a = [1,2,3]
>>> a.index(3)
2
>>> a.index(1)
0

다음 예에서 값 0은 a 리스트에 존재하지 않기 때문에 값 오류(ValueError)가 발생한다.

>>> a = [1,2,3]
>>> a.index(0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 0 is not in list

insert()

insert(a, b)는 리스트의 a번째 위치에 b를 삽입하는 함수이다. 파이썬에서는 숫자를 0부터 센다는 것을 반드시 기억하자.

>>> a = [1, 2, 3]
>>> a.insert(0, 4)
>>> a
[4, 1, 2, 3]

위 예는 0번째 자리, 즉 첫 번째 요소(a[0]) 위치에 값 4를 삽입하라는 뜻이다.

>>> a.insert(3, 5)
>>> a
[4, 1, 2, 5, 3]

위 예는 리스트 a의 a[3], 즉 네 번째 요소 위치에 값 5를 삽입하라는 뜻이다.

remove()

remove(x)는 리스트에서 첫 번째로 나오는 x를 삭제하는 함수이다.

>>> a = [1, 2, 3, 1, 2, 3]
>>> a.remove(3)
>>> a
[1, 2, 1, 2, 3]

a가 3이라는 값을 2개 가지고 있을 경우 첫 번째 3만 제거되는 것을 알 수 있다.

>>> a.remove(3)
>>> a
[1, 2, 1, 2]

pop()

pop()은 리스트의 맨 마지막 요소를 돌려주고 그 요소는 삭제한다.

>>> a = [1,2,3]
>>> a.pop()
3
>>> a
[1, 2]

a 리스트 [1, 2, 3]에서 3을 끄집어내고 최종적으로 [1, 2]만 남는 것을 볼 수 있다.
pop(x)는 리스트의 x번째 요소를 돌려주고 그 요소는 삭제한다.

>>> a = [1,2,3]
>>> a.pop(1)
2
>>> a
[1, 3]

a.pop(1)은 a[1]의 값을 끄집어낸다. 다시 a를 출력해 보면 끄집어낸 값이 삭제된 것을 확인할 수 있다.

count()

count(x)는 리스트 안에 x가 몇 개 있는지 조사하여 그 개수를 돌려주는 함수이다.

>>> a = [1,2,3,1]
>>> a.count(1)
2

1이라는 값이 리스트 a에 2개 들어 있으므로 2를 돌려준다.

extend()

extend(x)에서 x에는 리스트만 올 수 있으며 원래의 a 리스트에 x 리스트를 더하게 된다.

>>> a = [1,2,3]
>>> a.extend([4,5])
>>> a
[1, 2, 3, 4, 5]
>>> b = [6, 7]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6, 7]

a.extend([4, 5])는 a += [4, 5]와 동일하다.

>>> a = [1, 2, 3]
>>> a += [4, 5]
>>> a
[1, 2, 3, 4, 5]

List 함수 정리

• count(원소) : 리스트 내 특정 원소가 몇 개 포함되어 있는지 반환
• index(원소) : 리스트 내 특정 원소의 인덱스를 반환
• append(원소) :리스트의 뒤쪽에 새로운 원소를 삽입
• sort() : 리스트를 오름차순으로 정렬
• extend(리스트) : 리스트의 뒤쪽에 다른 리스트를 삽입
• insert(인덱스, 원소) : 특정한 위치(인덱스)에 원소를 삽입
• remove(원소) : 리스트 내 특정 원소를 삭제
• pop(인덱스) : 리스트 내 특정 인덱스의 원소를 삭제
• reverse() : 리스트의 순서를 뒤집기

---

튜플(Tuple)

Tuple은 element들을 '()'로 감싸고 있어 List와 비슷한 역할을 하지만, 다른 특성을 가지고 있다.
Tuple은 List처럼 elemnet들의 순서가 있지만 element값을 변경할 수 없다.
Tuple의 특징을 다음과 같다

• '( )'으로 element를 둘러싼다.
• element들의 순서가 있다
• element들의 생성, 삭제, 수정이 불가능하다.

Tuple 표현

Tuple은 element를 둘러싸을때 '()'으로 감싼다
element들을 '()'를 감싸지 않아도 tuple로 표현된다
tuple안에 tuple을 element를 넣어 복잡하게 표현도 가능하다

>>> a = (1, 2, 3)
>>> a
(1, 2, 3)
>>> b = 3, 4, 5
(3, 4, 5)
>>> c = ('a', 'b', ('ab', 'cd'))
('a', 'b', ('ab', 'cd'))

tuple 삭제 수정 정말 안되나?

tuple element 삭제 시

>>> t1 = (1, 2, 'a', 'b')
>>> del t1[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

tuple element 수정 시

>>> t1 = (1, 2, 'a', 'b')
>>> t1[0] = 'c'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Tuple 관련 함수

Tuple indexing

>>> t1 = (1, 2, 'a', 'b')
>>> t1[0]
1
>>> t1[3]
'b'

Tuple sliding

>>> t1 = (1, 2, 'a', 'b')
>>> t1[1:]
(2, 'a', 'b')

Tuple 더하기

>>> t1 = (1, 2, 'a', 'b')
>>> t2 = (3, 4)
>>> t1 + t2
(1, 2, 'a', 'b', 3, 4)

Tuple 곱하기

>>> t2 = (3, 4)
>>> t2 * 3
(3, 4, 3, 4, 3, 4)

Tuple 길이

>>> t1 = (1, 2, 'a', 'b')
>>> len(t1)
4

---

딕셔너리(Dictionary)

데이터가 다양해지고 속성과 값들의 표현들이 많아져 단순 List나 tuple로 데이터를 표현하기가 힘들다. 따라서 데이터들의 대응관계(속성과 값)를 잘 나타낼 수 있는 자료형이 딕셔너리(Dictionary)이다.
즉, 사전이라는 의미로 예를들어 "people"이라는 단어에 "사람"그리고 "baseball"이라는 단어에는 "야구"라는 뜻을 부합시키듯, Dictionary에서도 Key와 Value로 한 쌍을 이루어 element를 갖는다.

그러나 element들은 순서를 갖지 않고, dictionary에서 원하는 element를 찾고자하면 element의 key를 통해 value를 얻을 수 있다. 마치 사전에서 "baseball"의 뜻을 찾기위해 "baseball"를 찾는 것과 같다

Dictionary 표현

{Key1:Value1, Key2:Value2, Key3:Value3, ...}

Key와 Value의 쌍 여러 개가 { }로 둘러싸여 있다. 각각의 요소는 Key : Value 형태로 이루어져 있고 쉼표(,)로 구분되어 있다.

dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}

위에서 Key는 각각 'name', 'phone', 'birth'이고, 각각의 Key에 해당하는 Value는 'pey', '0119993323', '1118'이 된다.

Key	Value
name	pey
phone	01199993323
birth	1118

다음 예는 Key로 정수 값 1, Value로 문자열 'hi'를 사용한 예이다.

>>> a = { 1 : 'hi }

또한 다음 예처럼 Value에 리스트도 넣을 수 있다.

>>> a = { 'a' : [1, 2, 3] }

Dictionary element 추가하기

>>> a = { 1 : 'a' }
>>> a[2] = 'b'
>>> a
{ 1 : 'a', 2 : 'b' }

{1: 'a'} 딕셔너리에 a[2] = 'b'와 같이 입력하면 딕셔너리 a에 Key와 Value가 각각 2와 'b'인 2 : 'b'라는 딕셔너리 쌍이 추가된다.

>>> a['name'] = 'pey'
>>> a
{1: 'a', 2: 'b', 'name': 'pey'}

딕셔너리 a에 'name': 'pey'라는 쌍이 추가되었다.

>>> a[3] = [1,2,3]
>>> a
{1: 'a', 2: 'b', 'name': 'pey', 3: [1, 2, 3]}

Dictionary element 삭제하기

>>> a = {1: 'a', 2: 'b', 'name': 'pey', 3: [1, 2, 3]}
>>> del a[1]
>>> a
{2: 'b', 'name': 'pey', 3: [1, 2, 3]}

위 예제는 딕셔너리 요소를 지우는 방법을 보여 준다. del 함수를 사용해서 del a[key]처럼 입력하면 지정한 Key에 해당하는 {key : value} 쌍이 삭제된다.

Dictionary Key-Value 확인

>>> grade = {'pey': 10, 'julliet': 99}
>>> grade['pey']
10
>>> grade['julliet']
99

>>> a = {1:'a', 2:'b'}
>>> a[1]
'a'
>>> a[2]
'b'

>>> dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> dic['name']
'pey'
>>> dic['phone']
'0119993323'
>>> dic['birth']
'1118'

Dictionary 만들 시 주의사항

먼저 딕셔너리에서 Key는 고유한 값이므로 중복되는 Key 값을 설정해 놓으면 하나를 제외한 나머지 것들이 모두 무시된다는 점을 주의해야 한다. 다음 예에서 볼 수 있듯이 동일한 Key가 2개 존재할 경우 1:'a' 쌍이 무시된다.

>>> a = {1:'a', 1:'b'}
>>> a
{1: 'b'}

Key에 리스트는 쓸 수 없다는 것이다. 하지만 튜플은 Key로 쓸 수 있다. 딕셔너리의 Key로 쓸 수 있느냐 없느냐는 Key가 변하는 값인지 변하지 않는 값인지에 달려 있다. 리스트는 그 값이 변할 수 있기 때문에 Key로 쓸 수 없다. 다음 예처럼 리스트를 Key로 설정하면 리스트를 키 값으로 사용할 수 없다는 오류가 발생한다

>>> a = {[1,2] : 'hi'}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Dictionary 관련 함수

keys()

>>> a = {'name': 'pey', 'phone': '0119993323', 'birth': '1118'}
>>> a.keys()
dict_keys(['name', 'phone', 'birth'])

a.keys()는 딕셔너리 a의 Key만을 모아서 dict_keys 객체를 돌려준다.

python 3.0 이상버전에서는 keys()반환값으로 List가 필요할 경우에는 list(a.keys()) 를 사용하면된다.
dict_keys 객체를 리스트로 변환하려면 다음과 같이 하면 된다.

>>> list(a.keys())
['name', 'phone', 'birth']

values()

Key를 얻는 것과 마찬가지 방법으로 Value만 얻고 싶다면 values 함수를 사용하면 된다. values 함수를 호출하면 dict_values 객체를 돌려준다.

>>> a.values()
dict_values(['pey', '0119993323', '1118'])

items()

items 함수는 Key와 Value의 쌍을 튜플로 묶은 값을 dict_items 객체로 돌려준다. dict_values 객체와 dict_items 객체 역시 dict_keys 객체와 마찬가지로 리스트를 사용하는 것과 동일하게 사용할 수 있다.

>>> a.items()
dict_items([('name', 'pey'), ('phone', '0119993323'), ('birth', '1118')])

clear()

clear 함수는 딕셔너리 안의 모든 요소를 삭제한다. 빈 리스트를 [ ], 빈 튜플을 ( )로 표현하는 것과 마찬가지로 빈 딕셔너리도 { }로 표현한다.

>>> a.clear()
>>> a
{}

get()

get(x) 함수는 x라는 Key에 대응되는 Value를 돌려준다. 앞에서 살펴보았듯이 a.get('name')은 a['name']을 사용했을 때와 동일한 결괏값을 돌려받는다.

>>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> a.get('name')
'pey'
>>> a.get('phone')
'0119993323'

다만 다음 예제에서 볼 수 있듯이 a['nokey']처럼 존재하지 않는 키(nokey)로 값을 가져오려고 할 경우 a['nokey']는 Key 오류를 발생시키고 a.get('nokey')는 None을 돌려준다는 차이가 있다. 어떤것을 사용할지는 여러분의 선택이다.

>>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> print(a.get('nokey'))
None
>>> print(a['nokey'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'nokey'

딕셔너리 안에 찾으려는 Key 값이 없을 경우 미리 정해 둔 디폴트 값을 대신 가져오게 하고 싶을 때에는 get(x, '디폴트 값')을 사용하면 편리하다.

>>> a.get('foo', 'bar')
'bar'

a 딕셔너리에는 'foo'에 해당하는 값이 없다. 따라서 디폴트 값인 'bar'를 돌려준다.

in

'name' 문자열은 a 딕셔너리의 Key 중 하나이다. 따라서 'name' in a를 호출하면 참(True)을 돌려준다. 반대로 'email'은 a 딕셔너리 안에 존재하지 않는 Key이므로 거짓(False)을 돌려준다.

>>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> 'name' in a
True
>>> 'email' in a
False

---

집합 자료형 Set

Set은 python 2.3부터 지원한 자료형으로, 집합에 관련된 것을 쉽게 처리하기 위해 만든 자료형이다.
Set은 다음과 같은 특징이 있다.

• 중복을 허용하지 않는다.
• 순서가 없다(Unodered).

Set 표현

>>> s1 = set([1,2,3])
>>> s1
{1, 2, 3}

>>> s2 = set("Hello")
>>> s2
{'e', 'H', 'l', 'o'}

Set 활용

list, tuple 사전작업

>>> s1 = set([1,2,3])
>>> l1 = list(s1)
>>> l1
[1, 2, 3]
>>> l1[0]
1
>>> t1 = tuple(s1)
>>> t1
(1, 2, 3)
>>> t1[0]
1

집합 자료형 관련 함수들

교집합 '&', intersecion()

>>> s1 & s2
{4, 5, 6}

"&" 기호를 이용하면 교집합을 간단히 구할 수 있다.

>>> s1.intersection(s2)
{4, 5, 6}

또는 위와같이 intersection 함수를 사용해도 동일한 결과를 돌려준다.

합집합 '|', union()

>>> s1 | s2
{1, 2, 3, 4, 5, 6, 7, 8, 9}

합집합은 다음과 같이 구할 수 있다. 이때 4, 5, 6처럼 중복해서 포함된 값은 한 개씩만 표현된다

>>> s1.union(s2)
{1, 2, 3, 4, 5, 6, 7, 8, 9}

또는 union 함수를 사용하면 된다. 교집합에서 사용한 intersection 함수와 마찬가지로 s2.union(s1)을 사용해도 동일한 결과를 돌려준다.

차집합 '-', difference()

>>> s1 - s2
{1, 2, 3}
>>> s2 - s1
{8, 9, 7}

빼기(-) 기호를 사용한 방법이다.

>>> s1.difference(s2)
{1, 2, 3}
>>> s2.difference(s1)
{8, 9, 7}

difference 함수를 사용해도 차집합을 구할 수 있다.

add()

>>> s1 = set([1, 2, 3])
>>> s1.add(4)
>>> s1
{1, 2, 3, 4}

이미 만들어진 set 자료형에 값을 추가할 수 있다. 1개의 값만 추가(add)할 경우에는 다음과 같이 한다.

update()

>>> s1 = set([1, 2, 3])
>>> s1.update([4, 5, 6])
>>> s1
{1, 2, 3, 4, 5, 6}

여러 개의 값을 한꺼번에 추가(update)할 때는 다음과 같이 하면 된다.

remove()

>>> s1 = set([1, 2, 3])
>>> s1.remove(2)
>>> s1
{1, 3}

특정 값을 제거하고 싶을 때는 다음과 같이 하면 된다.