#2 리스트(List)

리스트는 다른 언어의 배열과 같은 역할을 하는 기본 자료구조이다.
하지만 파이썬의 리스트는 배열과는 달리 여러 강력한 기능들을 제공한다.

 

선언

my_list = []				# 빈 리스트 선언
my_list2 = [1, 2, 3, 4]			# 정수형 데이터를 넣은 리스트
my_list3 = [1, 'hello', [2,3,4]]	# 여러 타입의 데이터를 넣은 리스트

 위와같이 리스트는 기본적으로 대괄호안에 데이터를 콤마(,)로 구분하여 생성 가능하다. 특이하게도 하나의 리스트에
들어갈 데이터들간에 타입이 통일되어야 할 필요는 없으며 숫자형 같은 기본적인 자료는 물론 리스트나 튜플 등의
자료구조도 iterable하다면 무엇이든 리스트에 들어갈 수 있다. 

 

---

참조

my_list = [1, 3, 5, 7, 9]
print(my_list[3])			# 실행결과 : 7
my_list[2] = 4
print(my_list)				# 실행결과: [1, 3, 4, 7, 9]

 리스트의 참조는 C나 Java의 배열과 동일하게 <리스트>[인덱스] 의 형태로 이루어진다.

값의 변경은 <리스트>[변경할_데이터의_인덱스] = <변경할_값> 의 형태로 가능하다.

 

---

삽입

1. append

my_list = [1, 2, 3, 4, 5]
my_list.append(6)
print(my_list)			# 실행결과 : [1, 2, 3, 4, 5, 6]

 리스트의 끝에 데이터를 삽입할 경우 리스트에 내장된 append 메소드를 사용한다.  append 함수에 전달할 인자로는
숫자형 등의 기본 자료형이나 문자열, 리스트, 튜플 등의 iterable한 자료구조들을 사용할 수 있다. 

2. insert

my_list = [1, 2, 3, 4, 5]
my_list.insert(2, 6)
print(my_list)			# 실행결과 : [1, 2, 6, 3, 4, 5]

 리스트의 원하는 인덱스에 데이터를 삽입할 경우 리스트에 내장된 insert 메소드를 사용한다. 
위 코드에서 my_list.insert(2, 6)을 호출하여 인덱스 2에 데이터값 6을 삽입한 것을 확인할 수 있다.

 

---

확장

my_list = [1, 2, 3, 4, 5]
my_list.append([6, 7, 8, 9])
print(my_list)		# 실행결과 : [1, 2, 3, 4, 5, [6, 7, 8, 9]]

my_list2 = [1, 2, 3, 4, 5]
my_list2.extend([6, 7, 8, 9])
print(my_list2)		# 실행결과 : [1, 2, 3, 4, 5, 6, 7, 8, 9]

 append 메소드에 인자로 iterable한 인스턴스를 전달할 경우 그 인스턴스 자체가 하나의 데이터로서 삽입된다.

하지만 extend 메소드를 사용할 경우 전달된 인스턴스 내부의 데이터를 각각 리스트에 삽입한 결과를 얻을 수 있다.

 

---

삭제

1. del 명령어

my_list = ['alice', [2, 3, 4, 5], 7]
print(my_list)		# 실행결과 : ['alice', [2, 3, 4, 5], 7]
del my_list[1]
print(my_list)		# 실행결과 : ['alice', 7]

 리스트의 기본적인 데이터 삭제는 del 명령어를 사용할 수 있다.  del <리스트>[삭제할_데이터의_인덱스] 의 형태이다.

 

2. pop 메소드

my_list = [1, 2, 3, 4, 5]
print(my_list)		# 실행결과 : [1, 2, 3, 4, 5]
print(my_list.pop())	# 실행결과 : 5
print(my_list)		# 실행결과 : [1, 2, 3, 4]

 리스트에 내장된 pop 메소드를 사용할 경우 stack과 같이 가장 마지막의 데이터를 반환하고 리스트 내에서 삭제한다.

append 메소드와 pop 메소드만을 사용해서 값의 삽입/삭제를 실행할 경우 리스트를 stack과 동일하게 사용 가능하다.

 

3. remove 메소드

my_list = [1, 3, 2, 4, 5]
print(my_list)		# 실행결과 : [1, 3, 2, 4, 5, 3]
my_list.remove(3)
print(my_list)		# 실행결과 : [1, 2, 4, 5, 3]

 리스트에 내장된 remove 메소드는 인자로 넘겨준 데이터와 리스트의 데이터들을 대조하여 처음으로 발견된
동일한 데이터를 삭제한다.  

 

4. clear 메소드

my_list = [1, 3, 2, 4, 5, 3]
print(my_list)	# 실행결과 : [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)	# 실행결과 : []

 리스트에 내장된 clear 메소드는 리스트 내의 모든 데이터를 삭제한다.  결과는 del <리스트>[ : ]를 호출한 것과 같다.

 

---

슬라이싱

my_list = ['zero', 'one', 'two', 'three', 'four', 'five']
my_sub_list = my_list[2:5]
print(my_sub_list)			# 실행결과 : ['two', 'three', 'four']

 리스트에서 원하는 구간만을 가져올 경우 <리스트>[첫_인덱스 : 마지막_인덱스+1] 의 형태로 슬라이싱이 가능하다.

위 코드와 같이 구간을 [2 : 5] 로 지정할 경우 인덱스 2부터 4까지 총 세개의 데이터를 잘라서 반환한다.

 

---

정렬

1. sort()

my_list = [1, 4, 2, 5, 3]
print(my_list)		# 실행결과 : [1, 4, 2, 5, 3]
my_list.sort()
print(my_list)		# 실행결과 : [1, 2, 3, 4, 5]

 리스트에는 리스트에 들어있는 데이터들을 정렬해주는 sort() 메소드가 내장되어있다.  sort() 메소드를 호출할 경우

리스트에 들어있는 값들이 모두 서로 비교 가능하다면 기준에 맞게 오름차순으로 정렬해준다.

 

2. sorted()

my_list = [1, 4, 2, 5, 3]
print(my_list)				# 실행결과 : [1, 4, 2, 5, 3]
my_list_sorted = sorted(my_list)
print(my_list)				# 실행결과 : [1, 4, 2, 5, 3]
print(my_list_sorted)			# 실행결과 : [1, 2, 3, 4, 5]

 리스트를 정렬하는 방법으로 sorted() 라는 메소드도 존재한다. 이 메소드는 인자로 정렬하려는 리스트를 전달하여
호출하면 원본 리스트는 건드리지 않고 정렬한 결과만을 리스트의 형태로 반환하는 메소드이다. 
위 코드를 실행해보면 원본인 my_list는 그대로지만 sorted() 메소드의 반환값을 저장한 my_list_sorted는 정렬된 상태로
출력되는 것을 확인할 수 있다.

 

3. 추가인자 - reverse

# 추가인자 reverse
my_list = [1, 4, 2, 5, 3]
print(my_list)		# 실행결과 : [1, 4, 2, 5, 3]
my_list.sort(reverse=True)		
print(my_list)		# 실행결과 : [5, 4, 3, 2, 1]

 sort(), sorted() 메소드에 추가인자로 reverse 값을 전달할 수 있다.  위 코드처럼 reverse 값으로 True를 전달할 경우

정렬조건을 반대로 하여 내림차순 정렬이 되는 것을 확인할 수 있다.

 

4. 추가인자 - key

# 추가인자 key
my_list = [[1, 3], [5, 2], [5, 1], [6, 4], [2, 7]]
my_list_sorted1 = sorted(my_list, key = lambda x : x[0])
my_list.sort(key = lambda x : (-x[0], x[1]))
print(my_list)		# 실행결과 : [[6, 4], [5, 1], [5, 2], [2, 7], [1, 3]]
print(my_list_sorted1)	# 실행결과 : [[1, 3], [2, 7], [5, 2], [5, 1], [6, 4]]

 sort(), sorted() 메소드에 추가인자로 key 값을 전달할 수도 있다.  key는 정렬의 기준을 제시하는 함수이다.
위 코드는 람다함수를 key로 전달하여 my_list_sorted1 에는 리스트의 첫 인자를 기준으로 오름차순 정렬한 결과를,

my_list에는 리스트의 첫 인자를 기준으로는 내림차순, 첫 인자가 같다면 둘째 인자를 기준으로 오름차순 정렬한 결과를

저장한 것이다.

 

---

카운팅

my_list = [1, 3, 2, 4, 5, 3, 3]
how_many_three = my_list.count(3)
print(how_many_three)	# 실행결과 : 3

 리스트에 내장된 count 메소드는 인자로 전달된 데이터와 같은 데이터가 리스트 내부에 몇개 있는지 반환한다.

위 코드에선 my_list에 3이 3개 존재하기 때문에 3이 반환되는 것을 볼 수 있다.

 

---

복사 ( 대입, list.copy(), copy.deepcopy() )

import copy
my_list = [1, 2, 3, 4, [5, 6, 7, 8]]

my_list_copy1 = my_list			# 단순 대입
my_list_copy2 = my_list.copy()		# 얕은 복사
my_list_copy3 = copy.deepcopy(my_list)	# 깊은 복사

my_list[0] = 9
my_list[4][0] = 7

print(my_list_copy1)	# 실행결과 : [9, 2, 3, 4, [7, 6, 7, 8]]
print(my_list_copy2)	# 실행결과 : [1, 2, 3, 4, [7, 6, 7, 8]]
print(my_list_copy3)	# 실행결과 : [1, 2, 3, 4, [5, 6, 7, 8]]

 

단순대입으로 복사한 my_list_copy1 의 경우 원본과 같은 인스턴스를 가리키기 때문에 my_list의 변경이 모두 반영된다.

 

얕은복사본을 저장한 my_list_copy2 의 경우 리스트의 내장메소드인 copy를 사용하여 my_list와는 별도의 인스턴스지만
마지막 데이터인 리스트 [5, 6, 7, 8]의 경우 같은 인스턴스를 가리키기 때문에 my_list의 두 번째 변경이 반영된다.

 

깊은복사본을 저장한 my_list_copy3의 경우 copy 모듈의 deepcopy 메소드를 사용하여 리스트 데이터도 값만 같은
별도의 인스턴스를 가리키기 때문에 my_list에 가해진 변경이 일체 영향을 미치지않는 것을 볼 수 있다.

copy 모듈에 대해서는 추후 모듈에 대해 공부할 때 추가적으로 정리하도록 한다.