파이썬 - 2

이번엔 복습 차원에서 데이터 타입(자료형)에 대해서 알아보려고 한다.

리스트 (list)

리스트는 지금까지 본 자료형들을 모아둔 데이터 타입이다. 대괄호([])안에 자료형들을 여러개를 저장하고 불러올 수 있다. a라는 리스트에 저장된 개수를 n이라고 할 때, 저장된 값이 차지하는 공간?은 a[0]에서 a[n-1]이 된다.

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

print(a[0])
> 1

print(a[4])
> 5

두 개의 리스트를 더하거나 리스트에 수를 곱할 수도 있다.

a = [1,2,3,4,5]
b = [5,6,7,8,9]
c = a + b
print(c)
> [1,2,3,4,5,6,7,8,9]

a = [1,2,3]
print(a * 3)
> [1,2,3,1,2,3,1,2,3]

리스트 안에서 원하는 인자를 뽑아오고 싶을 때는 콜론(:)을 사용한다

a = [1,2,3,4,5]
print(a[:])
> [1,2,3,4,5]

print(a[2:])
> [3,4,5]

print(a[:4])
> [1,2,3,4]

print(a[::2])
> [1,3,5]

print(a[1:5:2])
> [2,4]

리스트 메소드

리스트에 인자를 추가하거나 제거하고 싶을 때에 사용할 수 있는 메소드들이 있다. 사용하는 방법은 변수명.메소드('인자')로 사용할 수 있다.
append() : 리스트 맨 마지막에 인자 하나를 추가한다.
insert() : 리스트안의 원하는 위치에 인자를 삽입한다.
extend() : 리스트 맨 마지막에 인자 여러 개를 추가한다.
remove() : 일치하는 인자가 있을 경우, 일치하는 인자들 중 맨 앞의 항목을 하나 제거한다.
pop() : 리스트 안에 있는 인자 중, 맨 마지막 인자를 제거하고 위치를 반환한다.
index() : 일치하는 인자들 중 첫번째 항목의 위치를 반환한다.
count() : 일치하는 인자의 개수를 반환한다.
sort() : 숫자나 문자로 된 인자를 순방향(오름차순)으로 정렬한다.
reverse() : 숫자나 문자로 된 인자를 역방향(내림차순)으로 정렬한다.

list1 = ['a','b','c','d']

list1.append('e')
print(list1)
> ['a','b','c','d','e']

list1.insert(2, 'f')
print(list1)
> ['a','b','f','c','d','e']

list1.extend(['g','h','i'])
print(list1)
> ['a','b','f','c','d','e','g','h','i']

list1.remove('f')
print(list1)
> ['a', 'b', 'c', 'd', 'e', 'g', 'h', 'i']

poplist = list1.pop()
print(poplist, list1)
> h ['a', 'b', 'c', 'd', 'e', 'g']

indexlist = list1.index('e')
print(indexlist, list1)
> ['a', 'b', 'c', 'd', 'e', 'g']

list1  = ['a', 'e', 'g', 'b', 'c', 'd', 'e', 'e']
countlist = list1.count('e')
print(countlist)
> 3

list1 = ['a', 'e', 'g', 'b', 'c', 'd']
list1.sort()
print(list1)
> ['a', 'b', 'c', 'd', 'e', 'g']

list1.reverse()
print(list1)
> ['g', 'e', 'd', 'c', 'b', 'a']

튜플 (tuple)

튜플은 소괄호 () 를 이용하며 리스트와 유사하게 인자들을 묶어주는 역할을 한다. 하지만, 리스트와 다르게 인자를 변형할 수 없다. 그래서 인자를 변형하지 않고 유지해야할 때 주로 사용한다.

a = (1,2,3,4)
print(a)
> (1,2,3,4)

type(a)
> tuple

a[1]
> 2

만약 튜플의 값을 바꾸려 한다면?
a[2] = 5
> TypeError                                 Traceback (most recent call last)
<ipython-input-36-dec41322dc24> in <module>()
----> 1 a[2] = 5

TypeError: 'tuple' object does not support item assignment

TypeError가 발생한다.

만약 인자가 하나만 있는 튜플을 생성할 때는 뒤에 ,(쉼표)를 적어준다.

a = (5,)
print(a)
> (5,)

그래서 튜플은 튜플 안의 값을 변형하는 것 말고는 리스트의 메소드를 사용할 수 있다.

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

a.index(3)
> 2

세트 (set)

세트는 중괄호 {} 를 이용하며, 값의 순서나 중복이 되지 않는 데이터 타입이다. 수학의 집합 개념(합집합, 교집합, 차집합)을 이용할 수 있도록 해주는 데이터 타입이기도 하다.

set1 = {1,2,3,3,5}
set2 = {3,4,5,6}
print(set1, set2)
> {1,2,3,5}
> {3,4,5,6}

세트의 집합

앞서 말한 것 처럼 세트는 수학의 집합 개념을 사용할 수 있도록 만들어졌다.
합집합은 데이터명.union(비교 데이터명) 또는 데이터명|비교 데이터명 으로 표현할 수 있으며, 두 개의 데이터에 있는 값 모두를 출력한다. 논리연산자의 or와 같은 역할인 것 같다.
교집합은 데이터명.intersaction(비교 데이터명) 또는 데이터명&비교 데이터명으로 표현할 수 있고, 두 데이터의 중복된 인자를 출력한다. 논리연산자의 and와 같은 역할을 하는 것 같다.
차집합은 데이터명.difference(비교 데이터명) 또는 데이터명 - 비교 데이터명으로 표현할 수 있으며, 데이터에 있는 인자들 중 비교 데이터에 포함된 인자들을 빼고 출력한다. 논리연산자의 not과 비슷하지 않을까? 참고로 차집합은 어떤 데이터를 앞에 두느냐에 따라 결과값이 다르다.

set1 = {1,2,3,3,5}
set2 = {3,4,5,6}

합집합
set1.union(set2)
> {1, 2, 3, 4, 5, 6}

set1|set2
> {1, 2, 3, 4, 5, 6}

교집합
set1.intersection(set2)
> {3, 5}

set1 & set2
> {3, 5}

차집합
set1.difference(set2)
> {1, 2}

set2 - set1
> {4, 6}

차집합은 어떤 데이터가 먼저 오냐에 따라 결과값이 달라지는 걸 확인할 수 있다.

딕셔너리 (dictionary)

딕셔너리는 말 그대로 사전으로 키(key):값(value)의 형태를 가지며, 세트와 같이 중괄호 {} 로 표현할 수 있다.

dict1 = {'키1' : '값1', '키2' : '값2'}
dict1['키3'] = '값3'
print(dict1)
> {'키1': '값1', '키2': '값2', '키3': '값3'}

딕셔너리는 키 값이 중복되면 가장 최근에 입력된 값을 가지게 되며 이전에 입력된 값은 지워지게 된다.

dict1['키1'] = '커피'
print(dict1)
> {'키1': '커피', '키2': '값2', '키3': '값3'}

또한 리스트, 튜플, 세트도 그렇지만, 다차원으로 값을 입력할 수 있다. (대충 리스트 형태로 값을 가질 수 있다는 얘기)

dict1['키2'] = [1,2,3,4,5]
print(dict1)
> {'키1': '커피', '키2': [1, 2, 3, 4, 5], '키3': '값3'}

딕셔너리 메소드

딕셔너리에서는 keys(), values(), items(), update(), clear()라는 메소드를 사용할 수 있다.

keys() : 딕셔너리의 키를 반환한다.
values() : 딕셔너리의 값을 반환한다.
items() : 딕셔너리의 키와 값을 모두 반환한다.
update(딕셔너리2) : 딕셔너리1에 딕셔너리2를 추가할 수 있다. 물론 이때, 딕셔너리2에 중복되는 키값이 있다면 딕셔너리2의 밸류값으로 덮어 씌워진다.
clear() : 딕셔너리에 있는 데이터를 모두 지운다.

dict1.keys()
> dict_keys(['키1', '키2', '키3'])

dict1.values()
> dict_values(['커피', [1, 2, 3, 4, 5], '값3'])

dict1.items()
> dict_items([('키1', '커피'), ('키2', [1, 2, 3, 4, 5]), ('키3', '값3')])

dict2 = {'키3' : '노트북', '키4' : '값4', '키5' : '값5'}
dict1.update(dict2)
print(dict1)
> {'키1': '커피', '키2': [1, 2, 3, 4, 5], '키3': '노트북', '키4': '값4', '키5': '값5'}

dict1.clear()
print(dict1)
> {}

만약 어떤 키에 대해 원하는 값을 반환하고 싶다면, dict1[키값]을 요구하면 된다. !

dict1 = {'키1': '커피', '키2':[1, 2, 3, 4, 5]), '키3': '값3'}
print(dict1['키2'])
> [1, 2, 3, 4, 5]