[Python] 자료형 (리스트, 튜플, 딕셔너리, 집합)

1. 리스트 (List)

[1] 정의

- 요소들의 모음을 나타내는 자료형
- 모든 자료형을 리스트의 요소로 사용 가능

 

[2] 인덱싱

- 문자열과 마찬가지로 인덱싱 적용 가능

- 리스트 내의 리스트는 인덱싱 두 번으로 요소 가져올 수 있음.

>>>
a = [1, 2, 3, 4, 5]
d = [1, 2, ['life', 'is', ['too', 'short']]]

print(a[0])
print(a[0] + a[4])
print(a[3:])
print(a[1:-1])

print(d[2])
print(d[2][2])
print(d[-1][2:]) # 범위로 인덱싱 하면 리스트로 묶여서 출력됨.
print(d[-1][-1][-1])

 

# Output
1
6
[4, 5]
[2, 3, 4]

['life', 'is', ['too', 'short']]
['too', 'short']
[['too', 'short']]
short

 

[3] 연산

- + : 리스트와 리스트를 순서대로 연결하여 하나의 리스트 생성

- * : 리스트와 숫자형을 곱하여 리스트 안의 요소를 숫자만큼 반복한 리스트를 생성

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

print(a + b)
print(a + [4])
print(b * 3)

 

# Output
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4]
[4, 5, 6, 4, 5, 6, 4, 5, 6]

 

[4] 수정

- 인덱싱을 통해 값 수정 가능

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

a[0] = 0
print(a)

 

# Output
[1, 2, 3, 4, 5]
[0, 2, 3, 4, 5]

 

>>>
a = [1, [2, 3], [4, 5, [6, 7]]]

a[0] = 10
print(a)

a[1][0] = [9, 10, 11]
print(a)

a[2][-1] = 8
print(a)

a[1][0][1:] = [20, 30] # 범위 인덱스에 치환하려면 리스트로 해야 함.
print(a)

 

# Output
[10, [2, 3], [4, 5, [6, 7]]]
[10, [[9, 10, 11], 3], [4, 5, [6, 7]]]
[10, [[9, 10, 11], 3], [4, 5, 8]]
[10, [[9, 20, 30], 3], [4, 5, 8]]

 

[5] 함수

- len : 리스트의 길이 출력

- sum, min, max : 리스트 요소들의 합, 최소값, 최대값 출력

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

print(len(a))
print(sum(a) / len(a))
print(min(a))
print(max(a))

 

# Output
5
3.0
1
5

 

>>>
a = ['a', 'b', 'c', 'd', 'e']
print(sum(a)) # 에러 발생
print(min(a)) # 알파벳 순서
print(max(a))

 

# Output
a
e

 

- in : 특정 요소가 리스트 안에 있는지 확인

>>>
a = ['a', 'b', 'c', 'd', 'e']
print('a' in a)
print(1 in a)

 

# Output
True
False

 

- append : 리스트의 마지막에 요소를 추가

- extend : 리스트의 마지막에 리스트를 추가

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

 

# Output
[1, 2, 3, 4, 4, 5]

 

- insert : 리스트의 특정 위치에 특정 요소를 삽입

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

 

# Output
[1, 2, 3, 2, 4]

 

- remove, pop : 리스트의 특정 요소 제거

>>>
a = [1, 2, 3, 4] 
a.remove(4) # 특정 요소 제거
print(a)

a = [1, 2, 3, 4]
a.pop(2) # 특정 위치 제거
print(a)

 

# Output
[1, 2, 3]
[1, 2, 4]

 

- count : 리스트의 특정 요소의 개수를 반환

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

 

# Output
2

 

- index : 리스트에 요소가 있는 경우 인덱스 값을 반환

>>>
a = ['a', 'b', 1, 2]
a.index(1) # 1의 인덱스 출력

 

# Output
2

 

- sort, sorted : 리스트를 정렬

>>>
a = [1, 20, 23, 2]
a.sort()
print(a)

 

# Output
[1, 2, 20, 23]

 

>>>
a = [1, 20, 23, 2]
sorted(a) # 출력만 정렬
print(a)

a = [1, 20, 23, 2]
a = sorted(a)
print(a)

a = [1, 20, 23, 2]
a = sorted(a, reverse=True)
print(a)

 

# Output
[1, 20, 23, 2]
[1, 2, 20, 23]
[23, 20, 2, 1]

 

- join : 리스트의 요소들을 하나의 문자열로 합침.

- split : 문자열을 리스트의 요소들로 쪼갬.

>>>
a = ['a', 'b', 'c', 'd', 'e']
print('-'.join(a)) # 리스트 안에 문자열이 있을 때만 사용 가능
print('/'.join(a))
print(''.join(a))

a = 'a b c d e'
print(a.split(' '))

a = 'a,b,c,d,e'
print(a.split(','))

 

# Output
a-b-c-d-e
a/b/c/d/e
abcde

['a', 'b', 'c', 'd', 'e']

['a', 'b', 'c', 'd', 'e']

 

[6] range 함수

- range(시작, 끝, 간격) : 간격 미입력시 디폴트 1

- list(range()) : list로 변환하고 싶으면 list() 함수 씌움.

>>>
range(1, 10) # range라는 개체 자체가 반환

list(range(1, 10))

list(range(1, 10, 2))

list(range(5, -11, -3))

 

# Output
range(1, 10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
[5, 2, -1, -4, -7, -10]

 

---

2. 튜플 (Tuple)

[1] 정의

- 튜플의 요소는 수정, 삭제 불가능

- 프로그램 실행 중 절대 변하지 않거나, 변해서는 안되는 값을 튜플로 저장

- 요소가 하나일 경우 '-'를 뒤에 붙임.

>>>
d = (1, 2, ['life', 'is', ('too', 'short')])
print(d, type(d))

x = (3,)
print(x, type(x))

 

# Output
(1, 2, ['life', 'is', ('too', 'short')]) <class 'tuple'>
(3,) <class 'tuple'>

 

[2] 인덱싱

- 리스트와 동일하게 인덱싱 적용 가능 (다만, 인덱싱을 활용해 값을 바꿀 수 없음.)

 

[3] 연산

- 리스트와 동일하게 +, * 가능 (다른 자료형을 더하면 오류)

>>>
a = (1, 2, 3)
a + (3,)

 

# Output
(1, 2, 3, 3)

 

[4] 수정

- 튜플의 요소는 수정하거나 삭제할 수 없으므로 불가능

- 리스트에서 사용하는 함수들 사용 불가능 (append, insert, extend, remove, pop, sort, ...)

- sorted는 튜플을 리스트로 변환하여 정렬해 출력

a = (1, 2, 3, 4, 5)

a[0] = 0 # 에러 발생

sorted(a, reverse=True)
tuple(sorted(a, reverse=True))

 

# Output
[5, 4, 3, 2, 1]
(5, 4, 3, 2, 1)

 

[5] 함수

- 사용 가능한 함수 (사용법은 리스트와 동일) : len, sum, min, max, in, count, index, join

 

[6] 함수 심화

- max(튜플, key = lambda x: x[인덱스]) : 다중 튜플의 경우 정렬 기준을 정의하여 튜플 내 최대값을 탐색

- min(튜플, key = lambda x: x[인덱스]) : 다중 튜플의 경우 정렬 기준을 정의하여 튜플 내 최소값을 탐색

>>>
a = (('a', 1), ('b', 7), ('c', 3), ('d', -5), ('e', -9))

print(max(a, key = lambda x: x[0]))
print(max(a, key = lambda x: x[1]))
print(min(a, key = lambda x: x[0]))
print(min(a, key = lambda x: x[1]))

 

# Output
('e', -9)
('b', 7)
('a', 1)
('e', -9)

 

- 두 번째 요소의 절댓값을 기준으로 최대값, 최소값을 탐색

>>>
print(max(a, key = lambda x:abs(x[1])))
print(min(a, key = lambda x:abs(x[1])))

 

# Output
('e', -9)
('a', 1)

 

- 리스트에도 동일하게 적용

>>>
b = list(a)

print(sorted(b, key = lambda x:x[1]))
print(sorted(b, key = lambda x:x[1], reverse=True))
print(sorted(b, key = lambda x:abs(x[1])))

 

# Output
[('e', -9), ('d', -5), ('a', 1), ('c', 3), ('b', 7)]
[('b', 7), ('c', 3), ('a', 1), ('d', -5), ('e', -9)]
[('a', 1), ('c', 3), ('d', -5), ('b', 7), ('e', -9)]

 

---

3. 딕셔너리 (Dictionary)

[1] 정의

- key : value 쌍이 모여있는 사전 형태의 자료형

- key는 중복될 수 없고 (고유한 값), list (값이 변할 수 있는 자료형)은 key가 될 수 없음.

- 위치로 인덱싱 불가

>>>
dic = {'name' : ['merry', 'john'],\
       'num' : [1, 2, 3],\
        'birth' : ['jan', 'feb', 'nov']}

print(dic)
print(type(dic))

 

# Output
{'name': ['merry', 'john'], 'num': [1, 2, 3], 'birth': ['jan', 'feb', 'nov']}
<class 'dict'>

 

[2] 추가, 삭제

>>>
print(dic)

dic['country'] = ['Korea', 'US']
print(dic)

 

# Output
{'name': ['merry', 'john'], 'num': [1, 2, 3], 'birth': ['jan', 'feb', 'nov']}
{'name': ['merry', 'john'], 'num': [1, 2, 3], 'birth': ['jan', 'feb', 'nov'], 'country': ['Korea', 'US']}

 

>>>
del dic['country']
print(dic)

 

# Output
{'name': ['merry', 'john'], 'num': [1, 2, 3], 'birth': ['jan', 'feb', 'nov']}

 

[3] Key로 값 찾기

>>>
print(dic['name'])
print(dic['num'])

 

# Output
['merry', 'john']
[1, 2, 3]

 

[4] 함수

- keys() : 키 반환

- values() : 값 반환

- items() : 키와 값의 튜플 쌍 반환

>>>
dic = {'name' : ['merry', 'john'],\
       'num' : [1, 2, 3],\
        'birth' : ['jan', 'feb', 'nov']}
        
print(dic.keys())
print(type(dic.keys())) # 고유한 타입 가짐.
print(dic.values())
print(dic.items())

# list 형태로 출력
print(list(dic.keys()))
print(list(dic.values()))
print(list(dic.items()))

 

# Output
dict_keys(['name', 'num', 'birth'])
dict_keys
dict_values([['merry', 'john'], [1, 2, 3], ['jan', 'feb', 'nov']])
dict_items([('name', ['merry', 'john']), ('num', [1, 2, 3]), ('birth', ['jan', 'feb', 'nov'])])

['name', 'num', 'birth']
[['merry', 'john'], [1, 2, 3], ['jan', 'feb', 'nov']]
[('name', ['merry', 'john']), ('num', [1, 2, 3]), ('birth', ['jan', 'feb', 'nov'])]

 

>>>
# 반복문 자주 사용
for k, v in dic.items():
    print('키: ', k)
    print('값: ', v)

 

# Output
키:  name
값:  ['merry', 'john']
키:  num
값:  [1, 2, 3]
키:  birth
값:  ['jan', 'feb', 'nov']

 

- get(키) : 키 값에 대응되는 값 반환 (딕셔너리[키] 와 동일)

>>>
print(dic.get('name'))
print(dic['name'])

 

# Output
['merry', 'john']
['merry', 'john']

 

- update : 새로운 딕셔너리 추가

>>>
dic1 = {'a':[1, 2], 'b':3, 'c':[4, 5, 6]}
dic2 = {'d':10, 'e':[102, 101]}

dic1.update(dic2)
print(dic1)

# Output
{'a': [1, 2], 'b': 3, 'c': [4, 5, 6], 'd': 10, 'e': [102, 101]}

 

- zip : 튜플/리스트 두 개를 하나의 딕셔너리로 변환

>>>
keys = ("a", "b")
values = (1, 2)
result_dict = dict(zip(keys, values))
result_list = list(zip(keys, values))
print(result_dict)
print(result_list)

keys = ["a", "b"]
values = [1, 2]
result_dict = dict(zip(keys, values))
result_list = list(zip(keys, values))
print(result_dict)
print(result_list)

keys = ["a", "b", "c"] 
values = [1, 2] # 개 수가 적은 values 기준으로 만들어짐.
result_dict = dict(zip(keys, values))
result_list = list(zip(keys, values))
print(result_dict)
print(result_list)

 

# Output
{'a': 1, 'b': 2}
[('a', 1), ('b', 2)]

{'a': 1, 'b': 2}
[('a', 1), ('b', 2)]

{'a': 1, 'b': 2}
[('a', 1), ('b', 2)]

 

[5] 데이터 셋과 대응

- 각 키들의 값이 길이가 같다면

>>>
dic = {'name' : ['merry', 'john', 'kevin'],\
       'num' : [1, 2, 3],\
        'birth' : ['jan', 'feb', 'nov']}

import pandas as pd
df = pd.DataFrame(dic)
print(df)

 

# Output
    name  num birth
0  merry    1   jan
1   john    2   feb
2  kevin    3   nov

 

---

4. 집합 (Set)

[1] 정의

- 순서, 중복이 없는 자료형

- 순서가 없기 때문에 인덱싱 불가 (리스트, 튜플로 변환 후 인덱싱)

>>>
s1 = set([1, 2, 'a'])
s2 = set("Hello") # 중복 제거됨.
s3 = set([1, 2, 2, 3, 4, 5, 5, 3]) # 중복 제거됨.
s4 = set((1, 2, 2, 3))

print(s1, type(s1))
print(s2, type(s2))
print(s3, type(s3))
print(s4, type(s4))
print(list(s1)[1])

 

# Output
{1, 2, 'a'} <class 'set'>
{'e', 'o', 'H', 'l'} <class 'set'>
{1, 2, 3, 4, 5} <class 'set'>
{1, 2, 3} <class 'set'>
2

 

[2] 함수

- intersection or & : 교집합

- difference or -     : 차집합

- union or |            : 합집합

>>>
s1 = set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
s2 = set([5, 6, 7, 8, 9, 10, 11, 12])

print(s1&s2)
print(s1.intersection(s2))

print(s1-s2)
print(s1.difference(s2))

print(s1|s2)
print(s1.union(s2))

 

# Output
{5, 6, 7, 8, 9, 10}
{5, 6, 7, 8, 9, 10}
{1, 2, 3, 4}
{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

 

- add : 요소를 추가

- remove : 요소를 제거

>>>
s1.add(11)
print(s1)

 

# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

 

>>>
s1.remove(11)
print(s1)

 

# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}