당신은 멋쟁이, 우리는 장고쟁이~

0%

Python-기초-6편-Data-Type-튜플-리스트-사전

작성일 In , Disqus:

Python Data Type


데이터 타입


데이터 타입은, 값의 종류를 결정하고, 어떤식으로 값이 사용될지에 대해 결정합니다. 파이썬에 모든 데이터 값들은, 연관되어 있는 객체 클래스로 캡슐화 됩니다.


파이썬 데이터 타입들은, 아래와 같은 종류들이 존재합니다.


데이터 타입 비고
숫자형 (Numbers) 숫자로 생성된 객체로, immutable 합니다. 3가지 수의 타입이 존재합니다. 1. 정수 (integer)2. 실수 (float)3. 복소수 (complex)
불리언 (Boolean) 파이썬에서 가장 간단한 내장 타입으로, True 와 False 를 표현합니다.
문자열 (string) 파이썬에서, 문자열 객체는 왼쪽에서부터 오른쪽으로 방향으로 순서가 있는 객체 입니다. 이를, sequence 라고 표현합니다. 문자열은, ‘ 혹은 “ 으로 감싸지는 데이터 입니다. 문자열은 immutable 합니다
튜플 (Tuples) 튜플은 () 안에 , 로 분리된 값들 입니다튜플은 immutable 하고, 여러 데이터 타입을 가지고 있을수 있습니다.
리스트 (Lists) 리스트는 [] 안에 , 로 분리된 값들 입니다. 아무런 원소도 가지고 있지 않은 리스트를 빈 리스트라고 부릅니다. 리스트는 mutable 합니다
집합 (Sets) 집합은 순서가 없는 고유한 원소들의 집합입니다. 기본 사용은, 교집합, 합집합, 차집합, 합집합 같은 집합 이론을 다루거나, 혹은, 중복된 것들을 없애기 위해 사용할수 있습니다.
사전 (Dictionaries) 파이썬 사전은, 리스트같이 순서가 없는 객체들의 집합의 컨테이너 입니다. 객체는 {} 로 감싸져 있고. key : value 형태로, 한 쌍으로 존재합니다. 각 객체 혹은 값은, key 값으로 접근이 가능하고, key 값들은 사전안에서 고유합니다. key 가 인덱싱을 할때 사용되므로, 이 key 는 immutable 타입이여야 합니다 (문자열, 숫자 혹은 튜플).
None 하나의 값을 가지고 있는 타입으로, 내장 예약어 None 으로 접근이 가능합니다. 값이 없는것을 여러 상황에서 강조하기 위해서 사용됩니다.

지난 포스팅에서는, 문자열까지 알아보았고.


이번 포스팅에서는, 튜플, 리스트, 집합, 사전, None 까지 알아봅니다



Tuples (튜플)


튜플은, , 로 분리된 값 (항목 혹은 요소)를 () 안에 가지고 있는 자료형 입니다.

튜플은 immutable 합니다. (한번 생성되면, 그 안의 값을 바꿀수가 없습니다.)
그리고, 튜플은, 여러 데이터 타입을 가질수 있습니다.


튜플 생성하기


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 튜플 생성하기 
# 정수, 실수, 문자열을 가진 튜플을 생성 
# () 안에 데이터를 , 로 분리하고 변수에 할당하면 생성됩니다. 

tup = (0, -1, 12, 2123.44, 100, 'Django')
print(tup)
print(type(tup))

# 문자열 3개, 숫자 1개로 이루어진 튜플 생성 

tup2 = ('python', 'Django', 200, 'GoLang')
print(tup2)
print(type(tup2))

# () 를 사용하지 않고 생성하는 방법 
tup3 = "Django", "Python", "JavaScript"
print(tup3)
print(type(tup3))

# 비어있는 튜플을 생성하기 
empty_tup = () 
print(empty_tup)
print(type(empty_tup))

# 1개의 데이터만 가진 튜플 생성하기 
single_tup = (100)
print(single_tup)
print(type(single_tup))

# 값이 한개일때, 요소의 끝에 , 를 붙여줘야 1개의 값을 가진 튜플이 생성됩니다. 
single_tup = (100,)
print(single_tup)
print(type(single_tup))

튜플 인덱싱 하기


문자열이랑 비슷하게도, 튜플 요소들도 인덱스를 통해 접근할수 있습니다. 예를들면, tup=('d', 'j', 'a', 'n', 'g', 'o') 라는 튜플을 생성하였을때 생성되는 인덱스는 아래와 같습니다.


데이터 D j a n g o
인덱스(왼쪽) 0 1 2 3 4 5
인덱스(오른쪽) -6 -5 -4 -3 -2 -1

이러한 인덱스를 통해서, 각 요소에 접근을 해보기 위해, 아래 예시를 참조합니다. 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
tup = ('d', 'j', 'a', 'n', 'g', 'o')

print(tup[0])
print(tup[1])
print(tup[2])
print(tup[3])
print(tup[4])
print(tup[5])

print()

print(tup[-1])
print(tup[-2])
print(tup[-3])
print(tup[-4])
print(tup[-5])
print(tup[-6])

Tuple 은 immutable 합니다.

튜플 안에 항목이나 요소들의 값은 바뀌거나 수정될수 없습니다.


튜플 안에 있는 값을 바꾸려고 하면, 아래와 같이 에러가 납니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
# tuple 은 immutable 합니다. 
# 값을 바꿀수 없습니다. 값을 바꾸려 하면, 에러가 납니다. 

tup = ('d', 'j', 'a', 'n', 'g', 'o')
tup[1] = 'b'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-13-253c803b15bb> in <module>
      3 
      4 tup = ('d', 'j', 'a', 'n', 'g', 'o')
----> 5 tup[1] = 'b'

TypeError: 'tuple' object does not support item assignment

또한, 인덱스 범위를 넘어가는 요소를 접근하려 하면, index error 가 발생 합니다.


튜플 슬라이싱 하기


문자열과 같은 시퀀스와 비슷하게, 튜플도 슬라이스가 가능합니다.


튜플을 슬라이싱 하면, 새로운 튜플을 생성하지만, 기존 값을 변경하지는 않습니다.


예를들면, 


1
2
3
4
5
6
# 튜플 슬라이싱 하기 

tup = ('d', 'j', 'a', 'n', 'g', 'o')

print(tup[0:3])
print(tup[2:5])

튜플에서 +, * 같은 연산자 사용하기


+ 연산자를 사용하여, 튜플들을 합친, 새로운 튜플을 생성하고, * 연산자를 사용하여, 하나의 튜플을 반복할수 있습니다. 예를들면, 


1
2
3
4
5
6
7
8
9
10
11
# +, * 연산자 사용하기 

tup = ('d', 'j', 'a', 'n', 'g', 'o')

tup1 = ('p', 'y', 't', 'h', 'o', 'n')

add_tuples = tup + tup1  # tup 과 tup1 을 합친 새로운 튜플을 생성합니다. 
print(add_tuples)

# tup 을 *을 사용하여 반복합니다 
print(tup * 4)


Lists (리스트)


리스트는, , 로 분리된 값을 [] 안에 가지고 있는 자료형 입니다. 튜플과 비슷하게, 리스트 안의 요소들은 같은 데이터 타입을 가질 필요는 없습니다.


리스트 생성하기


1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 리스트 생성하기 
# , 로 분리된 값들을 [] 안에 넣어주면 생성됩니다. 
list1 = [1, 2, 3, 4, 5]
list2 = ['django', 'python', 'javascript', 'GoLang']
list3 = [12, 'developer', 32.33]

print(list1)
print(list2)
print(list3)

# 비어 있는 리스트를 생성
# [] 안에 아무 값도 넣어주지 않으면 비어있는 리스트가 생성됩니다 
empty_list = []
print(empty_list)


리스트 인덱싱 하기


문자열과 비슷하게, 리스트도 순회 가능한, 그리고 인덱싱이 가능한 자료형입니다. 리스트 인덱스도 왼쪽에서 오른쪽으로 갈때 0으로부터 시작하고, 오른쪽에서 왼쪽으로 갈때는, -1 로 시작합니다.


예를들면,


list1 = ['d', 'j', 'a', 'n', 'g', 'o'] 라는 리스트를 생성하였을때에 인덱스는 아래와 같습니다.


데이터 D j a n g o
인덱스(왼쪽) 0 1 2 3 4 5
인덱스(오른쪽) -6 -5 -4 -3 -2 -1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 리스트 슬라이싱 하기 

list1 = ['d', 'j', 'a', 'n', 'g', 'o']
print(list1[0])
print(list1[1])
print(list1[2])
print(list1[3])
print(list1[4])
print(list1[5])
print()
print(list1[-1])
print(list1[-2])
print(list1[-3])
print(list1[-4])
print(list1[-5])
print(list1[-6])

# 문자열이나 튜플과 비슷하게, 인덱스값을 벗어난 요소를 접근하려 하면 
# 에러가 발생합니다. 


print(list1[6])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-22-3034fc2e792a> in <module>
----> 1 print(list1[6])

IndexError: list index out of range

리스트 슬라이싱 하기


다른 시퀀스형 자료와 비슷하게, 리스트도 슬라이싱이 가능합니다. 튜플이나 문자열을 슬라이싱 하는 방법과 같다고 볼수 있습니다. 예를들면, 


1
2
3
4
5
6
# 리스트 슬라이싱 

list1 = ['d', 'j', 'a', 'n', 'g', 'o']
print(list1[0:3])
print(list1[2:5])
print(list1[1:-2])

리스트는 튜플과 다르게, mutable 객체 입니다!

리스트는 생성후에, 값을 변경할수 있습니다.


리스트의 값 바꿔보기


리스트의 값을 바꿔보는 예시는 아래와 같습니다. 


1
2
3
4
5
6
7
8
9
10
# 리스트는 mutable 합니다 

list1 = ['d', 'j', 'a', 'n', 'g', 'o']

list1[1] = 'b' # 인덱스 1에 해당하는 값을 'b'로 바꿈 
print(list1)

list1[5] = 'u' # 인덱스 5에 해당하는 값을 'u' 로 바꿈 

print(list1)

리스트에 + 와 * 연산자 사용하기


두개의 리스트를 합친 새로운 리스트를 생성하는 + 연산자와, 하나의 리스트를 여러번 반복하는 *를 사용할수 있습니다. 예를들면, 


1
2
3
4
5
6
7
8
9
list1 = ['d', 'j', 'a', 'n', 'g', 'o']
list2 = [12, 'developer', 32.33]
list3 = [1, 2, 3, 4, 5]

list_sum = list1 + list2 # + 연산자를 사용하여, list1 과 list2 를 합친 새로운 리스트를 생성 
print(list_sum)

# * 연산자를 사용하여, list3 을 4번 반복 
print(list3 * 4)

Sets (집합)


집합은, 순서가 없는 고유한 요소들의 집합입니다. 기본 사용은 보통, 수학에서 이야기하는 집합 이론 (합집합, 교집합, 차집합, 합집합 같은 수학적 연산) 들을 다룰때 사용합니다.

혹은, 중복된 요소들을 제거할때에도 사용됩니다.


예시를 들면, 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 중복된 값을 가진 리스트를 생성 
a = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
b = [5, 5, 6, 6, 7, 7, 1, 2]

s1 = set(a)  # a를 집합으로 선언 
s2 = set(b)  # b를 집합으로 선언 

print(s1)
print(s2)

# 차집합 
print(s1 - s2)

# s1 혹은 s2 에 있는 숫자들 
print(s1 | s2)

# s1 그리고 s2 에 있는 숫자들 
print(s1 & s2)

# s1 과 s2 에 있지만, 양쪽에 없는 숫자들 
print(s1 ^ s2)

Dictionaries (사전)


파이썬 사전은 순서가 없는 객체들의 집합을 {} 안에 가지고 있는 자료형입니다.


특이한 점은, 사전 안에는, key:value 형태로, 값들이 한쌍으로 이루어져 있다는 점입니다.


이 key 값들은 고유해야 하고,사전을 인덱싱 할때에는, 이 key 값들이 사용됩니다. 간단한 사전을 만들어서 예시를 들어보면, 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 사전 생성하기 
# {} 안에, key:value 형태로 이루어진 자료를 , 로 구분하여 넣어주면 생성됩니다. 
web_framework = {'python': 'django', 'Java': 'spring', 'JavaScript': 'nodejs'}
print(web_framework)
print(type(web_framework))

# 사전의 데이터를 key 값을 사용해서 접근하기 

print(web_framework['python'])
print(web_framework['Java'])
print(web_framework['JavaScript'])

# 사전에 데이터를 추가하기 
web_framework['php'] = 'Laravel'

print(web_framework)

# 사전에 데이터를 삭제하기 
del web_framework['php']

print(web_framework)

None


이 데이터 형태는 오직 하나의 값만 가지고 있습니다.


내장되어 있는 이름 None 을 통해서 값에 접근할수 있습니다. None 은 여러 상황에서, 값이 없다는것을 강조하기 위해 사용 됩니다. 예를들면, 아무것도 반환하지 않는 함수에서 반환 됩니다.


None 의 불리언 값은 False 를 가집니다. 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# None 

print(None)
print(type(None))

# 아무값도 반환하지 않는 함수는 None 을 반환합니다. 

def fun():
    pass 

print(fun())


# None 의 불리언값은 False 입니다. 
print(bool(None))