파이썬(3) - 컨테이너(1) 리스트

 

컨테이너(Container)

파이썬에는 네 가지 기본 컨테이너 타입이 있다. 말 그대로 무언가를 담는 즉 여러 데이터를 담을 수 있는 데이터 타입을 뜻한다. 기본 컨테이너로 List, Dictionary, Tuple, Set이 있다. 서로 다른 타입의 데이터도 상관없이 하나의 컨테이너에 담을 수 있다. 여기서 자주 쓰이지 않는 Set은 생략하겠다.

 

리스트(List)

리스트는 말 그대로 여러개의 데이터를 목록(list)처럼 담아둘 수 있는 자료형이다. 파이썬 자체가 동적 타입이기 때문에 상관없이 아무 자료나 담을 수 있다. 리스트 안에 리스트를 담을 수 있고 뒤에 배울 Dictionay나 클래스 객체 등 어떠한 데이터든 담을 수 있다.

# 비어있는 리스트를 만드는 방법
empty_list1 = []
empty_list2 = list()
# 네 가지 기본 자료형으로 만든 리스틎
basic_list = ["Hello", 1234, 1.234, True]
# 리스트 안에 리스트를 담은 것
depth2_list = ["Hello", 1234, [1.234, True]]
depth3_list = [["Hello"], [1234, [1.234, True]]]

 

• 리스트 인덱싱과 슬라이싱

리스트를 다루는 방법은 앞서 문자열을 다루는 방법과 비슷하다. 특정 원소를 출력하는 인덱싱(Indexing)은 [](braket operator)를 쓴다. 문자열처럼 뒤에서부터 음수로 인덱싱도 가능하다. 여러겹으로 겹쳐있다면 원하는 요소가 나올때까지 단계별로 인덱스를 붙이면 된다. 범위가 넘어가면 에러가 발생할 수 있다.

print("basic indexing:", basic_list[2])
print("negative indexing:", basic_list[-2])
print("first indexing:", depth2_list[2])
print("second indexing:", depth2_list[2][0])
print("first indexing:", depth3_list[1])
print("second indexing:", depth3_list[1][1])
print("third indexing:", depth3_list[1][1][0])

 

출력 :

basic indexing: 1.234

negative indexing: 1.234

first indexing: [1.234, True]

second indexing: 1.234

first indexing: [1234, [1.234, True]]

second indexing: [1.234, True]

third indexing: 1.234

 

인덱싱이 리스트의 원소를 출력한다면 슬라이싱(slicing)은 리스트에서 일부 원소들을 묶어 새로운 리스트로 출력한다. 마찬가지로 음수를 이용해 뒤에서부터 범위를 지정할 수 있다. 슬라이싱의 경우 범위가 인덱스 범위를 넘더라도 에러가 발생하지 않고 빈 리스트를 출력한다.

print("[start:end]", basic_list[1:3])
print("[start:]", basic_list[2:])
print("[:end]", basic_list[:2])
print("[start:negative_end]", basic_list[1:-1])
print("[:negative_end]", basic_list[:-2])
print("[negative_start:negative_end]", basic_list[-4:-2])
print("[nested list1]", depth2_list[1:3])
print("[nested list2]", depth3_list[0:2])
print("[partially overlap]", basic_list[2:10])
print("[out of range]", basic_list[5:10])

 

출력 :

[start:end] [1234, 1.234]

[start:] [1.234, True]

[:end] ['Hello', 1234]

[start:negative_end] [1234, 1.234]

[:negative_end] ['Hello', 1234]

[negative_start:negative_end] ['Hello', 1234]

[nested list1] [1234, [1.234, True]]

[nested list2] [['Hello'], [1234, [1.234, True]]]

[partially overlap] [1.234, True]

[out of range] []

 

• 리스트 연산

리스트도 문자열처럼 +를 통해 두 리스트를 합칠 수 있고 *를 통해 리스트 원소들을 반복할 수 있다.

mammal = ["dog", "cat", "human"]
reptile = ["snake", "lizard", "frog"]
bird = ["eagle", "sparrow", "chicken"]
animal = mammal*2 + reptile + bird
print("animal:", animal)

 

출력 :

animal: ['dog', 'cat', 'human', 'dog', 'cat', 'human', 'snake', 'lizard', 'frog', 'eagle', 'sparrow', 'chicken']

 

• 리스트 내장 함수

리스트를 쓰다보면 정렬을 한다던지(sort()), 원소를 추가한다던지(append()), 중간에 삽입한다던지(insert()), 특정 원소의 인덱스 위치를 반환한다던지(index()) 등의 기능이 필요하다. 이 함수들을 사용할 때 대부분의 함수들이 in-place 함수라는 것을 주의해야 한다. 함수로 수정한 리스트 결과가 리턴으로 나오지 않고 함수를 실행한 변수 자체를 수정한다는 것이다. 하지만 대부분의 외부 패키지들은 데이터를 수정하는 함수들이 원본은 그대로 둔채 수정된 결과를 리턴하는 방식이므로 잘 구분해야 한다.

animal = ['Cat', 'Dog', 'Elephant', 'Tiger', 'Lion', 'Gorilla']

# sort(): 원소 알파벳순, 크기순 정렬, in-place 함수기 때문에 아무것도 리턴하지 않는다.
print("sort() is a in-place function:", animal.sort())
print("sort by name:", animal) # 위 함수에서 정렬 완료
print("Dog's index:", animal.index('Dog'))

# remove(): 입력한 원소를 삭제
animal.remove('Tiger')
# insert(): 원하는 위치에 원소 삽입
animal.insert(1, 'Monkey')
print("Tiger out and Monkey in:", animal)

# pop(): 입력이 없으면 마지막 원소를 삭제하고 pop(index)는 index의 원소를 삭제한다.
animal.pop(-1)
# append(): 원소를 마지막에 추가한다. 두 리스트의 원소들을 합칠 때는 +나 extend()를 쓴다.
animal.append('Fox')
print("Lion out and Fox in:", animal)

del animal[2]
animal += ['Lizard']
print("Dog out and Lizard in:", animal)
# reverse(): 순서를 거꾸로 뒤집는다.
animal.reverse()
print("reverse order", animal)

 

출력 :

sort() is a in-place function: None

sort by name: ['Cat', 'Dog', 'Elephant', 'Gorilla', 'Lion', 'Tiger']

Dog's index: 1

Tiger out and Monkey in: ['Cat', 'Monkey', 'Dog', 'Elephant', 'Gorilla', 'Lion']

Lion out and Fox in: ['Cat', 'Monkey', 'Dog', 'Elephant', 'Gorilla', 'Fox']

Dog out and Lizard in: ['Cat', 'Monkey', 'Elephant', 'Gorilla', 'Fox', 'Lizard']

reverse order ['Lizard', 'Fox', 'Gorilla', 'Elephant', 'Monkey', 'Cat']

 

• 리스트 관련 함수

len() : 파이썬 내장 함수로 여러 원소를 담고 있는 대부분의 객체들은 이 함수로 길이(갯수)를 잴 수 있다. 문자열의 길이, list, dict, tuple, set 등의 자료 구조의 원소 수를 읽을 수 있다.

string = "Hello"
print(f"len of {string}: {len(string)}")
# => len of Hello: 5
mylist = [1, 2, 3, 4]
print(f"len of {mylist}: {len(mylist)}")
# => len of [1, 2, 3, 4]: 4

 

 

del : 객체를 삭제하는 키워드로 자료 구조에서 특정 원소를 삭제할때 쓰인다 del()이 아님에 유의.

mylist = [1, 2, 3, 4, 5]
del mylist[2]
print("after deleting [2]:", mylist)
# => after deleting [2]: [1, 2, 4, 5]
del mylist[2:]
print("after deleting [2:]:", mylist)
# => after deleting [2:]: [1, 2]

 

 

원소 변경 : 인덱싱이나 슬라이싱으로 잡은 리스트 범위에 = operator로 원소들을 수정할 수 있다.

참고로 문자열은 =를 이용한 일부 문자 수정이 불가하다.

mylist = [1, 2, 3, 4, 5]
mylist[0] = "Life"
print("change element by indexing:", mylist)
# => change element by indexing: ['Life', 2, 3, 4, 5]
mylist[1:4] = ["is", "too", "short"]
print("change elements by slicing:", mylist)
# => change elements by slicing: ['Life', 'is', 'too', 'short', 5]

 

 

join() : 리스트의 내부 문자열 원소들을 하나의 문자열로 연결해준다. 연결할 때 각 문자열 사이에 " "사이에 들어 있는 문자열을 끼워준다.

print("join strings")
path = ["/home", "ian", "work", "ian-lecture"]
print("joined path:", "/".join(path))
# => joined path: /home/ian/work/ian-lecture
time = ["13", "20", "30"]
print("joined time:", ":".join(time))
# => joined time: 13:20:30

 

 

in : in은 함수가 아니라 operator다. 리스트에 특정 원소가 들어있는지 확인할 때 쓴다.

animal = ['Cat', 'Dog', 'Elephant', 'Tiger', 'Lion', 'Gorilla']
if "Cat" in animal:
    print("Cat은 동물에 있습니다.")
if "Lizard" not in animal:
    print("Lizard는 동물에 없습니다.")