파이썬: 리스트(list)와 튜플(Tuple)

리스트와 튜플

파이썬에는 두 가지 다른 시퀀스 구조인 튜플과 리스트가 있다.

이들 항목은 다른 타입이 될 수 있다.

즉, 각 요소는 어떤 객체도 될 수 있다.

리스트

리스트는 데이터를 순차적으로 파악하는데 유용하다.

특히, 내용의 순서가 바뀔 수 있고, 문자열과 달리 변경이 가능하다.

리스트의 현재 위치에서 새로운 요소를 추가하거나 삭제 혹은 기존 요소를 덮어쓸 수 있다.

또한 동일한 값이 여러번 나타날 수 있다.

리스트 생성: [ ] 또는 list()

리스트는 0 또는 그 이상의 요소로 만들어진다.

콤마(,)로 구분하고, 대괄호([ ])로 둘러싸여 생성된다.

또한 list 함수로 빈 리스트를 할당할 수 있다.

# list 생성
>>> empty_list = []
>>> days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

# list 할당
>>> empty_list2 = list()

다른 데이터 타입을 리스트로 변환하기: list()

list() 함수는 다른 데이터 타입을 리스트로 변환한다.

# 문자열 -> 리스트
>>> list('dog')
['d', 'o', 'g']

# 튜플 -> 리스트
>>> a_tuple = ('one', 'two', 'three')
>>> list(a_tuple)
['one', 'two', 'three']

문자열에서 사용되는 split()은 문자열을 구분자로 나누어서 리스트로 변환한다.

>>> birthday = '10/23/1999'
>>> birthday.split('/')
['10', '23', '1999']

[offset]으로 항목 얻기

문자열과 마찬가지로 리스트는 오프셋으로 하나의 특정 값을 추출할 수 있다.

>>> animal = ['cat', 'dog', 'cow']
>>> animal[0]
'cat'

>>> animal[1]
'dog'

>>> animal[2]
'cow'

>>> animal[-1]
'cow'

>>> animal[-2]
'dog'

>>> animal[-3]
'cat'

리스트의 리스트

리스트는 다음과 같이 다른 타입의 요소도 포함할 수 있다.

>>> small_animal = [1, 'cat', 2, 'dog']
>>> big_animal = [3, 'cow', 1, 'horse']
>>> all_animal = [small_animal, big_animal]

여기서 all_animal은 리스트 안에 또 다른 리스트가 들어간 형태로 다음과 같이 된다.

>>> all_animal = [[1, 'cat', 2, 'dog'], [3, 'cow', 1, 'horse']]

offset을 이용해서 항목을 추출해보자.

>>> all_animal[0]
[1, 'cat', 2, 'dog']

 

첫번째 항목은 리스트 형태로 출력된다.

즉, all_animal의 첫 번째 항목은 small_animal이다.

 

그럼 small_animal 안의 항목을 꺼내고 싶다면 어떻게 해야할까?

>>> all_animal[0][1]
'cat'

이처럼 두개의 인덱스(오프셋)을 사용하면 된다.

[0]은 all_animal의 첫번째 항목을 가리키고, [1]은 앞에서 가리킨 항목의 두번째 항목을 가리킨다.

offset으로 항목바꾸기

>>> animal = ['cat', 'dog', 'cow']
>>> animal[2] = 'horse'
>>> animal
['cat', 'dog', 'horse']

이처럼 오프셋을 통해 리스트의 항목을 바꿀 수 있다.

오프셋은 리스트에서 유효한 위치여야 한다.

문자열은 불변하기 때문에 이러한 방식으로 변경할 수 없다.

슬라이스로 항목 추출하기

슬라이스를 사용해서 리스트의 서브 시퀀스를 추출할 수 있다.

>>> animal = ['cat', 'dog', 'cow', 'horse']
>>> animal[:2]
['cat', 'dog']

>>> animal[::2]
['cat', 'cow']

>>> animal[::-1]
['horse', 'cow', 'dog', 'cat']

리스트의 슬라이스 또한 리스트이다.

리스트 관련 함수

리스트에 항목 추가: append()

append() 함수는 리스트의 끝에 새 항목을 추가한다.

>>> animal = ['dog', 'cat']
>>> animal.append('cow')
>>> animal
['dog', 'cat', 'cow']

>>> num = [1, 2]
>>> animal.append(num)
>>> animal
['dog', 'cat', 'cow', [1, 2]]

리스트 병합하기: extend() 또는 +=

extend() 또는  +=를 사용하면 다른 리스트를 병합할 수 있다.

>>> small_animal = ['dog', 'cat']
>>> big_animal = ['cow', 'horse']
>>> small_animal.extend(big_animal)
>>> small_animal
['dog', 'cat', 'cow', 'horse']

>>> num1 = [1, 2]
>>> num2 = [2, 3]
>>> num1 += num2
>>> num1
[1, 2, 2, 3]

항목 추가하기: insert()

append() 함수는 단순히 리스트의 끝에 항목을 추가한다.

그러나 insert() 함수를 사용하면 원하는 위치에 항목을 추가할 수 있다.

>>> animal = ['cat', 'dog']
>>> animal.insert(1, 'cow')
>>> animal
['cat', 'cow', 'dog']

>>> animal.insert(10, 'horse')
['cat', 'cow', 'dog', 'horse']

위의 예시를 보면 오프셋이 리스트의 끝을 넘는 값인 10이 들어가 있는 것을 볼 수 있다.

이처럼 리스트의 끝을 넘어가는 오프셋이 들어가게 되면, 자동으로 리스트의 맨 뒤에 값이 추가되게 된다.

항목 삭제하기: del, remove(), pop()

오프셋과 del을 이용하여 특정 위치의 값을 삭제할 수 있다.

>>> num = [1, 2, 3]
>>> del num[1]
>>> num
[1, 3]

리스트에서 삭제할 항목의 위치를 모른다면, remove()와 그 값을 이용하여 항목을 삭제할 수 있다.

>>> num = [1, 2, 3, 4, 5]
>>> num.remove(2)
>>> num
[1, 3, 4, 5]

pop()은 리스트에서 항목을 가져오는 동시에 그 항목을 삭제한다.

즉, 오프셋과 함께 pop()을 호출했다면 그 오프셋의 항목이 반환된다.

인자가 없다면 -1을 사용한다.

pop(0)은 리스트의 머리(시작)을 반환하고, pop(-1) 또는 pop()은 리스트의 꼬리(끝)을 반환한다.

>>> num = [1, 2, 3, 4, 5]
>>> num.pop()
5

>>> num
[1, 2, 3, 4]

>>> num.pop(1)
2

>>> num
[1, 3, 4]

값으로 항목 오프셋 찾기: index()

항목 값의 리스트 오프셋을 알고 싶다면 index()를 사용하면 된다.

>>> animal = ['cat', 'dog', 'cow']
>>> animal.index('cat')
0

존재여부 확인하기: in

리스트에 어떠한 값의 존재를 확인하려면 in을 사용한다.

>>> num = [1, 2, 3, 4]
>>> 2 in num
True

>>> 5 in num
False

값의 개수 세기: count()

리스트에 특정 값이 얼마나 있는지 세기 위해 사용한다.

>>> animal = ['cat', 'cat', 'cat', 'dog', 'cow']
>>> animal.count('cat')
3

>>> animal.count('hippo')
0

문자열로 변환: join()

>>> friends = ['Harry', 'Hermione', 'Ron']
>>> seperator = ' * '
>>> joined = separator.join(friends)
>>> joined
'Harry * Hermione * Ron'

>>> separated = joined.split(separator)
>>> separated
['Harry', 'Hermione', 'Ron']

>>> freinds == separated
True

join()의 인자는 문자열 혹은 반복 가능한 문자열의 시퀀스이다 .

결과로 반환되는 값은 문자열이다.

이처럼 join을 한 후 다시 split()을 했을 때의 결과값을 비교해보면 같은 값인 것을 확인할 수 있다.

join()을 split()의 반대라고 생각하면 좀 더 수월하다.

정렬하기: sort()

오프셋을 이용하여 리스트를 정렬할 때도 있지만, 값을 이용하여 정렬할 때도 있다.

파이썬은 두 가지 함수를 제공한다.

• sort(): 리스트 자체를 내부적으로 정렬한다.
• sorted(): 리스트의 정렬된 복사본을 반환한다.

리스트의 항목이 숫자인 경우, 기본적으로 오름차순으로 정렬하고,

문자열인 경우, 알파벳순으로 정렬한다.

>>> num = [2, 5, 1, 4, 3]
>>> sorted_num = sorted(num)
>>> sorted_num
[1, 2, 3, 4, 5]

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

>>> num.sort()
[1, 2, 3, 4, 5]

>>> animal = ['dog', 'cat', 'hippo']
>>> animal.sort()
['cat', 'dog', 'hippo']

예시를 보면 sorted()를 사용했을 때 기존의 num 리스트는 정렬되지 않은 것을 확인할 수 있다.

 

내림차순으로 정렬하기 위해서는 인자에 reverse=True를 추가한다.

>>> num = [2, 5, 1, 4, 3]
>>> sorted_num = sorted(num, reverse=True)
>>> sorted_num
[5, 4, 3, 2, 1]

>>> num.sort(reverse=True)
[5, 4, 3, 2, 1]

리스트의 크기: len()

len()은 리스트의 크기, 즉 항목 수를 반환한다.

>>> num = [1, 2, 3]
>>> len(num)
3

복사: copy()

>>> a = [1, 2, 3]
>>> b = a
>>> a[0] = 5
>>> a
[5, 2, 3]

위처럼 있을 때 b에는 무슨 값이 들어가 있을까?

>>> b
[5, 2, 3]

a를 할당한 것이기에 b 또한 항목이 변경된다.

이를 방지하기 위해서 copy()를 사용한다.

copy()뿐 아니라, list()와 슬라이스: [ : ]를 사용해서도 복사를 할 수 있다.

>>> a = [1, 2, 3]
>>> b = a.copy()
>>> c = list(a)
>>> d = a[:]

b, c, d는 a의 복사본이다.

즉, 자신만의 값을 가진 새로운 객체이다. 

따라서, a의 항목이 변경되어도 b, c, d에는 아무 변화가 없게 된다.

튜플

리스트와 마찬가지로 튜플은 임의적인 항목의 시퀀스이다.

리스트와는 달리 불변한다.

즉, 튜플을 정의한 후에는 추가, 삭제, 수정을 할 수 없다는 것을 의미한다.

그러므로 튜플은 상수의 리스트라고 할 수 있다.

튜플 생성하기

튜플의 구문은 리스트와 조금 다르다.

먼저 ( )로 튜플을 생성해보자.

>>> empty_tuple = ()
>>> empty_tuple
()

하나 이상의 요소가 있는 튜플을 만들기 위해서는 각 요소 뒤에 콤마(,)를 붙인다. 

>>> animal = 'cat',
>>> animal
('cat',)

두 개 이상의 요소가 있을 경우, 마지막 요소에는 콤마를 붙이지 않는다.

>>> animal = 'cat', 'dog'
>>> animal
('cat', 'dog')

파이썬은 튜플을 출력할 때 ( )를 포함한다. 튜플을 정의할 때는 괄호( )가 필요 없다.

뒤에 콤마가 붙는다는 것은 튜플을 정의한다는 뜻이다.

하지만 값들을 괄호로 묶어서 튜플을 정의하는 것이 구분하기가 더 쉽다.

>>> animal = ('cat', 'dog')
>>> animal
('cat', 'dog')

튜플은 한 번에 여러 변수를 할당할 수 있다.

>>> animal = ('cat', 'dog', 'cow')
>>> a, b, c = animal
>>> a
'cat'

>>> b
'dog'

>>> c
'cow'

이를 튜플 언패킹이라고 한다.

 

한 문장에서 값을 교환하기 위해 임시 변수를 사용하지 않고 튜플을 사용할 수 있다.

>>> password = 'qwerty'
>>> icecream = 'watermelonbar'
>>> password, icecream = icecream, password
>>> password
'watermelonbar'

>>> icecream
'qwerty'

다른 데이터 타입을 튜플로 변경: tuple( )

tuple()은 다른 객체를 튜플로 만들어준다.

>>> num = [1, 2, 3, 4]
>>> tuple(num)
(1, 2, 3, 4)

튜플을 사용하는 이유

튜플은 리스트의 append(), insert() 등과 같은 함수가 없고, 함수의 수가 매우 적다.

튜플을 생성한 후에는 수정할 수 없기 때문이다.

그렇다면 리스트를 사용하면 되는 것을 왜 튜플을 사용할까?

• 튜플은 더 적은 공간을 사용한다.
• 실수로 튜플의 항목이 손상될 염려가 없다.
• 튜플을 딕셔너리 키로 사용할 수 있다.
• 네임드 튜플은 객체의 단순한 대안이 될 수 있다.
• 함수의 인자들은 튜플로 전달된다.