시퀀스, 집합형 자료구조

분류	타입	특징	예시
시퀀스(sequence)	리스트(list)	순서가 있고, 가변(mutable)	[1, 2, 3]
시퀀스(sequence)	튜플(tuple)	순서가 있고, 불변(immutable)	(1, 2, 3)
세트(set)	세트(set)	순서가 없고, 중복을 허용하지 않음	{1, 2, 3}
맵(map)	딕셔너리(dictionary)	순서가 없고, key/value 쌍으로 이루어짐	{‘a’: 1, ‘b’: 2, ‘c’: 3}

리스트(list)

리스트는 데이터의 요소를 순차적으로 파악하는데 용이한 자료형 입니다.
리스트는 다양한 메서드(method) 혹은 함수를 지원하며 메서드를 활용하여 요소를 추가, 삭제 및 변경할 수 있습니다.

메서드(method): 객체(object)가 포함하는 함수 혹은 기능입니다. 함수에 대한 내용은 추후에 다룹니다.

생성

[] 형태로 표현합니다.

빈 리스트를 생성합니다.

mylist = []
mylist

[]

mylist = list()
mylist

[]

리스트를 생성하면서 값을 포함합니다.

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

[1, 3, 2, 4, 5]

list 규칙

list는 다양한 type의 데이터를 집합으로 가집니다.
list안에 list도 허용합니다.
list는 순서(order)의 개념이 존재합니다.

a = []

a = [1, 2, 3]
a

[1, 2, 3]

a = [1, 'hello', 3, 3.14, True]
a

[1, 'hello', 3, 3.14, True]

리스트 안에 리스트로 포함할 수 있습니다.

a = [1, 'hello', 3, 3.14, [6, 7, '8']]
a

[1, 'hello', 3, 3.14, [6, 7, '8']]

append() : 값 추가

빈 리스트를 생성합니다.

mylist = []
mylist

[]

append() 는 값을 맨 뒤에 추가 합니다.

mylist.append(1)
mylist

[1]

중복된 값을 추가할 수 있으며, 순서가 유지됩니다.

mylist.append(7)
mylist.append(7)
mylist.append(7)
mylist.append(3)
mylist.append(5)
mylist.append(2)
mylist

[1, 7, 7, 7, 3, 5, 2]

sort() : 정렬

요소를 순서대로 정렬합니다 (오름차순)
sort()는 내부적으로 정렬 합니다.

mylist = [1, 6, 3, 2, 7, 5, 4]
mylist.sort()

mylist

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

역정렬(reverse order)도 가능합니다. (reverse=True를 지정합니다.)

mylist = [1, 6, 3, 2, 7, 5, 4]
mylist.sort(reverse=True)

mylist

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

sorted() : 정렬

요소를 순서대로 정렬합니다.
내부적으로 정렬하지 않고 정렬된 복사본을 반환합니다.
즉 원본 데이터는 정렬되지 않습니다.

mylist = [1, 6, 3, 2, 7, 5, 4]
sorted(mylist)

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

mylist

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

마찬가지로, reverse=True를 지정하여 역정렬할 수 있습니다.

mylist = [1, 6, 3, 2, 7, 5, 4]
sorted(mylist, reverse=True)

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

reverse() : 역정렬

mylist.reverse()

mylist

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

len() : 전체 항목의 개수 세기

mylist = [1, 6, 3, 2, 7, 5, 4]
len(mylist)

insert() : 값 추가

지정한 index에 값 추가

mylist.insert(1, 100)

mylist

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

remove() : 값 제거

리스트에서 첫 번째 나오는 해당 값 삭제

mylist.remove(7)

mylist

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

pop() : 요소 꺼내기

x번째 요소를 돌려주고 해당 요소는 삭제

mylist.pop(1)

del : 요소 삭제

mylist = [100, 200, 300, 400, 500]

del mylist[1]
print(mylist)
del mylist[3]
print(mylist)

[100, 300, 400, 500]
[100, 300, 400]

count() : 갯수 세기

a = [1, 1, 1, 1, 1, 2, 2, 3]

a.count(1)

a.count(2)

a.count(5)

extend() : 리스트 확장

a = [1, 2, 3]

a.extend([4, 5])

[1, 2, 3, 4, 5]

+ 연산자는 extend()와 동일한 기능을 수행합니다.

a = [1, 2, 3]
a + [4, 5]

[1, 2, 3, 4, 5]

인덱싱(indexing): 색인

mylist = [1, 2, 3, 4]

인덱스는 0번 부터 시작 합니다.

mylist[0]

mylist[3]

mylist[4]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-46-88b11041aa4f> in <module>
----> 1 mylist[4]

IndexError: list index out of range

역순 인덱싱

파이썬은 음수 인덱싱을 지원합니다.

mylist[-1]

mylist[-3]

mylist[-5]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-49-7f152f66d2d3> in <module>
----> 1 mylist[-5]

IndexError: list index out of range

인덱스로 접근하여 값 바꾸기

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

[1, 2, 3, 4, 5]

mylist[0]

mylist[0] = 100

mylist

[100, 2, 3, 4, 5]

mylist[-1] = 300

mylist

[100, 2, 3, 4, 300]

중첩된 리스트 인덱싱

중첩된 리스트에 대한 리스트는 중첩 인덱싱으로 접근합니다. 값을 변경하는 것도 가능합니다.

mylist = [['가', '나', '다'], [4, 5, 6], 7, 8, 9]

mylist

[['가', '나', '다'], [4, 5, 6], 7, 8, 9]

1 번째 리스트 요소를 가져옵니다.

mylist[1]

[4, 5, 6]

1번째 리스트의 요소 중 1번째 요소를 가져오기 위해서는 중첩 인덱싱으로 접근합니다.

mylist[1][1]

mylist[1][1] = 99

mylist

[['가', '나', '다'], [4, 99, 6], 7, 8, 9]

슬라이싱(Slicing): 범위 추출

슬라이싱의 활용: [start:stop:step] 을 명시하여 부분을 추출할 수 있습니다.

mylist = [100, 200, 300, 400, 500]

[:]을 활용하여 전체를 추출할 수 있습니다.

mylist[:]

[100, 200, 300, 400, 500]

[start:]는 시작 index 부터 끝까지 추출합니다.

mylist[2:]

[300, 400, 500]

mylist[-3:]

[300, 400, 500]

[:end]는 처음부터 end 전까지 추출합니다.

mylist[:3]

[100, 200, 300]

[start:end]는 start부터 end 전까지 추출합니다.

mylist[1:3]

[200, 300]

mylist[-3: -1]

[300, 400]

indexing 에 step 활용하기

list[start:stop:step]

step은 몇 칸씩 건너 뛰는지 지정합니다.

mylist = [100, 200, 300, 400, 500]

2칸씩 건너뛰기

mylist[::2]

[100, 300, 500]

역순 출력

mylist[::-1]

[500, 400, 300, 200, 100]

역순 그리고 2칸씩 건너뛰기

mylist[::-2]

[500, 300, 100]

list 덧셈: list 확장

a = [1, 2, 3, 4]
b = [5, 6, 7, 8]

a + b

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

a = ['a', 'b', 'c']
b = ['d', 'e', 'f']

a + b

['a', 'b', 'c', 'd', 'e', 'f']

list 곱셈: list 반복

a = ['a', 'b', 'c']
b = [1, 2, 3, 4]

a * 2

['a', 'b', 'c', 'a', 'b', 'c']

b * 3

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

튜플(tuple)

리스트(list)는 가변(mutable)하는 객체(object)이지만, 튜플(tuple)은 불변(immutable)한 객체입니다.
가변 객체는 요소에 대한 수정, 삭제, 변경 등이 가능하지만, 불편 객체는 요소에 대한 수정, 삭제, 변경이 불가합니다.

생성

tuple(), () 로 생성합니다.
혹은 , 로 생성할 수 있습니다.

()로 튜플을 생성할 수 있습니다.

mytuple = (1, 2, 3)
mytuple

(1, 2, 3)

tuple() 로 생성하는 경우

mytuple = tuple([1, 2, 3])
mytuple

(1, 2, 3)

, 로 생성할 수 있습니다.

mytuple = 1, 2, 3
mytuple

(1, 2, 3)

단일 요소를 생성할 때는 반드시 ,를 붙여 줍니다. - (1,)과 (1)은 다른 자료구조임을 꼭 알고 있어야 합니다.

mytuple = 1,
print(type(mytuple))
mytuple

<class 'tuple'>

(1,)

mytuple = (1,)
print(type(mytuple))
mytuple

<class 'tuple'>

(1,)

mytuple = (1)
print(type(mytuple))
mytuple

<class 'int'>

튜플 언패킹(unpacking) - 튜플로 한 번에 여러 변수에 값을 한 번에 할당할 수 있습니다.

a, b, c = 1, 2, 3

print(a)
print(b)
print(c)

1
2
3

튜플 자료형은 요소의 추가, 삭제, 변경등을 허용하지 않습니다.

mytuple = (1, 2, 3)
mytuple

(1, 2, 3)

요소를 조회하는 것은 가능합니다.

mytuple[1]

요소를 변경하려는 경우

mytuple[1] = 100

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-106-302beb1444a7> in <module>
----> 1 mytuple[1] = 100

TypeError: 'tuple' object does not support item assignment

요소를 삭제하려는 경우

del mytuple[1]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-107-011fbf932d04> in <module>
----> 1 del mytuple[1]

TypeError: 'tuple' object doesn't support item deletion

튜플 덧셈: 튜플의 확장

a = (1, 2)
b = (3, 4)

a + b

(1, 2, 3, 4)

튜플 곱셈: 튜플의 반복

a * 3

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

길이 파악하기

mytuple

(1, 2, 3)

len(mytuple)

list를 tuple로 변환

a = [1, 2, 3, 4]

[1, 2, 3, 4]

type(a)

list

b = tuple(a)

(1, 2, 3, 4)

type(b)

tuple

tuple을 list로 변환

a = (1, 2, 3, 4)

(1, 2, 3, 4)

type(a)

tuple

b = list(a)

[1, 2, 3, 4]

type(b)

list

리스트로 type을 변경하였기 때문에 요소의 추가 및 삭제가 가능합니다.

b.append(5)
b

[1, 2, 3, 4, 5]

b.remove(2)
b

[1, 3, 4, 5]

요소를 추가 및 삭제한 후 다시 tuple로 변경할 수 있습니다.

c = tuple(b)

(1, 3, 4, 5)

type(c)

tuple