[Python] 파이썬 리스트 타입 - list 객체

파이썬 list 타입

C나 JAVA 언어 등에는 배열이라는 자료구조가 있다면 파이썬에는 list 자료형이 있습니다. 파이썬에는 배열은 없으며 대신에 index를 부여할 수 있는 시퀀스 타입을 제공합니다. 파이썬에서 시퀀스 타입의 특징은 저장하고 있는 데이터가 순서를 가진다는 점이며, 그 중 하나가 list 타입 입니다. list는 우리가 흔히 알고 있는 타 언어의 배열과 거의 똑같다고 할 수 있습니다.

파이썬에서 가장 많이 다루어지는 자료구조이며, 실무에서도 데이터를 다룰때 자주 다루게 되기때문에 기능도 많습니다. 여러번 따라해보면서 숙달하시기를 권해드립니다.

list 객체 생성

list 타입은 다음과 같이 '[ ]' (대괄호)로 표기하며, 각 요소마다 ,(콤마) 로 구분하여 생성할 수 있습니다.

>>> my_list = [1, 3, 5, 7, 9]
>>> my_list
[1, 3, 5, 7, 9]
                                                                                            

두번째 방법으로는 다음과 같이 list() 형태로 비어있는 list 객체를 생성하는 것입니다. 단 이렇게 생성하는 경우 아무런 요소가 없는 list가 생성됩니다. 또한 비어있는 리스트에 요소를 추가할 때에는 append() 메서드를 사용합니다.

>>> my_list = list()
>>> my_list
[]
>>> my_list.append('index 0')
>>> my_list.append('index 1')
>>> my_list
['index 0', 'index 1']
                                                                                            

이후에 나올 + 연산자로도 list에 새로운 내용을 합치는 연산을 할 수 있는데, append() 메서드는 현재 list 객체에 내용을 추가하는 것이며, + 연산자는 list끼리 합친 새로운 list가 생성되는 차이점이 있습니다.

list에 담을 수 있는 타입에는 제한이 없으며, 정수, 문자열 등의 타입뿐만 아니라 모든 타입의 객체 및 다른 list 객체까지도 담을 수 있습니다. my_list에 정수, 실수, 문자열, 또 다른 list, 딕셔너리 객체까지 담았습니다.

>>> my_list = [1, 'hello', 3.7, [7, 8, 9], {"a": 2, "b": 3}]
>>> my_list
[1, 'hello', 3.7, [7, 8, 9], {'a': 2, 'b': 3}]
                                                                                            

문자열을 list로 형변환

list()를 사용하여 문자열을 list로 형변환(type casting) 할 수 있습니다.

>>> my_str = 'python'
>>> my_list = list(my_str)
>>> my_list
['p', 'y', 't', 'h', 'o', 'n']
                                                                                            

list 요소에 접근하기

이렇게 생성된 list 객체의 요소들은 index를 가지게 되는데 index는 0부터 시작하며, index를 통해서 각 요소에 접근할 수 있습니다. list객체[index] 형식으로 요소에 접근할 수 있습니다.

>>> my_list = [1, 3, 5, 7, 9]
>>> my_list[0]
1
>>> my_list[1]
3
>>> my_list[3]
7
                                                                                            

만약 존재하지 않는 요소에 접근하거나 값을 할당하려 하면 IndexError가 발생합니다.

>>> my_list = [1, 3, 5, 7, 9]
>>> my_list[5] = 30
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    my_list[5] = 30
IndexError: list assignment index out of range
                                                                                            

다차원 list에 접근하기

list는 데이터가 순서대로 이어진 1차원 자료구조입니다. 여기서 각 요소에 또 다른 list 객체를 할당하면 개념적으로 다차원 list가 됩니다.

>>> my_list = [1, 3, 5, [11, 13, 15]]
>>> my_list
[1, 3, 5, [11, 13, 15]]
>>> my_list[3]
[11, 13, 15]
                                                                                            

파이썬에서는 모든 것들이 객체이기 때문에 변수에 무엇을 집어넣든지 실제 그 객체가 들어가는 것이 아닌 객체를 가리키는 객체의 참조 주소값이 변수에 할당됩니다. 그런 의미로 list의 요소들도 사실은 실제 값이 아닌 요소에 할당된 객체의 주소를 가리키고 있습니다.

따라서 위의 개념처럼 다차원 list를 만들게 되면 또 다른 list가 생성되고 그 list의 주소값을 요소로 가지고 있는 것입니다. 위의 그림은 쉬운 이해를 위해 쉽게 표현한 것입니다.(실제로는 나머지 요소들도 실제 정수 값이 아닌 정수 객체를 가리키는 주소값이 들어가 있습니다.)

다차원 list의 요소에 접근하고 싶다면 다음과 같이 사용합니다.

>>> my_list[3][0]
11
                                                                                            

list 요소에 index 범위로 접근하기

파이썬에서 list같은 시퀀스 타입 자료구조의 장점은 다양한 방법으로 요소들을 접근할 수 있다는 점 입니다. 따라서 데이터를 다루는데, 매우 유연하게 코드를 작성할 수 있으며, 머릿속에 생각한대로 직관적으로 데이터를 다룰 수 있습니다.

파이썬에서는 다음과 같은 형식으로 요소에 접근할 수 있습니다. 표만 봐서는 잘 와닿지 않으므로 대충 훑어보고 그 아래 예제를 참고하시기 바랍니다.

형식	설명
list[시작:끝:step]	list의 시작 요소부터 끝 이전까지 step 마다 존재하는 요소
list[시작:]	list의 시작부터 이후의 모든 요소
list[:끝]	list의 끝 이전까지의 모든 요소
list[::step]	list의 시작부터 끝까지 step 마다 존재하는 요소
list[시작:끝]	list의 시작부터 끝 이전까지의 요소
list[시작::step]	list의 시작부터 시작 이후의 step 마다의 요소
list[:끝:step]	list의 끝 이전까지의 step 마다의 요소

다음 예제를 보면 더욱 쉽게 이해할 수 있습니다.

>>> my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
 
 
>>> my_list[9:]  # [9]부터 이후의 모든 요소
[10, 11, 12]
 
 
>>> my_list[:4]   # [4] 이전의 모든 요소
[1, 2, 3, 4]
 
 
>>> my_list[::3]  # 요소를 3씩 건너 뛰며 접근
[1, 4, 7, 10]
 
 
>>> my_list[1:5]  # [1] 부터 [5] 이전까지
[2, 3, 4, 5]
 
 
>>> my_list[3::2]  # [3] 부터 2씩 건너 뛰며 접근
[4, 6, 8, 10, 12]
                                                                                            

list 요소에 -index (음수 인덱스) 로 접근하기

파이썬에서 시퀀스 타입(list, 문자열 등)에서 index로 음수값을 사용하면 '요소의 뒤에서' 라는 의미로 사용됩니다.

>>> my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>> my_list[-1]
12
>>> my_list[-2]
11
                                                                                            

다음은 list의 [3] 부터 뒤에서 두번째 이전까지의 요소에 접근합니다.

>>> my_list[3:-2]
[4, 5, 6, 7, 8, 9, 10]
                                                                                            

list 반대로 맨 뒤에서부터 접근하기

만약 list를 거꾸로 뒤집어서 맨 뒤에서부터 처음까지의 요소를 접근하려면 어떻게 해야할까요?

잘 될것 같지만 아무런 값도 나오지 않았습니다. 이유는 step이 1씩 증가한다는 사실을 간과했기 때문입니다. 다음 소스는 내부적으로 my_list[-1:0:1] 과 같은 의미를 지닙니다.

>>> my_list[-1:0]
[]
                                                                                            

이번에는 조금 수정하여 step을 -1로 바꾸어 index를 1씩 감소시켜 접근 하도록 해보았습니다. 그러나 두번째 범위조건은 이하가 아닌 미만이기 때문에 [-12] 요소인 1이 출력되지 않았습니다.

>>> my_list[-1:0:-1]
[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2]
                                                                                            

이럴때는 다음과 같이 최종적으로 두번째 범위조건인 끝 조건을 빼주면 됩니다.

>>> my_list[-1::-1]
[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
                                                                                            

이후에 나올 list의 메서드인 reverse() 메서드를 사용하면 list의 요소가 거꾸로 뒤집히는데, 둘의 차이는 reverse() 메서드의 경우에는 my_list의 내부 저장된 요소들이 거꾸로 뒤집힌다는 점이며, 음수 index를 사용한 경우에는 실제로 요소가 뒤집히는것이 아닌 접근 결과만 뒤집혀 반환된다는 점입니다.

list객체 + 연산

list끼리 + 연산을 하면 예상처럼 연산 대상의 두 list가 하나의 list로 더해집니다. 여기서는 my_list 자신을 + 연산했는데 두 개로 합쳐진 새로운 list가 생성되었습니다.

>>> my_list = [1, 3, 5, 7, 9]
>>> my_list+my_list
[1, 3, 5, 7, 9, 1, 3, 5, 7, 9]
                                                                                            

그러나 my_list에 추가된 것은 아닙니다. 만약 my_list에 다른 list를 합치려면 + 연산 이후 생성된 list를 다시 할당해 주어야 합니다.

>>> my_list = my_list + my_list
>>> my_list
[1, 3, 5, 7, 9, 1, 3, 5, 7, 9]
                                                                                            

list객체 * 연산

list끼리 * 연산을 하게 되면 +와 같은 맥락으로 곱한 수만큼 list 객체가 반복해 증가합니다.

>>> my_list = [1, 3, 5, 7, 9]
>>> my_list * 3
[1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1, 3, 5, 7, 9]
                                                                                            

list 요소 값 하나 수정하기

원하는 요소에 값을 할당하면 해당 요소의 값이 바뀝니다.

>>> my_list = [1, 3, 5, 7, 9]
>>> my_list[3] = 10
>>> my_list
[1, 3, 5, 10, 9]
                                                                                            

list 요소 인덱스 범위 연산으로 수정하기

앞에서 설명했었던 [시작:끝] 범위연산을 같이 사용하면 한꺼번에 값을 수정할 수 있습니다. 주의할점으로는 my_list[3] = [1,2] 와 같은 식으로 수정하려 하면 범위 수정이 아닌 [3] 요소에 [1,2] list가 들어가서 [1, 3, 5, [1, 2], 9] 과 같이 2차원 list가 되어버린다는 점입니다.

>>> my_list = [1, 3, 5, 7, 9]
>>> my_list[0:3] = ['3', '4', '5', '6']
>>> my_list
['3', '4', '5', '6', 7, 9]
                                                                                            

[0:3]은 [0], [1], [2] 를 의미하므로 해당 범위를 수정하기 위해 날려버립니다. (실제로는 값을 덮어 씌우는것이 더 정확하지만 날려버린다고 생각하세요)

그러나 새로 대입할 list 객체는 기존에 수정할 범위보다 길이가 1만큼 더 깁니다.

my_list 객체의 길이를 1 늘리고 오른쪽으로 한칸씩 밀어준 후 비어있는 자리에 추가할 list 를 대입합니다.

범위 수정을 응용하면 다음과 같이 list의 요소들을 삭제할 수 있습니다.

>>> my_list = [1, 3, 5, 7, 9]
>>> my_list[0:] = []
>>> my_list
[]
                                                                                            

list 객체의 메서드

list의 기본적인 연산들 이외에 list 객체만의 다양한 메서드를 제공하고 있습니다.

요소 추가 (append)

원하는 요소를 list 맨 뒤에 추가합니다.

>>> my_list = [1, 3, 5]
>>> my_list.append(100)
>>> my_list
[1, 3, 5, 100]
>>> my_list.append([200, 300])
>>> my_list
[1, 3, 5, 100, [200, 300]]
                                                                                            

특정 위치에 추가 (insert)

list의 원하는 위치(index)에 원하는 값을 추가합니다. [1] index 위치에 777을 추가합니다.

>>> my_list = [1, 3, 5]
>>> my_list.insert(1, 777)
>>> my_list
[1, 777, 3, 5]
                                                                                            

list 확장 (extend)

list 객체에 새로운 list를 더하여 확장합니다. 이때 extend(x) 에서 x에는 iterable을 구현한 객체만 사용 가능한데, 시퀀스 타입의 자료형들은 모두 iterable을 구현했으므로 사용 가능합니다. append(x) 와의 차이점은 append()는 하나의 요소로서 추가되지만 extend()는 확장 개념으로 추가된다는 점 입니다. 똑같은 list를 추가해보면 바로 차이점을 알 수 있습니다.

>>> my_list = [1, 3, 5]
>>> my_list.extend([100, 200, 300])
>>> my_list
[1, 3, 5, 100, 200, 300]
                                                                                            

요소 제거 (remove)

지정한 값을 list 객체에서 지정한 값을 바탕으로 검사하여 가장 처음에 발견된 요소를 제거합니다.

>>> my_list = [1, 3, 1, 3]
>>> my_list.remove(1)
>>> my_list
[3, 1, 3]
>>> my_list.remove(3)
>>> my_list
[1, 3]
                                                                                            

del 키워드를 통해서도 제거할 수 있습니다. del 키워드역시 [시작:끝] 범위 연산을 사용할 수 있습니다.

>>> my_list = [1, 3, 1, 3]
>>> del my_list[1]
>>> my_list
[1, 1, 3]
 
                                                                                            

list 값 꺼내기 (pop)

list의 요소 중 끝의 요소를 꺼내어 반환합니다. 복사가 아닌 꺼내는 것이기 때문에 꺼낸 요소는 list 객체에서 사라집니다.

>>> my_list = [1, 3, 1, 3]
>>> my_list.pop()
3
>>> my_list
[1, 3, 1]
                                                                                            

pop(index) 로 사용하면 index 위치의 요소 값을 꺼냅니다.

>>> my_list = [1, 3, 1, 3]
>>> my_list.pop(1)
3
>>> my_list
[1, 1, 3]
                                                                                            

list 정렬 (sort)

list의 요소 값들을 오름차순으로 정렬합니다.

>>> my_list = [1, 3, 1, 3]
>>> my_list.sort()
>>> my_list
[1, 1, 3, 3]
                                                                                            

내림차순으로 정렬하는 경우는 reverse 값을 True로 합니다.

>>> my_list = [1, 3, 1, 3]
>>> my_list.sort(reverse=True)
>>> my_list
[3, 3, 1, 1]
                                                                                            

list 거꾸로 뒤집기 (reverse)

list의 요소를 거꾸로 뒤집습니다.

>>> my_list = [1, 2, 3, 4]
>>> my_list.reverse()
>>> my_list
[4, 3, 2, 1]
                                                                                            

list 특정 값의 위치(Index) 구하기 (index)

지정한 값이 list의 어느 index 위치에 있는지 반환합니다. 이때 값이 여러개 중복되는 경우 첫번째 찾은 위치의 index를 반환합니다. 1은 [0] 요소에 있습니다.

>>> my_list = [1, 2, 3, 4]
>>> my_list.index(1)
0
                                                                                            

만약 범위를 지정하고 싶은 경우 index(값, 시작, 끝) 형식으로 범위 지정이 가능합니다.

또는 index(값, 시작) 형식으로 시작범위만 지정할 수도 있습니다. 

>>> my_list = [1, 2, 3, 4, 1, 2, 3, 4]
>>> my_list.index(1, 4, 7)
4
>>> my_list.index(1, 4)
4
                                                                                            

값을 찾지 못하면 ValueError 에러가 발생합니다.

>>> my_list.index(6)
Traceback (most recent call last):
  File "<pyshell#88>", line 1, in <module>
    my_list.index(6)
ValueError: 6 is not in list
                                                                                            

list 특정 값 개수 카운트 하기 (count)

list에서 특정 값이 몇 개 존재 하는지 개수를 세어 반환 합니다.

>>> my_list = [1, 2, 3, 4, 1, 2, 3, 4]
>>> my_list.count(1)
2
                                                                                            

list의 길이(크기) 구하기

list의 길이를 구하는 방법은 두가지로 list 객체의 __len__() 메서드를 사용하거나 len() 함수에 list 객체를 넣어 구하는 방법 입니다.

>>> my_list = [1, 3, 5, 7]
>>> my_list.__len__()
4
>>> len(my_list)
4