Ch 2. 파이썬 자료구조

1. 리스트 (List)

• 여러가지 자료를 저장할 수 있는 데이터 구조체 Link to list

Link to list

• 요소(value) : 리스트 내 데이터를 의미
• 인덱스(index) : 리스트 내 데이터의 주소

 

(1). 일차원 리스트

li = [1, 2, 3, 4, 5]
print(li)
# [1, 2, 3, 4, 5]

 

(2). 다차원 리스트

[[], [], []]

matrix = [[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]
print(matrix)
# [[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [10, 12, 13, 14, 15], [16, 17, 18, 19, 20]]

 

(3). 슬라이싱 (데이터 접근)

• array[index] : 특정 인덱스의 값 접근
• array[start:stop:step] : 특정 범위의 값 접근
• array[-stop] : 뒤에서 부터 접근
• array[index][index] : 다차원 리스트 접근
• list.index(value) : value의 index를 반환
• zip(list1, list2) : 2개의 리스트를 받아서 항목을 2개를 묶어서 제공
• 숫자 0부터 시작
• 범위를 벗어난 인덱스 접근시 error 발생

matrix = [[1, 2], [3, 4]]

print(matrix[1][1])
# 4

print(matrix[0][0:])
# [1, 2]

 

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

print(li[-2])
# 4

print(li[0:4:2])
# [1, 3]

print(li.index(5))
# 4

 

li1 = [1, 2, 3]  # 개수가 달라도 가능
li2 = [4, 5, 6]

for a in zip(li1, li2) :
	print(a)

# (1, 4)
# (2, 5)
# (3, 6)

for a, b in zip(li1, li2) :
	print(a)
    print(b)
    
# 1
# 4
# 2
# 5
# 3
# 6

 

(4). 리스트 연산자

• + : 리스트 합치기
• * : 리스트 반복하기
• in : 특정 값 포함 여부 확인, True 또는 False 출력
• not in : 특정 값 불포함 여부 확인, True 또는 False 출력

li1 = [1, 2, 3]
li2 = [4, 5, 6]

li3 = li1 + li2
print(li3)
# [1, 2, 3, 4, 5, 6]

print(li1 * 2)
# [1, 2, 3, 1, 2, 3]

print(5 not in li1)
# True

 

(5). 리스트 관련 함수

• list.append(value) : 마지막에 요소 추가
• list.insert(index, value) : 인덱스에 요소 추가
• list1.extend(list2) : 리스트 뒤에 확장 또는 추가 -> + 연산자와 동일

li1 = [1, 2, 3]
li2 = [4, 5, 6]

li1.append(11)
print(li1)
# [1, 2, 3, 11]

li1.insert(1, 7)
print(li1)
# [1, 7 ,2, 3, 11]

li1.extend(li2)
print(li1)
# [1, 7, 2, 3, 11, 4, 5, 6]

 

• del list[index] : 리스트 내 하나의 요소 제거
• del list[index:index] : 특정 범위의 요소들 제거
• del list[:index] : 처음부터 인덱스 바로 직전까지 제거
• list.pop(index) : 리스트 내 하나의 요소 제거, del과 유사
• list.remove(value) : 특정 값을 지정하여 제거, 단 처음 하나만 제거
• list.clear() : 요소들 모두 제거

li = [1, 2, 3, 4, 5, 6, 7, 8]

del li[2]
print(li)
# [1, 2, 4, 5, 6, 7, 8]

del li[1:3]
print(li)
# [1, 5, 6 ,7, 8]

del li[:2]
print(li)
# [6, 7, 8]

li.pop() # 파라미터가 없으면 마지막 제거 -> del 과 유사
print(li)
# [6, 7]

li.remove(6)
print(li)
# [7]

li.clear()
print(li)
# []

 

• list.sort() : 정렬
• sorted(list) : 정렬된 새로운 리스트 반환

li1 = [10, 3, 7, 9, 2]

li.sort()
print(li)
# [2, 3, 7, 9, 10]

 

• len(list) : 리스트의 길이 측정
• min(list) : 최소값 가져오기
• max(list) : 최대값 가져오기
• sum(list) : 모든 요소의 합계
• all(list) : 모든 요소가 참이면 참 반환
• any(list) : 한 요소라도 참이면 참 반환
• enumerate(list) : 인덱스와 요소를 함께 반환
• random.choice(list) : 리스트에서 랜덤 선택

li = [1, 2, 3]

print(all(li))
# True

for i in enumerate(li) :
	print(i)
    
# (0, 1)
# (1, 2)
# {2, 3)

 

import random

li = [1, 2, 3]
print(random.choice(li))

# li 중 하나 임의로 반환

 

(6). 리스트와 함수

• call by value -> 변수 복사
• call by reference -> 주소를 참조

def A(a, b) :
	a += 1

x = 1
y = 1
A(x, y) # 1을 a에 복사

print(x)
# 1

 

def A(a, b) :
	a[1] = 7
    
x = [1, 2, 3] 
y = 1

A(x, y) # a가 리스트 주소를 참조

print(x)
# [1, 7, 3]

 

(7). 리스트 함축

• 리스트의 요소를 생성하는 문장을 리스트 안에 넣어 집합 생성
• 파이썬만이 가진 독특한 문법
• [수식 (for 변수 in 리스트) if 조건]

A = [2*x + 1 for x in range(6) if x%2 == 0]
print(A)
# [1, 5, 9]

 

---

2. 튜플 (Tuple)

• 리스트와 유사하나 수정이 불가한 자료구조
• ( , , )
• 요소가 1개인 튜플은 요소의 끝에 반드시 쉼표(,) 추가
• 데이터 변경 금지(locking) 효과
• 반복문에서 리스트보다 빠름
• 딕셔너리의 키가 될 수 있음

 

(1). 리스트와 튜플 변환

• 리스트와 튜플은 서로 변환이 가능
• tp = tuple(list), li = list(tp)

 

(2). Packing / Unpacking

• Packing : tuple = (value, value, value)
• Unpacking : (a, b, c) = tuple

tp = (1, 2, 3) # Packing
(a, b, c) = tp # Unpacking

 

 

(3). 변경 불가 예외사항

• += 연산자를 통한 튜플 연장은 가능
• 튜플 내 리스트가 있을 경우 리스트는 수정 가능
• 리스트에 튜플을 추가하는 것 가능 (list += tuple)

a = [11, 12, 13]
b = (4, 5, [1, 2], 6)
c = (1, 2)

b[2][0] += 7
print(b)
# (4, 5, [8, 2], 6)

a += b
print(a)
# [11, 12, 13, 4, 5, [8, 2], 6]

print(c * 2)
# (1, 2, 1, 2)

 

---

 

3. 세트 (Set)

• 고유한 값들을 저장하는 자료구조
• 순서대로 저장되지 않으며, 인덱스를 통한 접근 불가
• { , , }

 

(1). 리스트와 세트 변환

• 리스트와 세트는 서로 변환이 가능
• s = set(li), li = list(s)
• 하나의 요소를 가진 문자열은 문자로 나뉨

li = [1, 1, 3, 3, 5]
s = set(li)

print(s)
# {1, 3, 5}

 

 

(2). 추가 / 삭제

• 세트는 튜플과는 달리 추가 / 삭제가 가능
• 인덱스가 없기 때문에 추가 / 삭제 시 add(), remove() or dicard() 사용
• set.clear(), set.update(list) 가능

s = {1, 3, 5}
li = [1, 2]

s.add(9)
print(s)
# {1, 3, 5, 9}

s.remove(1)
print(s)
# {3, 5, 9}

s.discard(3)
print(s)
# {5, 9}

s.update(li) # list를 set에 넣을 수 있음
print(s)
# {1, 2, 5, 9}

 

 

(4). 세트 연산자

• A < B 또는 A.issubset(B) : 부분집합 판단
• A == B 또는 A != B : 동일 또는 다른 집합인지 판단
• A | B 또는 A.union(B) : 합집합 도출
• A & B 또는 A.intersection(B) : 교집합 도출
• A - B 또는 A.difference(B) : 차집합 도출

A = {1, 2, 3, 4, 5}
B = {1, 2, 11}

print(A | B)
# {1, 2, 3, 4, 5, 11}

print(A & B)
# {1, 2}

print(A - B)
# {3, 4, 5}

 

---

 

4. 딕셔너리 (Dictionary)

• key를 기반으로 value 저장
• value에는 list가 올 수 있음
• { key : value, key : value, key : value }
• key는 변수로 지정 가능

me = {"주전공" : "수학과", "복수전공" : "컴퓨터공학과", "거주지" : "대전광역시"}

print(me["주전공"])
# 수학과

 

 

(1). 탐색

• 딕셔너리명[key] : 키를 통한 데이터 접근
• 딕셔너리명.get(key, value1) : key가 딕셔너리있으면 해당하는 value를 반환하고 없으면 value1을 반환
• 딕셔너리명.keys() : 모든 keys 반환
• 딕셔너리명.values() : 모든 values 반환
• 딕셔너리명.itmes() : 모든 keys와 values 반환

me = {"주전공" : "수학과", "복수전공" : "컴퓨터공학과", "거주지" : "대전광역시"}

print(me.get("부전공"))
# None

print(me.get("부전공", "부전공은 안함."))
# 부전공은 안함.

print(me.keys())
# dict_keys(['주전공', '복수전공', '거주지'])

print(me.values())
# dict_values(['수학과', '컴퓨터공학과', '대전광역시'])

print(me.items())
# dict_items([('주전공', '수학과'), ('복수전공', '컴퓨터공학과'), ('거주지', '대전광역시')]) -> 튜플

 

 

(2). 수정 및 추가

• 딕셔너리명[key] = value : 키가 존재하면 수정, 존재하지 않으면 추가
• 딕녀너리1.update(딕셔너리2) : 수정하거나 추가할 때 사용

me1 = {"주전공" : "수학과", "복수전공" : "컴퓨터공학과", "거주지" : "대전광역시"}
me2 = {"주전공" : "컴퓨터공학과", "복수전공" : "수학과 ", "국적" : "대한민국"}

me1["거주지"] = "서울특별시"
print(me1)
# {'주전공': '수학과', '복수전공': '컴퓨터공학과', '거주지': '서울특별시'}

me1.update(me2)
print(me1)
# {'주전공': '컴퓨터공학과', '복수전공': '수학과', '거주지': '서울특별시', '국적': '대한민국}

 

 

(4). 딕셔너리 함축

• 리스트로부터 딕셔너리의 요소를 생성하는 문장을 딕셔너리 안에 넣어 집합 생성
• 파이썬만이 가진 독특한 문법
• dic = {x*x for x in list if x%2 == 0}

li = [1, 2, 3]
dic = {x : x**x for x in li}
print(dic)
# {1: 1, 2: 4, 3: 27}