파이썬 공부 ③ 리스트, 튜플, 딕셔너리, 집합

리스트(List) : 여러 데이터를 모아 저장하는 파이썬 기본형 a = [1, 2, 3]

튜플(Tuple) : 리스트와 비슷하지만, 요소를 추가, 변경, 삭제할 수 없음 a = (1, 2, 3)

딕셔너리(Dictionary) : 데이터를 '키 : 값' 페어로 관리함 a = {'A' : 1, 'B' : 2, 'C' : 3}

집합(Set) : 리스트와 비슷하지만, 요소의 순서가 정해지지 않으며, 동일한 요소를 가질 수 없음 a = {1, 2, 3}

 

* 자주 사용되는 리스트와 튜플, 둘 사이의 변환 정도는 숙지하면 좋을 듯 합니다.

* 또한 리스트 복사시에 .copy() 메소드 활용 숙지할것 !!

---

리스트(List)

• 리스트 선언 (대괄호)

- 빈 리스트는 a = [] 혹은 a = list() 로 선언 가능

a = []
print(a)
a = [1, 2, 3]
print(a)
b = list()
print(b)
b = list([1, 2, 3])
print(b)


########## 결과
[]
[1, 2, 3]
[]
[1, 2, 3]

• 리스트의 특성

- 리스트에는 다양한 형을 넣을 수 있음 (ex. 리스트에 리스트 추가)

a = [1, 2, 3]
print(a[0]) # 리스트 참조
a[0] = 4
print(a) # 리스트 값 변경

print(len(a)) # 리스트 요소 수
check = 4 in a # a 리스트 내에 4가 있는지 확인 (return bool)
print(check)

b = list('ABCDE') # 문자열이나 튜플을 리스트로 변환 가능
print(b)

c1 = ['a', 'b']
c2 = ['c', 'd']
c = [c1, c2]
print(c)

d = [['a', 'b'], ['c', 'd']] # 사실상 c와 동일
print(d)


########## 결과
1
[4, 2, 3]
3
True
['A', 'B', 'C', 'D', 'E']
[['a', 'b'], ['c', 'd']]
[['a', 'b'], ['c', 'd']]

• 요소 추가(append, insert), 리스트 연결(+, extend)

a= [1, 2, 3]
a.append(4) # 끝에 값 추가
print(a)
a.insert(0, 5) # 0번째 위치에 5를 추가
print(a)
b = [5, 6, 7]
c1 = a+b # 리스트 덧셈
print(c1)
a.extend(b)
print(a)
# c2 = a.extend(b) 사용 불가


########## 결과
[1, 2, 3, 4]
[5, 1, 2, 3, 4]
[5, 1, 2, 3, 4, 5, 6, 7]
[5, 1, 2, 3, 4, 5, 6, 7]

• 리스트 요소 삭제(pop, remove), 분할

- remove를 사용할 경우 같은 값을 갖는 가장 먼저 발견한(왼쪽) 값 1개만 삭제함. 같은 값이 존재하지 않을 경우 오류 발생.

d = [1, 2, 3, 4, 5]
d.pop(3) # 3번째 요소를 삭제
print(d) # [1, 2, 3, 5]
d.remove(1) # 1이라는 값을 요소를 삭제함.
print(d) # [2, 3, 5]
del d[0] # 0번째 값을 삭제
print(d) # [3, 5]
d1, d2 = d # 리스트 분할
print(d1, d2)
# d1, d2, d3 = d # 오류


########## 결과
[1, 2, 3, 5]
[2, 3, 5]
[3, 5]
3 5

• 리스트 정렬 (Sort) : sort, sorted

# sort는 리스트 자체를 정렬함 (리턴값 None)
a = [4, 1, 2, 3, 5]
a.sort()
print(a) # [ 1, 2, 3, 4, 5]
print(a.sort()) # None

b = [4, 1, 2, 3, 5]
# sorted 는 정렬 결과 리스트를 리턴함
print(sorted(b)) # 오름차순 정렬 [ 1, 2, 3, 4, 5 ]
print(sorted(a, reverse=True)) # 내림차순 정렬 [ 5, 4, 3, 2, 1 ]


########## 결과
[1, 2, 3, 4, 5]
None
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

• 리스트의 복사 : a = b 의 형태로 복사하는 경우, 원래의 리스트(오브젝트)를 복사하는 것이 아닌 리스트의 주소를 저장함.
• 리스트의 복사에는 .copy() 메소드를 사용함
• is 연산자 -> 오브젝트가 동일한지 확인

a = [1, 2, 3]
print(a) # [1, 2, 3]
b = a
b[0] = 10
print(b) # [10, 2, 3]
print(a)# [1, 2, 3] 일 것 같지만 [10, 2, 3]임!!!!

print('a==b?', b is a) # True

c = a.copy()
print( 'a==c?', c is a) # False
c[0] = 100
print(c) # [100, 2, 3]
print(a) # [10, 2, 3]


########## 결과
[1, 2, 3]
[10, 2, 3]
[10, 2, 3]
a==b? True
a==c? False
[100, 2, 3]
[10, 2, 3]

 

튜플(Tuple)

• 튜플 선언 (소괄호)

a = (1, 2, 3) 

• 요소 추가가 안되기 때문에 리스트처럼 선언한 이후 .append를 이용하여 요소추가를 하는 형태 사용 불가
• 리스트처럼 튜플1 + 튜플2 = 튜플12 형태로 더하여 새로운 튜플을 선언하는 것 가능

a = (4, 1, 2, 3, 5) # tuple
print(a)
# a[0] = 3 # 오류 : 튜플은 요소 값을 변경할 수 없음

b = list(a) # tuple -> list
print(b)
print(sorted(b)) # 오름차순 정렬 [ 1, 2, 3, 4, 5 ]
print(sorted(a, reverse=True)) # 내림차순 정렬 [ 5, 4, 3, 2, 1 ]

c = tuple(b) # list -> tuple

d = a + c # 덧셈 가능
print(d)


########## 결과
(4, 1, 2, 3, 5)
[4, 1, 2, 3, 5]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
(4, 1, 2, 3, 5, 4, 1, 2, 3, 5)

 

딕셔너리(Dictionary)

• {요소1:키1, 요소2:키2 ... } 로 이루어진 데이터형

a = {'a':1, 'b':2, 'c':3}
print(a['a']) # 1
# print(a['d']) # 에러 : 리스트 안에 없을 경우 에러

print(a.get('b')) # 2
print(a.get('d')) # None : .get을 사용하면 값이 있을 경우 값을, 없을 경우 None을 리턴함

print('a' in a) # True : a안에 'a' 존재?
print('a' not in a) # False : a안에 'a' 존재하지 않음?

a['a'] = 10 # 값 변경
print(a['a'])

# 키의 요소를 튜플로 생성 가능
b = {('a', 1):10, ('b', 2):20, ('c', 3):30, ('a', 4):40}
print(b[('a', 1)]) # 10
print(b[('a', 4)]) # 40

d = dict(a = 10, b = 20, c = 30) # dict를 사용하는 경우 문자열에도 따옴표를 붙이지 않음
print(d['a']) # 10

key = ['a', 'b', 'c']
value = [1, 2, 3]
e = dict(zip(key, value))
print(e) # {'a': 1, 'b': 2, 'c': 3}

del e['a'] # 요소 삭제
print(e) # {'b': 2, 'c': 3}
e.pop('b')
print(e) # {''c': 3}
e.clear()
print(e) # {}

key = list(a.keys())
values = list(a.values())
item = list(a.items())
print(key) # ['a', 'b', 'c']
print(values) # ['10', '2', '3']
print(item) # [('a', 10), ('b', 2), ('c', 3)]


########## 결과
1
2
None
True
False
10
10
40
10
{'a': 1, 'b': 2, 'c': 3}
{'b': 2, 'c': 3}
{'c': 3}
{}
['a', 'b', 'c']
[10, 2, 3]
[('a', 10), ('b', 2), ('c', 3)]

 

집합(Set)

리스트와 비슷하나, 순서가 없으며 동일 원소를 중복시킬 수 없음

a = {'a', 'b', 'c', 'd'}
print(a) # {'c', 'b', 'd', 'a'}
b = {'a', 'b', 'c', 'd', 'a'}
print(b) # {'c', 'b', 'a', 'd'}

setA = set('abcde')
print(setA) # {'d', 'a', 'e', 'b', 'c'}

listA = ['a', 'b', 'c', 'd']
setAA = set(listA) # 리스트로부터 집합 생성
print(setAA)

print(len(setAA)) # 4

print('a' in setAA) # True
print('e' in setAA) # False


########## 결과
{'a', 'c', 'b', 'd'}
{'a', 'c', 'b', 'd'}
{'e', 'c', 'b', 'a', 'd'}
{'a', 'c', 'b', 'd'}
4
True
False

교집합 A∩B	&	intersection()
합집합 A∪B	|	union()
차집합 A-B	-	difference()
대칭차 집합 (A∪B)-(A∩B)	^	symmetric_difference()
부분집합 A⊂B (A의 요소가 모두 B에 포함되는 경우)	<=, >=	issubset()
진부분집합 A⊆B (A의 요소가 모두 B에 포함되는 경우, A, B가 동일집합인 경우 포함됨)	<, >	issuperset()

a = {1, 2, 3}
b = {3, 4, 5}
c = {1, 2}
d = {1, 2, 3}
print(a & b) # {3} print(a.intersection(b))와 동일
print(a | b) # {1, 2, 3, 4, 5}
print(a - b) # {1, 2}
print(a ^ b) # {1, 2, 4, 5}
print(a >= c) # True
print(a >= b) # False
print(a > c) # True
print(a > d) # False


########## 결과
{3}
{1, 2, 3, 4, 5}
{1, 2}
{1, 2, 4, 5}
True
False
True
False