Lesson 02: 파이썬의 자료형 II (list, tuple)

list

선언

- 리스트의 선언

a=[11,22]
a

[11, 22]

type(a)

list

- 비어있는 리스트의 선언

a=[] # 방법1
a

[]

a=list() # 방법2
a

[]

연산

- 더하기연산

a=[11,12]
b=[12,13]

a

[11, 12]

b

[12, 13]

a+b

[11, 12, 12, 13]

• 우리의 예상과 다른 결과가 나옴 \(\to\) 파이썬은 R처럼 자체적으로 좋은 계산기능을 내장하고 있지 않음.

- 브로드캐스팅과 같이 R에서는 당연히 가능했던 기능을 사용할 수 없음.

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

TypeError: can only concatenate list (not "int") to list

- 뺄셈은 정의되지 않음

a=[1,2]
b=[1,2]
a-b

TypeError: unsupported operand type(s) for -: 'list' and 'list'

- 곱하기는 정의가능

a=[1,2]

2*a # a+a 

[1, 2, 1, 2]

- 나눗셈은 정의되지 않음

a=[1,2,1,2]
a/2

TypeError: unsupported operand type(s) for /: 'list' and 'int'

- 더하기와 곱하기는 원소의 추가와 반복추가를 의미하지만 그렇다고 해서 뺄셈과 나눗셈이 원소의 삭제를 의미하는것은 아님

a=[1,2,3]
a-[3] # 이런건 없다

TypeError: unsupported operand type(s) for -: 'list' and 'list'

a=[1,2,1,2,1,2]
a/3 # 이런건 없다

TypeError: unsupported operand type(s) for /: 'list' and 'int'

- 더하기와 곱하기가 원소의 추가와 반복추가를 의미하여 편리할때도 있긴하지만, 우리는 산술적인 +, * 를 원하는 경우도 있다. 이럴 경우는 어떻게 할 수 있을까?

(예제)

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

a+b = [4,6] 이 되도록 하려면?

(풀이1)

a[0]+b[0] # a의 첫번째 원소를 추출, b의 첫번째 원소를 추출, 둘을 더함 

4

a[1]+b[1] # a의 두번째 원소를 추출, b의 두번째 원소를 추출, 둘을 더함 

6

[a[0]+b[0],a[1]+b[1]]

[4, 6]

풀이가 가능한 이유? a,b는 리스트이지만 a[0], a[1], b[0], b[1] 은 각각 인트형임. 인트형은 + 연산이 가능했음.

(풀이2)

• numpy 를 이용

numpy 패키지 (파이썬의 여러 수치연산들을 담당하는 라이브러리)

• 이러한 벡터연산은 누구나 필요로 하는 연산임.
• 내가 아니더라도 누군가가 프로그램화 해놓았을 것임.
• 그 누군가가 자신이 만든 코드를 잘 정리하여 무료로 배포했을 수도 있음. (패키지를 배포한다고 표현)
• 그 패키지를 우리는 가져와서 설치한뒤 사용하기만 하면된다.

패키지를 설치하는 방법 (코랩은 이미 설치되어 있음)

• !pip install numpy # 최신버전을 설치함
• !conda install -c conda-forge numpy -y # 안전한 버전을 설치함

설치된 패키지를 사용하는 방법

• import numpy 한뒤에 numpy.??로 기능을 사용
• import numpy as np 한뒤에 np.??로 기능을 사용

import numpy as np ## 설치한 numpy라는 패키지를 쓰겠음. 그런데 numpy말고 np라는 이름으로 쓰겠음

np.array(a)

array([1, 2])

a=[1,2]
b=[3,4]
np.array(a)+np.array(b)

array([4, 6])

인덱싱

- str형과 동일한 방식

a=[11,22,33,44,55] # 0 -4 -3 -2 -1

a[-2:] # 끝의 2개의 원소를 뽑음 

[44, 55]

리스트는 컨테이너형 객체이다.

- 리스트의 원소는 int, float 따위만 가능한 것이 아니다. (리스트는 컨테이너형 객체이므로)

lst = [1,3.14,True,'a',[1,2], 
       (1,2),{'name':'iu','age':27},{1,2,3}]

lst

[1, 3.14, True, 'a', [1, 2], (1, 2), {'name': 'iu', 'age': 27}, {1, 2, 3}]

각 원소의 타입을 알아보자.

type(lst[0])

int

type(lst[1])

float

type(lst[2])

bool

type(lst[3])

str

type(lst[4])

list

type(lst[5])

tuple

type(lst[6])

dict

type(lst[7])

set

- str은 컨테이너형이 아니다.

'abcd'[2]

'c'

• str의 모든 원소는 문자임

리스트는 가변형 객체이다.

리스트의 원소 수정

- 리스트의 원소를 수정할 수 있다. (리스트는 가변객체이므로)

a=[11,22,33]
a

[11, 22, 33]

a[0]

11

a[0]=111

a

[111, 22, 33]

- 원소수정은 당연한 기능같은데 이것이 불가능한 경우도 있다.

(가능한경우)

a=['g','u','e','b','i','n']
a

['g', 'u', 'e', 'b', 'i', 'n']

a[0]

'g'

a[0]='G'

a

['G', 'u', 'e', 'b', 'i', 'n']

(불가능한경우)

a='guebin'
a

'guebin'

type(a)

str

a[0]

'g'

a[0]='G'

TypeError: 'str' object does not support item assignment

리스트의 원소 삭제

(예제)

아래와 같이 문자로 된 리스트를 선언하자.

a=['g','u','e','b','i','n']
a

['g', 'u', 'e', 'b', 'i', 'n']

사실 더 쉽게 선언할 수 있음

a= 'guebin' # string으로 a를 선언
a= list(a) # list(a)를 통하여 str을 ㅣist로 변환 -> 그 결과를 a에 다시 저장
a

['g', 'u', 'e', 'b', 'i', 'n']

리스트의 원소 추가

(예제) 비어있는 리스트를 만들고 원소 0,1,2를 차례로 추가하여 보자.

(풀이1)

a=[]
a

[]

a= a + [0] 
a

[0]

a= a + [1]
a

[0, 1]

a= a + [2]
a

[0, 1, 2]

(풀이2)

a=[]
a

[]

a += [0] 
a

[0]

a += [1]
a

[0, 1]

a += [2]
a

[0, 1, 2]

• 암기법: 중복되는 변수를 지우고 연산자의 순서를 바꾼다.

(풀이3) 리스트 특화기능(=메소드)를 이용

a=[]
a

[]

a.append(0)
a

[0]

a.append(1)
a

[0, 1]

a.append(2)
a

[0, 1, 2]

- a+[4]와 a.append(4)의 차이점은?

(관찰1)

a=[1,2,3]
a+[4] ## 리스트 a와 리스트 [4]의 연산결과를 알려줘 

[1, 2, 3, 4]

a ## a는 그대로임. 변화없음 

[1, 2, 3]

(관찰2)

a=[1,2,3]
a.append(4)

a ## a자체가 변화함 

[1, 2, 3, 4]

비슷해보이지만 굉장히 미묘한 차이가 있음

a.append(4): a에 4를 append하라 \(\to\) a가 변함

a+[4]: a와 4를 연산하라

list 특수기능

(append)

a=[1,2,3,4]
a.append?

Signature: a.append(object, /)
Docstring: Append object to the end of the list.
Type:      builtin_function_or_method

a.append(5)
a

[1, 2, 3, 4, 5]

(clear)

a=[1,2,3,4]
a.clear?

Signature: a.clear()
Docstring: Remove all items from list.
Type:      builtin_function_or_method

a.clear()
a

[]

(copy)

a=[1,2,3,4]
a.copy?

Signature: a.copy()
Docstring: Return a shallow copy of the list.
Type:      builtin_function_or_method

b=a.copy()
b

[1, 2, 3, 4]

(count)

a=[1,1,2,3,3,4,4,4]
a.count?

Signature: a.count(value, /)
Docstring: Return number of occurrences of value.
Type:      builtin_function_or_method

a.count(1)

2

a.count(2)

1

a.count(3)

2

a.count(4)

3

(extend)

a=[1,2,3,4]
b=[-1,-2,-3,-4]

a.extend(b)
a

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

a=[1,2,3,4]
b=[-1,-2,-3,-4]

a.append(b)

a

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

(index)

a=[11,22,'a',True, 22,'a']
a.index?

Signature: a.index(value, start=0, stop=9223372036854775807, /)
Docstring:
Return first index of value.
Raises ValueError if the value is not present.
Type:      builtin_function_or_method

a.index(11)

0

a.index(22)

1

a.index('a')

2

a.index(True)

3

(insert)

a=[1,2,3]
a.insert?

Signature: a.insert(index, object, /)
Docstring: Insert object before index.
Type:      builtin_function_or_method

a.insert(1,88) 
a

[1, 88, 2, 3]

(pop)

a=['a',1,2,'d']
a.pop?

Signature: a.pop(index=-1, /)
Docstring:
Remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
Type:      builtin_function_or_method

a.pop() # index=-1 이므로 마지막원소가 나타남

'd'

a # a는 마지막 원소가 사라진 상태

['a', 1, 2]

a.pop(0) # index=0 이므로 첫번쨰 원소가 나타남

'a'

a # a에는 첫번째 원소가 사라진 상태

[1, 2]

(remove)

a=['a',2,3,'d']
a.remove?

Signature: a.remove(value, /)
Docstring:
Remove first occurrence of value.
Raises ValueError if the value is not present.
Type:      builtin_function_or_method

a.remove('d')

a

['a', 2, 3]

a.remove('a')

a

[2, 3]

(reverse)

a=[1,2,3,4]
a.reverse?

Signature: a.reverse()
Docstring: Reverse *IN PLACE*.
Type:      builtin_function_or_method

a.reverse()
a

[4, 3, 2, 1]

(sort)

a=[1,3,2,4]
a.sort?

Signature: a.sort(*, key=None, reverse=False)
Docstring:
Sort the list in ascending order and return None.
The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
order of two equal elements is maintained).
If a key function is given, apply it once to each list item and sort them,
ascending or descending, according to their function values.
The reverse flag can be set to sort in descending order.
Type:      builtin_function_or_method

a.sort()
a

[1, 2, 3, 4]

(다른예제들)

a=list('guebin')
a

['g', 'u', 'e', 'b', 'i', 'n']

a.sort()
a

['b', 'e', 'g', 'i', 'n', 'u']

a.sort(reverse=True)
a

['u', 'n', 'i', 'g', 'e', 'b']

중첩 리스트

A=[[1,2,3],[4,5,6],[7,8,9]]
A

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

- A는 아래와 같은 매트릭스로 이해할 수 있다

$ \[\begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix}\]

$

- A에서 (2,1)의 원소를 뽑고싶다 = 4를 뽑고싶다

A[1,0]

TypeError: list indices must be integers or slices, not tuple

• 실패

A[1][0]

4

• 성공

- 성공의 이유를 분석해보자.

A

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

A[1]

[4, 5, 6]

A[1][0]

4

- 매트릭스는 아니지만 매트릭스 같음! - 1차원 배열을 다차원 배열로 확장할 수 있는 기본 아이디어를 제공함

tuple

리스트 vs 튜플

- 컨테이너형타입이라는 점, 그리고 연산 및 인덱싱을 하는 방법은 리스트와 같음

• 차이점1: [] 대신에 ()를 사용한다.
• 차이점2: 불변형이다. (원소의 값을 바꿀 수 없음)
• 차이점3: 하나의 원소를 선언할 때는 (1,)와 같이 해야 한다.
• 차이점4: 의미가 명확할때는 튜플의 ()를 생략가능하다.

- 컨테이너형이라는 것이 무슨의미?

a=(4,6,'pencil', 3.2+4.6j, [3,4]) 

type(a[2])

str

type(a[3])

complex

- 불변형이라는 것은 무슨의미?

a[2] = 'Pencil'

TypeError: 'tuple' object does not support item assignment

참고로 a를 튜플이 아니라 리스트로 선언하면 값이 잘 바뀐다.

a=[4,6,'pencil', 3.2+4.6j, [3,4]]

a[2]

'pencil'

a[2]='Pencil'

a

[4, 6, 'Pencil', (3.2+4.6j), [3, 4]]

- 하나의 원소로 이루어진 튜플을 만들때는 쉼표를 붙여야 함.

[1]+[2,3,4]

[1, 2, 3, 4]

(1,)+(2,3,4)

(1, 2, 3, 4)

- 리스트와 중요한 차이점! 의미가 명확할때 튜플의 괄호는 생략가능하다. (이게 중요합니다)

a=1,2
a

(1, 2)

의미가 명확할때 생략해야함

1,2 + 3,4,5 

(1, 5, 4, 5)

(1,2) + (3,4,5) 

(1, 2, 3, 4, 5)

선언

- 소괄호를 이용

a=(1,2,3)
a

(1, 2, 3)

type(a)

tuple

- 생략가능하다는 점이 포인트

a=1,2,3
a

(1, 2, 3)

type(a)

tuple

- 원소가 하나인 튜플을 만들고 싶다면?

a=(1,)
a

(1,)

연산

- 리스트와 동일

(1,2)+(3,4,5)

(1, 2, 3, 4, 5)

(1,2)*2

(1, 2, 1, 2)

인덱싱

- 리스트와 동일

a=(1,2,3,-4,-5)
a

(1, 2, 3, -4, -5)

a[-1]

-5

a[-3:]

(3, -4, -5)