5. 데이터 구조

1. 리스트(list)

파이썬에서는 기본 데이터 타입인 숫자형 타입, 불리언 타입, 문자열 타입과는 별도로 이들로 구성되는 다양한 컨테이너 형태의 데이터 구조를 제공합니다. 그 중에서도 가장 많이 사용되는 것이 바로 리스트(list) 타입입니다.
리스트(list)는 간단히 순서대로 늘어선 박스로 이해할 수 있습니다. 각 박스에는 다양한 타입의 데이터를 저장할 수 있으며, 이 박스들을 통틀어서 리스트라고 부르게 됩니다.

파이썬에서 리스트는 다음과 같은 특징을 가집니다.

리스트에 저장되는 요소가 모두 같은 타입일 필요는 없습니다.
리스트에는 요소들이 순서대로 저장되며, 각 요소는 0부터 시작하는 인덱스(index)를 사용하여 접근할 수 있습니다.
리스트는 그 값을 변경할 수 있습니다. (mutable type)

아무런 요소도 저장하고 있지 않은 리스트를 빈 리스트(empty list)라고 부르며, 파이썬에서는 []로 표현할 수 있습니다.

이와 같은 데이터 타입을 다른 프로그래밍 언어에서는 배열(array)이라고도 부르지만

파이썬에서는 리스트(list)라는 용어만을 사용합니다.

1-1. 리스트 선언하기

파이썬에서 리스트는 대괄호([])로 감싸서 선언할 수 있으며, 리스트 안의 요소(element)들은 쉼표(,)로 구분합니다.

리스트명 = [요소1, 요소2, 요소3, ...]

다음 예제는 4개의 요소를 가지는 리스트를 선언하고, 해당 리스트의 모든 요소를 출력하는 예제입니다.

primes = [2, 3, 5, 7]  
 
for p in primes:
    print(p)  
 
print(len(primes))

결과

위의 예제처럼 리스트는 같은 타입의 데이터뿐만 아니라 서로 다른 타입의 데이터도 함께 저장할 수 있으며, for 문을 사용하면 저장된 모든 요소에 손쉽게 접근할 수 있습니다.
또한, 파이썬 내장 함수인 len() 함수를 사용하면 리스트의 길이, 즉 리스트에 저장된 모든 요소의 개수를 손쉽게 알 수 있습니다.

1-2. 리스트 요소 선택하기

for 문을 사용하면 리스트의 모든 요소에 순차적으로 접근할 수 있습니다. 하지만 리스트의 특정 요소에만 접근하고 싶을 때에는 0부터 시작하는 인덱스(index)를 사용해야만 합니다.
리스트의 첫 번째 요소는 0, 두 번째 요소는 1, 세 번째 요소는 각각 2의 인덱스를 가지며 이처럼 리스트의 각 요소는 저장될 때 순서대로 1씩 증가되는 인덱스를 자동으로 부여받습니다. 또한, 문자열과 마찬가지로 음의 인덱스를 지원하며, 음의 인덱스는 리스트의 마지막 요소를 -1로 놓고 역순으로 증가됩니다.

primes = [2, 3, 5, 7]  
 
print(primes[0])
print(primes[-1])
print(primes[1] + primes[3])  
 
# print(primes[5])

결과

2
7
10

위의 예제에서 primes[-1]과 primes[3]은 똑같이 리스트의 마지막 요소인 7을 가리키고 있습니다. 리스트의 모든 요소는 이처럼 양의 인덱스와 음의 인덱스의 두 가지 방법으로 접근할 수 있습니다.
이때 주석 처리된 7번 라인처럼 리스트의 총 길이를 벗어난 올바르지 않은 인덱스를 사용하게 되면, IndexError가 발생하며 프로그램은 강제 종료됩니다. 따라서 리스트를 사용할 때는 언제나 리스트의 길이와 인덱스에 충분한 주의를 기울여야 합니다.

1-3. 리스트 자르기

리스트를 다루다보면 리스트의 일부분만을 선택하거나 리스트의 일부 요소들만을 수정해야 할 경우가 생깁니다. 이러한 경우 손쉽게 처리할 수 있도록 문자열과 마찬가지로 리스트에서도 슬라이싱(slicing)을 지원하고 있습니다.

list1 = [1, 2, 3, 4, 5]  
 
print(list1[3])
print(list1[1:3])
print(list1[:3])
print(list1[3:])
print(list1)

결과

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

위 예제의 4번 라인처럼 콜론(:)기호를 사용하면 리스트의 일부분만을 자를 수 있으며, 이때 콜론의 앞쪽에 위치한 인덱스부터 콜론의 뒤쪽에 위치한 인덱스 바로 앞까지의 요소를 모두 반환합니다.
이때 유의할 점은 콜론의 앞쪽에 위치한 인덱스는 곧바로 시작 인덱스가 되지만, 콜론의 뒤쪽에 위치한 인덱스는 해당 인덱스에서 1을 뺀 인덱스가 마지막 인덱스가 된다는 점입니다.
하지만 7번 라인의 실행 결과에서 확인할 수 있듯이 리스트 자르기는 원본 리스트에는 전혀 영향을 미치지 않으며, 해당 부분에 해당하는 새로운 리스트를 생성하여 반환해 주는 것입니다.

1-4. 리스트 복사하기

list1 = [1, 2, 3, 4, 5]  
 
copy = list1
copy.append(6)  
 
print(copy)
print(list1)

결과

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

위의 예제에서는 대입 연산자(=)를 사용하여 리스트를 그대로 변수에 대입함으로써 리스트를 복사하고자 합니다. 그리고나서 4번 라인에서 복사된 리스트에 6을 추가합니다.
하지만 6번과 7번 라인의 실행 결과에서 추가한 6이라는 요소가 복사된 리스트뿐만 아니라 원본 리스트에도 추가되었음을 확인할 수 있습니다.
이처럼 단순히 리스트명을 변수에 대입하는 것은 리스트를 복사하는 것이 아니라 원본 리스트의 메모리 주소만을 넘겨주는 것입니다. 즉, 3번 라인에 의해 리스트명 list1과 변수명 copy는 같은 리스트를 가리키게 된 것입니다.

따라서 리스트의 복사본을 제대로 만들고 싶다면 다음과 같이 리스트 슬라이싱을 이용하여 리스트를 복사해야 합니다.

list1 = [1, 2, 3, 4, 5]  
 
copy = list1[:]
copy.append(6)  
 
print(copy)
print(list1)

결과

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

위 예제의 3번 라인에서 사용된 list1[:]은 리스트 list1의 모든 요소를 선택하여 자르는 구문입니다. 이렇게 잘린 리스트는 원본 리스트와는 별도의 리스트로 반환되기때문에 6번과 7번 라인을 통해 리스트가 제대로 복사되었음을 확인할 수 있습니다.

1-5. 리스트끼리의 연산

파이썬에서는 리스트끼리 더하거나 리스트에 숫자를 곱할 수도 있습니다.
리스트끼리의 더하기(+) 연산은 두 리스트를 서로 연결시켜주며, 리스트와 정수의 곱하기(*) 연산은 해당 리스트의 모든 요소들을 정수배만큼 반복해서 연결해 줍니다.

list1 = [1, 2, 3]
list2 = list((4, 5, 6))
 
print(list1 + list2)
print(list1 * 3)  
 
list1.extend(list2)
print(list1)

결과

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

위 예제의 7번 라인과 같이 extend() 함수를 사용하면 더하기(+) 연산과 마찬가지로 하나의 리스트에 다른 리스트를 연결할 수 있습니다. 단, 리스트끼리의 더하기(+) 연산은 원본 리스트에는 전혀 영향을 미치지 않지만, extend() 함수는 원본 리스트 그 자체를 변경하는 점이 다릅니다.
또한, 위 예제의 1번과 2번 라인처럼 파이썬에서 리스트는 대괄호를 사용하거나 list() 함수를 사용해서 선언할 수 있습니다. 이때 list() 함수의 인수로는 순환할 수 있는 객체(iterable object)만을 사용할 수 있습니다.

1-6. 리스트에 요소 추가하거나 제거하기

append() 함수는 전달된 인수를 해당 리스트의 마지막 요소로 추가하고, remove() 함수는 전달된 인수를 해당 리스트에서 찾아 제거합니다.

list1 = [1, 2, 3, 4, 5]  
 
list1.append(2)
print(list1) 
 
list1.remove(3)
print(list1)  
 
list1.remove(2)
print(list1)

결과

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

만약 remove() 함수에 인수로 전달한 요소가 해당 리스트에 두 개 이상 존재할 경우에는 위 예제의 9번 라인처럼 인덱스가 가장 낮은 요소 하나만을 삭제하게 됩니다.

1-7. 리스트에 요소 삽입하거나 꺼내기

insert() 함수는 해당 리스트의 지정된 인덱스에 전달된 인수를 요소로 삽입하며, pop() 함수는 전달받은 인덱스에 위치한 요소를 리스트에서 추출하여 반환합니다.

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

list1.insert(3, 9)
print(list1)  
 
list1.pop(4)
print(list1)

결과

[1, 2, 3, 9, 4, 5]
[1, 2, 3, 9, 5]

insert() 함수는 첫 번째 인수로 요소를 삽입할 인덱스를 전달받고, 두 번째 인수로 삽입할 요소를 전달받습니다.

1-8. 리스트 뒤집거나 정렬하기

reverse() 함수는 리스트의 모든 요소를 역순으로 뒤집어서 반환하며, sort() 함수는 리스트의 모든 요소를 순서대로 정렬해줍니다.

list1 = [5, 2, 4, 1, 3]
list2 = [5, 2, 4, 1, 3]  
 
list1.reverse()
print(list1)  
 
list1.sort()
print(list1)  
 
print(sorted(list2))
print(list2)

결과

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

위 예제의 10번 라인과 같이 파이썬의 내장 함수인 sorted() 함수를 사용해도 리스트를 정렬할 수 있습니다.
이때 리스트 함수인 sort() 함수는 원본 리스트 그 자체를 정렬하여 변경하지만, 파이썬 내장 함수인 sorted() 함수는 원본 리스트는 변경하지 않고 정렬된 새로운 리스트를 반환해 줍니다.

1-9. 중첩 리스트

파이썬에서는 리스트의 요소로 또 다른 리스트를 추가할 수 있습니다.
이때 중첩된 안쪽 리스트의 특정 요소의 인덱스는 두 개의 대괄호([][])를 사용하여 표시할 수 있습니다.

matrix = [[1, 2, 3], ["하나", "둘", "셋"]]  
 
print(matrix[0])
print(matrix[0][0])
print(matrix[1][2])

결과

[1, 2, 3]
1
셋

위 예제의 4번 라인처럼 중첩 리스트에서 첫 번째 인덱스는 바깥쪽 리스트의 인덱스로 인식되며, 두 번째 인덱스는 안쪽 리스트의 인덱스로 인식됩니다. 따라서 5번 라인은 바깥쪽 리스트의 두 번째 요소인 안쪽 리스트에서 또 다시 세 번째 요소를 선택하라는 의미가 됩니다.
이와 같은 방법을 사용하여 리스트를 몇 번이고 중첩시킬 수 있지만, 현실적으로 이해하기 쉽도록 2번 이상의 중첩은 잘 사용하지 않습니다.

2. 튜플(tuple)

파이썬에서 튜플은 여러 개의 데이터를 하나로 묶는데 사용됩니다.
이러한 튜플은 리스트(list)와 거의 비슷하지만 다음과 같은 점에서 서로 다릅니다.

튜플은 그 값을 변경할 수 없습니다. (immutable type)
튜플은 리스트와 같은 데이터 타입에 비해 그 실행 속도가 빠릅니다.

따라서 프로그램이 실행되는 동안 그 값을 일정하게 유지해야만 하는 데이터는 튜플로 작성하는 것이 성능이 좋으며, 도중에 그 값이 변경되거나 변경될지도 모르는 데이터는 리스트로 작성하는 것이 좋습니다.

아무런 요소도 저장하고 있지 않은 튜플을 빈 튜플(empty tuple)이라고 부르며, 파이썬에서는 ()로 표현합니다.

2-1. 튜플 선언하기

튜플은 리스트와 마찬가지로 요소(element)를 쉼표(,)로 구분하지만, 대괄호 대신 소괄호(())로 감싸거나 아예 감싸지 않고 선언합니다.

튜플명 = (요소1, 요소2, 요소3, ...)
또는
튜플명 = 요소1, 요소2, 요소3, ...

tuple1 = (1, 2, 3)
tuple2 = 1, 2, 3  
 
tuple3 = (1,)
tuple4 = (1)  
 
print(tuple1)
print(tuple2)  
 
print(tuple3)
print(tuple4)

결과

(1, 2, 3)
(1, 2, 3)
(1,)
1

위 예제의 2번 라인처럼 파이썬에서는 소괄호(())를 사용하지 않아도 자동으로 튜플로 인식됩니다.
그리고 4번 라인처럼 하나의 요소만을 가지는 튜플은 반드시 쉼표(,)를 포함해야만 제대로 튜플로 인식됩니다. 만약 하나의 요소만을 가지는 튜플에서 쉼표를 생략하게 되면, 파이썬 프로그램은 해당 데이터를 튜플이 아닌 그냥 하나의 데이터로만 인식하게 됩니다.

2-2. 튜플 사용하기

파이썬에서 튜플의 사용 방법은 그 값을 변경할 수 없다는 점을 제외하면 리스트를 사용하는 방법과 같습니다. 단, 값을 변경할 수 없기 때문에 요소를 추가하거나 삭제, 삽입, 추출하는 동작 등은 수행할 수 없습니다.

tuple1 = (1, 2, 3)
tuple2 = tuple(["원", "투", "쓰리"])
 
# 튜플 요소 선택하기
print(tuple1[0])
print(tuple2[-1])  
 
# 튜플 자르기
print(tuple1[1:])
print(tuple2[:2])  
 
# 튜플끼리의 연산
print(tuple1 + tuple2)
print(tuple1 * 2)

결과

1
쓰리
(2, 3)
('원', '투')
(1, 2, 3, '원', '투', '쓰리')
(1, 2, 3, 1, 2, 3)

위 예제의 1번과 2번 라인처럼 파이썬에서 튜플 타입의 데이터는 소괄호를 사용하거나 tuple() 함수를 사용해서 선언할 수 있습니다. 이때 tuple() 함수의 인수로는 순환할 수 있는 객체(iterable object)만을 사용할 수 있습니다.
또한, 튜플 타입에 한해 다음에 소개할 패킹(packing)을 이용하여 튜플을 선언할 수도 있습니다.

3. 패킹(packing)과 언패킹(unpacking)

여러 타입의 데이터를 하나의 튜플이나 리스트로 묶어 선언하는 것을 패킹(packing)이라 하며, 하나의 튜플이나 리스트의 요소들을 여러 개의 변수에 나누어 대입하는 것을 언패킹(unpacking)이라 합니다.
이러한 언패킹은 파이썬만의 독특한 문법으로 코드를 작성할 때 매우 유용하게 사용할 수 있습니다.

# 패킹(packing)
tuple1 = 10, "열", True  
 
# 언패킹(unpacking)
a, b, c = tuple1
# a, b, c, d = tuple1
# a, b = tuple1  
 
print(a)
print(b)
print(c)

결과

10
열
True

위 예제의 2번 라인처럼 별도로 소괄호(())를 사용하지 않더라도 둘 이상의 데이터가 쉼표로 연결되어 있으면, 파이썬은 자동으로 해당 데이터들을 하나의 튜플로 패킹(packing)해 줍니다.
또한, 5번 라인처럼 둘 이상의 변수에 튜플의 각 요소들을 한 번에 언패킹(unpacking)할 수도 있습니다.
하지만 6번이나 7번 라인처럼 언패킹을 위한 변수의 개수가 튜플이나 리스트의 길이와 다를 경우에는 ValueError가 발생합니다. 따라서 언패킹을 할 때는 언제나 변수의 개수와 튜플이나 리스트의 길이가 일치하는지를 확인해야만 합니다.

4. 특정 요소의 포함 여부

튜플이나 리스트, 세트 등에 어느 특정 요소가 포함되어 있는지를 확인하려면 in 키워드를 사용할 수 있습니다.
in 키워드를 사용한 결과 해당 데이터에 특정 요소가 포함되어 있으면 참(True)를 반환하고, 포함되어 있지 않으면 거짓(False)를 반환합니다.

tuple1 = 10, "열", True  
 
print(10 in tuple1)
print("아홉" in tuple1)
print("아홉" not in tuple1)

결과

True
False
True

위 예제의 5번 라인처럼 in 키워드 앞에 not를 붙여서 사용하면, in 키워드와는 반대로 특정 요소가 포함되어 있지 않으면 참(True)를 반환하고 포함되어 있으면 거짓(False)를 반환하게 됩니다.

5. 세트(set)

파이썬의 세트는 우리가 수학에서 자주 접한 개념인 집합과 같은 개념으로, 하나의 포대 안에 모든 데이터를 몰아서 저장하는 것으로 쉽게 이해해 볼 수 있습니다. 따라서 세트 타입에서는 각 요소들의 순서를 매길 수 없으며, 중복된 값 또한 허용하지 않습니다.
세트는 중괄호({})로 감싸서 선언하며, 세트 안의 요소(element)들은 쉼표(,)로 구분합니다.
또한, 파이썬 내장 함수인 set() 함수를 사용하면 문자열과 같이 순환할 수 있는 객체(iterable object)를 세트로 변환할 수 있습니다.

파이썬에서 순환할 수 있는 객체(iterable object)란 저장된 요소를 하나씩 차례대로 반환할 수 있는 객체를 의미하며,

대표적으로 리스트, 튜플, 문자열 등이 있습니다.

세트명 = {요소1, 요소2, 요소3, ...}

set1 = {1, 2, 3}
set2 = set("Python")
set3 = set("Hello")  
 
print(set1)
print(set2)
print(set3)

결과

{1, 2, 3}
{'P', 'y', 'h', 'n', 'o', 't'}
{'l', 'e', 'o', 'H'}

위의 예제의 출력 결과는 실행결과 버튼을 누를 때마다 다르게 변할 것입니다. 이것은 파이썬의 세트가 요소들 사이의 순서는 신경 쓰지 않기 때문입니다.
또한, 7번 라인에서 ‘Hello' 문자열에 포함된 두 개의 'l'문자 중 하나만이 세트의 요소로 포함된 것처럼 파이썬에서 순환할 수 있는 객체를 세트로 변환할 때는 자동으로 중복된 값이 제거됩니다.

5-1. 빈 세트(empty set)

아무런 요소도 저장하고 있지 않은 집합을 빈 세트(empty set)라고 합니다.
파이썬에서는 빈 세트를 나타낼 때 리스트나 튜플처럼 단순히 중괄호({})만을 사용해서는 안 됩니다. 만약 빈 세트를 나타내기 위해 중괄호({})만을 사용하게 되면, 파이썬 프로그램은 이를 빈 세트가 아닌 빈 딕셔너리로 잘못 인식할 것입니다.
따라서 파이썬에서 빈 세트는 중괄호가 아닌 set() 함수를 통해서만 선언할 수 있습니다.

set1 = {}
set2 = set()  
 
print(type(set1))
print(type(set2))

결과

<class 'dict'>
<class 'set'>

파이썬 내장 함수인 type() 함수는 인수로 전달받은 객체의 데이터 타입을 반환하는 함수입니다. 따라서 단순히 중괄호({})만을 사용하여 선언할 경우에는 딕셔너리 타입으로 선언됨을 확인할 수 있습니다.

5-2. 세트에 요소 추가하거나 제거하기

add() 함수는 전달된 인수를 해당 세트의 요소로 추가하고, remove() 함수는 해당 세트에서 전달된 인수를 찾아 제거합니다.
여러 개의 요소를 한 번에 추가하려면 update() 함수를 사용하면 되며, 이때 인수로는 순환할 수 있는 객체(iterable object) 타입만을 전달할 수 있습니다.

set1 = {1, 2, 3}  
 
set1.add(4)
print(set1)  
 
set1.update((5, 6))
print(set1)  
 
set1.remove(2)
print(set1)

{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6}
{1, 3, 4, 5, 6}

5-3. 집합 연산

파이썬의 세트 타입은 수학에서 다루는 집합과 매우 비슷하게 동작합니다. 따라서 파이썬에서는 합집합, 교집합, 차집합, 여집합 등 다양한 집합 연산을 세트 타입을 활용하여 매우 손쉽게 구현할 수 있습니다.

set1 = {1, 2, 3, 4, 5}
set2 = set((1, 3, 5, 7, 9))  
 
print(set1)
print(set2)  
 
print(set1 | set2) # 합집합
print(set1 & set2) # 교집합
print(set1 - set2) # 차집합
print(set1 ^ set2) # 여집합 = 합집합 - 교집합

결과

{1, 2, 3, 4, 5}
{1, 3, 5, 7, 9}
{1, 2, 3, 4, 5, 7, 9}
{1, 3, 5}
{2, 4}
{2, 4, 7, 9}

위 예제의 1번과 2번 라인처럼 파이썬에서 세트 타입의 데이터는 중괄호를 사용하거나 set() 함수를 사용해서 선언할 수 있습니다. 이때 set() 함수의 인수로는 순환할 수 있는 객체(iterable object)만을 사용할 수 있습니다.

6. 딕셔너리(dictionary)

리스트와 튜플 등에서는 정수인 인덱스(index)를 가지고 순차적으로 각 요소에 접근할 수 있었다면, 딕셔너리는 단어 그대로의 '사전'과 같이 별도로 정의한 키(key)를 통해 각 요소에 접근할 수 있도록 만들어진 데이터 타입입니다.
사전에서 단어를 가지고 그 단어의 설명을 찾을 수 있듯이, 딕셔너리에서는 키(key)를 가지고 그 키에 해당하는 값(value)을 찾을 수 있는 것입니다.

대부분의 프로그래밍 언어에서는 파이썬의 딕셔너리와 같이 키(key)와 값(value)으로 구성된 데이터 타입을 맵(map)이라고 부릅니다.
ex) JAVA : Map 컬렉션 클래스, C++ : Map 컨테이너 등

6-1. 딕셔너리 선언하기

딕셔너리는 중괄호({})로 감싸서 선언하며, 딕셔너리의 각 요소(element)들은 쉼표(,)를 사용하여 구분합니다.
이러한 딕셔너리의 요소는 또다시 키(key)와 값(value)의 한 쌍으로 구성되며, 이 둘은 콜론(:)으로 연결됩니다.

딕셔너리명 = {요소1, 요소2, 요소3, ...}
요소 = 키(key): 값(value)

dict1 = {'하나': 1, '둘': 'two', '파이': 3.14}
dict2 = dict({'하나': 1, '둘': 'two', '파이': 3.14})
dict3 = dict([('하나', 1), ('둘', 'two'), ('파이', 3.14)])
dict4 = dict(하나=1, 둘='two', 파이=3.14)  
 
print(dict1)
print(dict2)
print(dict3)
print(dict4)

결과

{'하나': 1, '둘': 'two', '파이': 3.14}
{'하나': 1, '둘': 'two', '파이': 3.14}
{'하나': 1, '둘': 'two', '파이': 3.14}
{'하나': 1, '둘': 'two', '파이': 3.14}

위의 예제처럼 파이썬 내장 함수인 dict() 함수를 사용해도 딕셔너리를 선언할 수 있습니다. 단, 4번 라인처럼 dict() 함수의 인수에 대입 연산자(=)를 바로 사용하기 위해서는 키(key)가 문자열이어야만 합니다.
딕셔너리의 키(key)는 정수뿐만 아니라 문자열이나 실수 등도 사용할 수 있지만, 리스트나 딕셔너리와 같이 변경할 수 있는 타입(mutable types)의 값은 사용할 수 없습니다.

dict1 = {'하나': 1, 2: 'two', 3.14: 'pi'}
dict2 = {('ten', 10): ['열', 10.0]}  
 
print(dict1)
print(dict2)

결과

{'하나': 1, 2: 'two', 3.14: 'pi'}
{('ten', 10): ['열', 10.0]}

위 예제의 2번 라인처럼 튜플은 그 값을 변경할 수 없는 타입(immutable types)이므로, 딕셔너리의 키(key)로 사용될 수 있습니다.

6-2. 딕셔너리 사용하기

딕셔너리는 대괄호([])를 사용하여 키(key)를 전달함으로써 해당 키로 저장된 값을 얻을 수 있습니다.
또한, 딕셔너리의 내장 함수인 get() 함수를 사용해도 같은 결과를 얻을 수 있습니다.
이 두 방식 간의 차이점은 존재하지 않는 키(key)에 대해 대괄호를 사용하는 방식은 KeyError를 발생시키며 프로그램을 강제 종료시키지만, get() 함수는 정상적으로 종료되며 None을 반환하는 것뿐입니다.

dict1 = dict({'자바': 80, 'PHP': 90, 'HTML': 70})  
 
print(dict1['자바'])
print(dict1.get('자바'))  
 
# print(dict1['파이썬'])
print(dict1.get('파이썬'))

결과

80
80
None

None이란 ‘값이 없음’을 나타내는 파이썬의 예약 상수입니다.

6-3. 딕셔너리에 요소 추가하거나 제거하기

딕셔너리에 요소를 추가하려면 대괄호([]) 안에 키(key)를 넣고 대입 연산자(=)를 사용하여 값(value)을 저장하면 됩니다.
예를 들어, {‘파이썬’: 100}이라는 요소를 딕셔너리 dict1에 추가하려면, 다음과 같이 추가할 수 있습니다.

dict1[‘파이썬’] = 100

또한 del 키워드를 사용하여 딕셔너리에 포함된 특정 요소를 제거할 수 있으며, 딕셔너리의 clear() 함수를 사용하면 딕셔너리에 저장된 모든 요소들을 한 번에 삭제할 수 있습니다.

dict1 = dict({'자바': 80, 'PHP': 90, 'HTML': 70})  
dict1['파이썬'] = 100
print(dict1)  
 
del dict1['PHP']
print(dict1)  
 
dict1['자바'] = 100
print(dict1)  
 
dict1.clear()
print(dict1)

결과

{'자바': 80, 'PHP': 90, 'HTML': 70, '파이썬': 100}
{'자바': 80, 'HTML': 70, '파이썬': 100}
{'자바': 100, 'HTML': 70, '파이썬': 100}
{}

위 예제의 6번 라인처럼 del 키워드는 함수가 아니므로 소괄호(())를 사용하지 않습니다.
그리고 9번 라인처럼 이미 저장되어 있는 키(key)와 동일한 키를 사용하여 요소를 추가하면, 이전에 저장된 값은 지워지고 나중에 추가한 값만이 저장됩니다.
10번 라인의 출력에서 확인할 수 있는 ‘자바’라는 키(key)로 저장된 80이라는 값이 9번 라인에 의해 100으로 변경된 것을 확인할 수 있으며, 이를 이용하여 딕셔너리에 저장된 값을 변경할 수 있는 것입니다.

6-4. 딕셔너리의 정보 얻기

딕셔너리의 keys() 함수를 사용하면 딕셔너리에 저장된 모든 요소의 키(key)들을 한 번에 얻을 수 있으며, values() 함수를 사용하면 딕셔너리에 저장된 모든 요소들의 값(value)들을 따로 얻을 수 있습니다.
또한, 딕셔너리의 items() 함수는 딕셔너리에 저장된 모든 요소들을 각각 키와 값의 한 쌍으로 이루어진 튜플의 형태로 반환합니다.
keys()와 values(), items() 함수의 반환값은 각각 dict_keys와 dict_values, dict_items 객체로서, 이 객체들은 list() 함수를 사용하여 리스트 타입으로 변환하여 사용할 수 있습니다. 하지만 굳이 리스트로 변환하지 않더라도 반복문 등에 그대로 사용할 수 있습니다.

dict1 = dict({'자바': 80, 'PHP': 90, 'HTML': 70})  
 
print(dict1.keys())
print(dict1.values())
print(dict1.items())  
 
print('HTML' in dict1)
print('파이썬' in dict1)

결과

dict_keys(['자바', 'PHP', 'HTML'])
dict_values([80, 90, 70])
dict_items([('자바', 80), ('PHP', 90), ('HTML', 70)])
True
False

위 예제의 7번과 8번 라인처럼 in 키워드를 사용하여 해당 딕셔너리에 특정 키(key)가 포함되어 있는지 여부를 손쉽게 확인할 수 있습니다.

파이썬 2.X 버전까지는 keys()와 values(), items() 함수의 반환값이 모두 리스트 타입이었습니다.

하지만 리스트 타입으로 이들 함수의 결과를 반환하기 위해서는 메모리의 낭비가 많이 발생하였기에, 이를 줄이고자 파이썬 3.0 버전부터는 각각 dict_keys와 dict_values, dict_items 객체로 결과값을 반환하도록 변경되었습니다.

참고 : http://tcpschool.com