파이썬 자료구조: 리스트, 튜플, 딕셔너리 이해하기

 

우리가 사용한 물건을 정리할 때 상자에 담고, 책을 정리할 때 책장에 꽂아두는 것처럼 파이썬도 숫자나 글자 같은 데이터들을 담아두는 공간이 필요합니다. 이런 해당 공간을 '자료구조(Data Stucture)'라고 부릅니다. 파이썬에는 여러 가지 공간이 있지만, 가장 많이 사용되고 기본이 되는 리스트(List), 튜플(Tuple). 딕셔너리(Dictionary) 3가지에 대해서 알아보겠습니다.

 

 

 

 

 

리스트(List)

 

리스트는 '여러 물건을 순서대로 늘어놓은 장난감 기차'와 같습니다. 대괄호를 사용해서 만들고 원하는 데이터를 마음껏 추가하거나 빼거나, 순서를 바꿀 수 있습니다.

---

1️⃣ 리스트 생성

- 순서가 있음 : 요소(Element)들의 위치가 정해져 있어 index(위치 번호)로 접근할 수 있습니다.

- 수정 가능 : 값의 추가, 수정, 삭제가 가능합니다.

- 중복 허용 : 동일한 값이 여러 번 들어갈 수 있습니다.

- 다양한 자료형 담기 가능 : 숫자, 문자열, 리스트 등 다양한 자료형 데이터를 담을 수 있습니다.

 

# 빈 리스트
empty_list = []

# 숫자와 문자열
numbers = [1,2,3,4,5]
fruits = ["사과", "바나나", "체리"]

# 혼합
mixed = [1,2,"Hello",3.14, True, [1,2,3], ["사과", "바나나"]]

 

 

2️⃣ 리스트 인덱싱과 슬라이싱

위치 번호를 사용해 원하는 요소만 가져올 수 있고, 특정 범위를 주어 잘라낼 수 있다.

 

인덱싱 예제

nums = [10,20,30,40,50]
print(nums)		# [10, 20, 30, 40, 50]
print(nums[0])		# 10
print(nums[-1])		# 50

mixs = [1,2,True,"Hello",['a','b','c']]
mixs[2]		# True
print(mixs[0])	# 1
mixs[-1]	# ['a','b','c']

# 리스트에 리스트를 넣은 경우라면 가장 먼저 index 4번째에 있는 리스트(['a','b','c'])를 꺼내고
# 꺼내진 리스트의 index 1번째를 꺼낸다.
print(mixs[-1][1])	# b

 

슬라이싱 예제

mixs = [1,2,True,"Hello",['a','b','c']]
mixs[0:2]	# [1, 2]
mixs[-1:]	# [['a', 'b', 'c']]
mixs[-3:]	# [True, 'Hello', ['a', 'b', 'c']]
mixs[:3]	# [1, 2, True]
mixs[4][:2]	# ['a', 'b']

 

3️⃣ 리스트 연산

파이썬 리스트에서 산술 연산자는 수학적 계산이 아니라 '연결'과 '반복'의 의미를 가집니다.

 

리스트 더하기(+)

두 개 이상의 리스트를 하나로 이어 붙입니다. 원래 리스트는 변경되지 않고 새로운 리스트가 생성됩니다.

 

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

result = a + b
print(result)	# [1, 2, 3, 4, 5]

# 참고 (확장 연산자 +=)
c = ['p','y','t']
d = ['h','o','n']

c += d
print(c)	# ['p', 'y', 't', 'h', 'o', 'n']

 

'c += d'를 사용하면 새로운 리스트 c가 만들어지지 않고 기존 리스트 c 자체를 수정하여 메모리를 아낄 수 있습니다.

 

리스트 곱하기(*)

리스트의 요소를 지정한 숫자만큼 반복하여 복사합니다.

 

a = [0,1]
result = a * 5
print(result)	# [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

zero_list = [0] * 5
# 특정 길이의 리스트를 초기화 할 때 자주 사용
print(zero_list)	# [0, 0, 0, 0, 0]

new_list = [result[1]] * 5
print(new_list)	# [1, 1, 1, 1, 1]

 

리스트 길이 구하기

리스트 길이를 구하기 위해서는 len 함수를 사용합니다.

a = [1,2,3,4,5]
len(a)	# 5

 

4️⃣ 리스트 수정과 삭제

리스트의 수정(update)과 삭제(delete)는 리스트 자료구조를 다룰 때 가장 빈번하게 사용하는 작업입니다.

 

리스트 수정(Midification)

리스트는 수정 가능한 자료형이므로, 기존 위치의 값을 새로운 값으로 덮어쓸 수 있습니다.

 

fruits = ["사과", "바나나", "키위", "체리"]
print(fruits)	# ['사과', '바나나', '키위', '체리']

# index 1번의 값(바나나)을 망고로 수정
fruits[1] = "망고"
print(fruits)	# ['사과', '망고', '키위', '체리']

# 음수 인텍스도 가능
fruits[-1] = "수박"
print(fruits)	# ['사과', '망고', '키위', '수박']

# 여러 요소 한 번에 수정
numbers = [10,20,30,40,50]
numbers[1:3] = [200,300]
print(numbers)	# [10, 200, 300, 40, 50]

numbers[1:4] = [99]
print(numbers)	# [10, 99, 50]

numbers[1:4] = [99] * 5
print(numbers)	# [10, 99, 99, 99, 99, 99]

 

리스트 삭제(Deletion)

삭제는 인덱스로 삭제, 값으로 삭제, 전체 비우기 등 목적에 따라 방식이 나뉩니다.

 

- del 키워드 : 인덱스나 범위로 삭제

- .pop() 메서드 : 지정한 인덱스의 요소를 삭제함(꺼내기)과 동시에 그 값을 반환

- .remove() 메서드 : 인덱스가 아닌 값으로 삭제 (여러 같은 값이 있는 경우, 첫 번째로 발견된 값만 삭제)

- .clear() 메서드 : 리스트 안의 모든 요소를 지우고 빈 리스트 만듦

 

# del 키워드(인덱스나 범위로 삭제)
# ────────────────────────────────────────────
colors = ["red","green","blue","yellow","black"]

# 특정 위치 1개 삭제
del colors[1]
print(colors)	# ['red', 'blue', 'yellow', 'black']

# 범위로 여러 개 삭제
del colors[1:3]
print(colors)	# ['red', 'black']

# .pop() 메서드
# ────────────────────────────────────────────
menu = ["김밥","피자","치킨","햄버거","회","족발"]

# 인덱스를 적지 않으면 '맨 마지막' 요소를 꺼낸다.
get_item = menu.pop()
print(get_item)	# 족발
print(menu)	# ['김밥', '피자', '치킨', '햄버거', '회']

# 인덱스를 지정하여 꺼내기
first_item = menu.pop(0)
print(first_item)	# 김밥
print(menu)		# ['피자', '치킨', '햄버거', '회']

# .remove() 메서드
# ────────────────────────────────────────────
animals = ["dog","cat","bird","cat"]

# 첫번째 cat 데이터만 찾아 삭제
animals.remove("cat")
print(animals)	# ['dog', 'bird', 'cat']

# .clear() 메소드
# ────────────────────────────────────────────
colors.clear()
menu.clear()
animals.clear()
print(colors)	# []	
print(menu)	# []
print(animals)	# []

 

🔔 중복된 값을 모두 지우려면?

remove() 메서드는 첫 번째 값만 지워주므로, 리스트 안의 특정 값을 모두 지우고 싶을 때는 리스트 컴프리헨션이나 while문을 활용합니다.

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

# 리스트 컴프리헨션: 2가 아닌 것들만 골라 새로 만들기
numbers = [x for x in numbers if x != 2]
print(numbers)  # [1, 3, 4, 5]

 

5️⃣ 리스트 주요 함수

- append(x) 메서드

리스트의 맨 뒤에 요소 x를 1개 추가합니다.

fruits = ["사과", "바나나"]
fruits.append("체리")
print(fruits)	# ['사과', '바나나', '체리']

 

- insert(i, x) 메서드

지정한 인덱스 i 위치에 요소 x를 삽입합니다. 

numbers = [1,3,4]
numbers.insert(1, 2)	# index 1번에 값2 삽입
print(numbers)	# [1, 2, 3, 4]

 

- extend(iterable) 메서드

리스트 끝에 다른 리스트나 튜플 등 여러 개의 요소를 한 번에 덧붙여 연장합니다.

a = [1,2]
a.extend([3,4])
print(a)	# [1, 2, 3, 4]

 

- remove(x) 메서드

리스트에서 값이 x인 첫 번째 요소를 찾아 삭제합니다.

colors = ["red","green","blue","yellow","black"]
colors.remove("green")
print(colors)	# ['red', 'blue', 'yellow', 'black']

 

- pop([i]) 메서드

지정한 인덱스 i 위치의 요소를 삭제하면서 그 값을 반환합니다. 인덱스를 생략 시, 맨 마지막 요소를 꺼냅니다.

stack = [10,20,30]
val = stack.pop()	# 맨 뒤 30을 꺼낸다
print(val)	# 30
print(stack)	# [10,20]

 

- clear() 메서드

리스트 내부의 모든 요소를 삭제하여 빈 리스트 []로 만듭니다.

data = [1,2,3]
data.clear()
print(data)	# []

 

- del 연산자

파이썬 키워드로, 인덱스나 슬라이싱 범위를 지정해 메모리에서 삭제합니다.

nums = [10,20,30,40,50]
del nums[1]	# 1번 인덱스(20) 삭제 -> [10,30,40,50]
del nums[1:3]	# 1번~2번 인덱스 범위 삭제
print(nums)	# [10, 50]

 

- sort() 메서드

리스트의 요소들을 오름차순(기본값) 또는 내림차순으로 정렬합니다. 

numbers = [3,1,4,2,6,5]
numbers.sort()	# 오름차순 정렬
print(numbers)	# [1, 2, 3, 4, 5, 6]

numbers.sort(reverse=True)	# 내림차순 정렬
print(numbers)	# [6, 5, 4, 3, 2, 1]

 

- reverse() 매소드

정렬을 하지 않고, 단순히 현재 리스트의 순서를 뒤집습니다.

letters = ["a","c","b"]
letters.reverse()
print(letters)	# ['b', 'c', 'a']

 

- index(x) 메서드

리스트에서 값 x가 위치한 첫 번째 인덱스 번호를 반환합니다.

items = ["A","B","C","B"]
print(items.index("B"))	# 1 (첫 번째 'B'의 위치)

 

- count() 메서드

리스트 안에 값 x가 몇 개 포함되어 있는지 개수를 반환합니다.

scores = [100,90,100,86,99,67,100]
print(scores.count(100))	# 3

 

- len(iterable) 메서드

리스트의 전체 요소 개수를 구합니다.

arr = [10,20,30,40,50,60,70,80,100]
print(len(arr))	# 9

 

- copy() 메서드

리스트의 얕은 복사본(새로운 객체)을 만들어 반환합니다. 원본과 별개의 리스트를 만들고 싶을 때 사용합니다.

original = [1,2,3]
copied = original.copy()	# 또는 original[:]

copied.append(4)
print(original)	# [1, 2, 3]
print(copied)	# [1, 2, 3, 4]

 

 

 

 

 

튜플(Tuple)

 

튜플은 여러 개의 요소를 하나로 묶어서 관리할 수 있는 자료형으로 리스트와 매우 유사하지만, 가장 큰 차이점은 "한 번 생성되면 요소를 변경할 수 없다."는 점입니다.

---

1️⃣ 튜플 생성

튜플은 소괄호를 사용해 생성하며, 각 요소는 쉼표로 구분합니다. 소괄호를 생략해도 쉼표만 있으면 튜플로 인식됩니다. 하지만 단일 요소(요소 1개)만 있을 때는 반드시 뒤에 쉼표를 꼭 붙여야 합니다. (쉼표가 없으면 일반 괄호 연산으로 인식하여 숫자나 문자열 타입이 됩니다.)

 

empty_tuple = ()
t1 = (1,2,3)
t2 = "a", "b", "c"
t3 = (1, "Hello", 3.14, True)
single_tuple = (1,)
not_a_tuple = 1

print(empty_tuple)	# ()
print(t1)		# (1, 2, 3)
print(t2)		# ('a', 'b', 'c')
print(t3)		# (1, 'Hello', 3.14, True)
print(single_tuple)	# (1,)
print(not_a_tuple)	# 1

print(type(empty_tuple))	# <class 'tuple'>
print(type(t1))			# <class 'tuple'>
print(type(t2))			# <class 'tuple'>
print(type(t3))			# <class 'tuple'>
print(type(single_tuple))	# <class 'tuple'>
print(type(not_a_tuple))	# <class 'int'>

 

2️⃣ 튜플 값 가져오기, 수정하기, 삭제하기

튜플은 불변(Immutable) 특성을 가지기 때문에, 값을 읽는 것만 가능하고 수정이나 삭제는 불가능합니다.

 

튜플 값 가져오기

인덱스를 활용하여 특정 위치의 값을 가져옵니다.

 

t = (10,20,30)
print(t[0])	# 10
print(t[1])	# 20
print(t[0:2])	# (10, 20)

 

튜플 수정 및 삭제 (에러 발생)

튜플은 요소를 변경하거나 삭제하려고 하면 TypeError가 발생합니다.

 

t = (10,20,30)
print(type(t))	# <class 'tuple'>
print(t)	# (10,20,30)

t = (1,2,3)
print(type(t))	# <class 'tuple'>
print(t)	# (1,2,3)

# 수정 진행
t[0] = 100	# 에러 발생
Traceback (most recent call last):
  File "<python-input-26>", line 1, in <module>
    t[0] = 10
    ~^^^
TypeError: 'tuple' object does not support item assignment

# 삭제 진행
del t[0]	# 에러 발생
Traceback (most recent call last):
  File "<python-input-27>", line 1, in <module>
    del t[0]
        ~^^^
TypeError: 'tuple' object doesn't support item deletion

 

🎯 튜플 변수 자체에 다른 값으로 재할당은 가능하나 튜플 요소 값의 수정은 불가능합니다. 그리고 튜플 변수를 메모리에서 삭제하는 것(del t)은 가능하지만, 튜플 내부의 특정 요소만 삭제하는 것은 불가능합니다. 

 

3️⃣ 튜플 인덱싱 및 슬라이싱

리스트와 마찬가지로 인덱스를 통해 특정 위치의 값에 접근하거나, 슬라이싱을 통해 범위 단위로 가져올 수 있습니다.

 

인덱싱(Indexing)

0부터 시작하는 양수 인덱스와 뒤에서부터 접근하는 음수 인덱스로 인덱싱이 가능합니다.

 

t = ("apple", "banana", "cherry")

print(t[0])	# apple
print(t[-1])	# cherry

 

슬라이싱(Slicing)

[시작:끝:증감폭] 형태로 작성하며, 끝 인덱스는 포함되지 않습니다.

 

numbers = (0,1,2,3,4,5,6)

print(numbers[1:4])	# (1, 2, 3) -> 인덱스 1부터 3까지
print(numbers[:3])	# (0, 1, 2) -> 처음부터 인덱스 2까지
print(numbers[3:])	# (3, 4, 5, 6) -> 인덱스 3부터 끝까지
print(numbers[::2])	# (0, 2, 4, 6) -> 2칸씩 건너뛰기

 

4️⃣ 튜플 연산하기

튜플 내부 요소는 바꿀 수 없지만, 튜플 간의 더하기(+) 및 곱하기(*) 연산을 통해 새로운 튜플을 만들어 낼 수 있습니다.

 

튜플 더하기(+)

t1 = (1,2)
t2 = (3,4)
result = t1 + t2
print(result)	# (1, 2, 3, 4)

 

튜플 곱하기(*)

t1 = ("a", "b")
result = t1 * 3
print(result)	# ('a', 'b', 'a', 'b', 'a', 'b')

 

튜플 길이 구하기

튜플에 들어있는 요소의 개수를 반환합니다. len() 함수를 사용하여 길이를 구할 수 있습니다.

t = (1,2,3,4,5,6,7,8)
print(len(t))	# 8

 

5️⃣ 튜플 주요 함수

튜플은 값이 변하지 않으므로 제공되는 자체 메서드(내장 함수)는 2개입니다. 하지만 파이썬의 표준 함수들과 함께 유용하게 쓰일 수 있습니다.

 

- count(value) 메서드

튜플 내에 특정 값이 몇 개 있는지 카운트합니다.

t = (1,2,3,4,5,1,2,3,1,2,1)
print(t.count(2))	# 출력 : 3 (숫자 2가 3개 있음)

 

- index(value) 메서드

특정 값이 처음으로 등장하는 인덱스 위치를 반환합니다.

t = (1,2,3,4,5,1,2,3,1,2,1)
print(t.index(3))	# 출력 : 2 (숫자 3은 인덱스 2번에 위치함)

 

6️⃣ 튜플 패킹과 언패킹

튜플의 아주 유용한 특징 중 하나는 여러 값을 묶거나(Packing) 풀어서 여러 변수에 한 번에 할당(UnPacking) 할 수 있다는 점입니다.

 

# 튜플 패킹 (여러 값을 하나의 튜플로 묶기)
packed = 1,2,3

# 튜플 언패킹 (튜플의 요소를 각각의 변수에 나누어 담기)
a,b,c = packed

print(packed)	# (1, 2, 3)
print(a)	# 1
print(b)	# 2
print(c)	# 3

# 변수 값 서로 교환하기 (Swap)
x,y = 10,20
x,y = y,x	# 내부적으로 튜플 언패킹 동작
print(x, y)	# 20 10

 

 

 

 

 

딕셔너리(Dictionary)

 

딕셔너리는 영한사전에서 'Apple'을 찾아보면 '사과'라고 정의하고 있는 것처럼, 이름(key)과 내용(Value)이 한 쌍으로 묶여 있는 공간을 뜻합니다. 딕셔너리는 중괄호를 사용하며 리스트나 튜플처럼 순차적으로 해당 요솟값을 구하지 않고 이름(key)으로 원하는 내용을 빠르게 찾을 수 있습니다.

---

1️⃣ 딕셔너리 생성

딕셔너리는 중괄호를 사용하며, Key : Value 형태로 요소를 작성합니다. dict() 함수를 사용할 수도 있습니다. Key는 중복될 수 없으며, 변경 불가능한 자료형(문자열, 숫자, 튜플 등)만 사용 가능합니다. Value는 중복이 가능하며, 어떤 자료형(리스트, 딕셔너리 포함)이든 올 수 있습니다.

 

# 중괄호를 이용하여 생성
person = {
	"name" : "홍길동",
    "age" : 25,
    "phone" : "010-123-1234",
    "hobby" : [
    	"독서", "영화감상"
    ]
}

# dict() 메서드를 이용하여 생성
car = dict(year=2025, brand="현대", model="아반떼")

# 빈 딕셔너리 생성
empty_dict1 = {}
empty_dict2 = dict()

print(person)
# 출력 : {'name': '홍길동', 'age': 25, 'phone': '010-123-1234', 'hobby': ['독서', '영화감상']}
print(car)
# 출력 : {'year': 2025, 'brand': '현대', 'model': '아반떼'}
print(empty_dict1)	# {}	
print(empty_dict2)	# {}

 

2️⃣ 딕셔너리 값 가져오기, 추가하기, 수정하기, 삭제하기

 

딕셔너리 값 가져오기

대괄호를 사용하거나 .get() 메서드를 이용합니다.

- dict[key] : 키가 없으면 KeyError 오류가 발생합니다.

- dict.get(key) : 키가 없어도 오류 대신 None을 반환하므로 안전합니다.

 

# 중괄호를 이용하여 생성
person = {
	"name" : "홍길동",
	"age" : 25,
	"phone" : "010-123-1234",
	"hobby" : [
		"독서", "영화감상"
	]
}

print(person["name"])		# 홍길동
print(person["phone"])		# 010-123-1234
print(person.get("hobby"))	# ['독서', '영화감상']
print(person.get("aaa", 200))	# 200 (키가 없을 때 기본값 지정)

# 없는 키로 값 꺼낼때
print(person["aaaa"])	# 에러 발생
Traceback (most recent call last):
  File "<python-input-57>", line 1, in <module>
    print(person["aaaa"])
          ~~~~~~^^^^^^^^
KeyError: 'aaaa'

print(person.get("aaaa"))	# None : 에러 발생하지 않음

 

딕셔너리에서 값을 꺼낼 때, 없는 키를 이용해서 값을 꺼내게 되는 경우에 에러가 발생하는 경우가 있고 그렇지 않은 경우가 있습니다. 'person["aaa"]'와 같은 형태로 값을 꺼낼 때에는 키가 존재하지 않는 경우라면 KeyError가 발생합니다. 하지만, 'person.get("aaa")'와 같은 형태로 값을 꺼낼 때에는 에러가 발생하지 않고 None이라는 값이 출력됩니다.

 

딕셔너리 수정 및 추가

존재하는 키에 값을 할당하면 수정되고, 존재하지 않는 키에 값을 할당하면 새로 추가됩니다.

 

info = {
	"name" : "홍길순",
    "score" : 89,
    "subject" : "수학"
}

# 수정
info["score"] = 98

# 추가
info["grade"] = "A"

print(info)
# 출력 : {'name': '홍길순', 'score': 98, 'subject': '수학', 'grade': 'A'}

 

딕셔너리 삭제

del 키워드나 .pop() 메서드를 사용합니다.

 

student = {
	"name" : "유재석",
    "math" : 90,
    "eng" : 85,
    "kor" : 92,
    "sci" : 88
}

# del 사용
del student["sci"]

# .po() 사용
math_score = student.pop("math")

print(student)		# {'name': '유재석', 'eng': 85, 'kor': 92}
print(math_score)	# 90

 

student 변수에 딕셔너리를 구성하고, 이름과 과목에 따른 점수를 이름과 값으로 구성하였습니다. del 키워드를 활용해서 student 안에 있는 과학점수에 대한 이름과 값을 삭제하였습니다. 그리고 .pop() 메서드를 활용해서 student 안에 있는 math 데이터를 꺼냈습니다. .pop() 메서드는 값을 꺼냄과 동시에 딕셔너리 안에 있는 데이터를 삭제합니다. 즉, 값을 복사하여 꺼내오는 게 아닌 값을 삭제하면서 꺼내옵니다.

 

3️⃣ 딕셔너리 인덱싱 및 슬라이싱

딕셔너리는 인덱싱과 슬라이싱을 지원하지 않습니다.

리스트나 튜플은 순서가 있는 자료형이지만, 딕셔너리는 순서가 아닌 키를 바탕으로 값을 조회하는 구조이기 때문입니다. 파이썬 3.7부터 입력 순서가 유지되긴 하지만, 여전히 dict[0] 같은 정수 인덱싱이나 dict[0:2] 같은 슬라이싱은 불가능하며 TypeError가 발생합니다. 

 

4️⃣ 딕셔너리 연산하기

딕셔너리는 숫자처럼 더하거나 곱하는 연산은 지원하지 않지만, 병합 연산자와 포함 여부 확인 연산자를 제공합니다. 

 

포함 여부 확인 (in, not in)

특정 키(Key)가 딕셔너리에 존재하는지 확인합니다. (Value는 확인하지 않음에 주의)

data = {"a": 1, "b": 2}

print("a" in data)	# True
print(1 not in data)	# True
print(1 in data)	# False (1은 Value 이므로 찾지 못함)

 

딕셔너리 병합 ( | 연산자)

파이썬 3.9 버전부터는 ' | ' 연산자를 사용해 두 딕셔너리를 쉽게 합칠 수 있습니다. (중복되는 키는 뒤의 값으로 덮어씌워집니다.)

dict1 = {"apple" : 1000, "banana" : 2000}
dict2 = {"banana" : 2500, "orange" : 3000}

merged = dict1 | dict2
print(merged)	# {'apple': 1000, 'banana': 2500, 'orange': 3000}

 

5️⃣ 딕셔너리 주요 함수

 

- keys() 메서드

딕셔너리의 모든 키(Key)를 모아 dict_keys 객체로 반환합니다. 반환된 객체는 동적 뷰 형태로, 딕셔너리가 수정되면 자동으로 반영되고 필요시 list(dict.keys()) 처럼 리스트로 변환하여 인덱싱을 사용할 수 있습니다. 

user = {"name" : "Alice", "age" : 25, "role" : "admin"}

print(user.keys())		# dict_keys(['name', 'age', 'role'])
print(list(user.keys()))	# ['name', 'age', 'role']

 

- values() 메서드

딕셔너리의 모든 값(Value)을 모아 dict_values 객체로 반환합니다. 

user = {"name" : "Alice", "age" : 25, "role" : "admin"}

print(user.values())		# dict_values(['Alice', 25, 'admin'])
print(list(user.values()))	# ['Alice', 25, 'admin']

 

- items() 메서드

Key와 Value를 튜플 형태로 묶어서 반환합니다. for문과 함께 딕셔너리를 순회할 때 가장 많이 사용됩니다.

user = {"name" : "Alice", "age" : 25, "role" : "admin"}

# for문과 함께 다중 할당 활용
for key, value in user.items():
	print(f"{key} -> {value}")
# 출력
# name -> Alice
# age -> 25
# role -> admin

 

- update() 메서드

다른 딕셔너리나 Key=Value 형태의 키워드 인자를 사용하여 기존 값을 수정하거나 새로운 키-값 상을 추가합니다.

info = {"name" : "Bob", "score" : 80}

info.update({"score": 95, "city" : "Seoul"})
print(info)	# {'name': 'Bob', 'score': 95, 'city': 'Seoul'}

info.update(age=30, score=100)
print(info)	# {'name': 'Bob', 'score': 100, 'city': 'Seoul', 'age': 30}

 

- clear() 메서드

딕셔너리 안의 모든 항목을 지워 빈 딕셔너리({})로 만듭니다.

data = {"a":1, "b":2}
print(data)	# {'a': 1, 'b': 2}
data.clear()
print(data)	# {}

 

 

 

 

 

@Junesker

---