numpy

 

 

 

 

Numpy란¶

 

 

• "Numerical Python" or "Numeric Python"

 

 

Numpy의 특징과 장점¶

 

 

Python은 느리다. 왜? 그래서...

 

 

• 강력한 N차원 배열 객체. List보다 빠르다.(메모리구조)
• 정교한 브로드케스팅(Broadcast) 기능. 반복문 쓰지 않음
• 유용한 선형 대수학, 푸리에 변환 및 난수 기능
• C/C++ 및 포트란 코드 통합 도구

 

 

Numpy가 빠른 이유¶

 

 

• python 코드가 아니라, Numpy는 C코드로 작성
• 메모리 저장구조가 다름
• 반복문 사용하지 않고 배열 통해 바로 계산
• 벡터라이즈와 브로드캐스팅 사용

 

 

Numpy를 사용하려면?¶

 

In [1]:

import numpy as np

 

 

• 모듈(라이브러리)을 호출해 속성과 메서드 사용
• numpy.sum()을 간단히 별칭(alias)를 사용해 np.sum()으로 사용

 

 

배열(Array)이란¶

 

 

ndarray(n dimensional array)

 

In [21]:

Image("numpyarrays.PNG")

 

Out[21]:

 

 

• 각 차원을 축(axis)라고 함
• 축의 개수는 차원의 개수인데 rank라고도 함.ndim
• 배열의 차원을 shape라고 하고 tuple로 표시(3,), (2,3)
• shape 안의 숫자는 각 차원에 있는 원소의 개수
• 전체 원소의 개수는 size

 

 

배열(Array) vs 행렬(Matrix)¶

 

In [22]:

Image("arraymatrix.PNG")

 

Out[22]:

 

 

배열 만들기¶

 

 

array creation¶

 

In [57]:

a = np.array([0,1,2,3])

 

In [59]:

print(a)

 

 

[0 1 2 3]

 

In [60]:

type(a)

 

Out[60]:

numpy.ndarray

 

 

• array함수는 np 라이브러리에 들어있다
• 입력값으로 list가 들어감
• 동일한 데이터형이어야 함

 

 

리스트를 array로 바꾸기¶

 

In [51]:

a = [0,1,2,3]
type(a)

 

Out[51]:

list

 

 

• 리스트가 있다면 그 리스트를 입력값으로 넣어주기만 하면 됨

 

In [52]:

array_a = np.array(a)

 

In [53]:

type(array_a)

 

Out[53]:

numpy.ndarray

 

In [54]:

array_a

 

Out[54]:

array([0, 1, 2, 3])

 

 

Array의 attribute(속성)¶

 

In [68]:

a = np.array([0,1,2,3])

 

In [69]:

a.dtype

 

Out[69]:

dtype('int32')

 

In [70]:

a.ndim

 

Out[70]:

1

 

In [71]:

a.shape

 

Out[71]:

(4,)

 

 

• 8bit = 1byte
• 32bit이므로 4byte가 한 칸

 

In [72]:

a.size

 

Out[72]:

4

 

In [73]:

a.nbytes

 

Out[73]:

16

 

 

nbytes의 의미¶

 

 

메모리크기반환
byte 수가 몇개인가?
a.dtype이 int32인 경우
int32는 32bit를 뜻하고 1byte는 8bit이므로 총 4bytes이다.a의 원소의 개수는 총 4개 이므로 4bytes 4를 하면 총 16bytes의 메모리를 사용하는 것으로 볼 수 있다.
**a.dtype이 int64인 경우**
int64는 64bit를 뜻하고 1byte는 8bit이므로 총 8bytes이다.a의 원소의 개수는 총 4개 이므로 8bytes 6을 하면 총 32bytes의 메모리를 사용하는 것으로 볼 수 있다.

 

In [74]:

a.itemsize

 

Out[74]:

4

 

 

• size는 원소(element)의 개수

 

In [75]:

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

 

Out[75]:

dtype('int32')

 

 

int32의 의미¶

 

 

각 숫자마다 32개의 방이 부과됨.
1은 이진법으로 1이므로 방을 1개 차지해 방이 32개 남고
2,3는 이진법으로 10이므로 방을 2개 차지해 방이 30개 남고
4는 이진법으로 100이므로 방을 3개 차지해 방이 29개 남음
서버에서는 a.dtype이 int64로 뜸.
컴퓨터에 따라 a.dtype의 값이 다르게 나올 수 있음

 

In [76]:

a = np.array([1,2,3.5,4.1])

 

In [77]:

a.dtype

 

Out[77]:

dtype('float64')

 

 

• 데이터형은 자동으로 할당됨(int32, float64)

 

In [79]:

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

 

Out[79]:

array([1, 2, 3, 4])

 

In [81]:

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

 

Out[81]:

array([1., 2., 3., 4.])

 

In [82]:

a.dtype

 

Out[82]:

dtype('int32')

 

In [83]:

b.dtype

 

Out[83]:

dtype('float64')

 

In [84]:

np.array([1,2,3.5,4.1], int)

 

Out[84]:

array([1, 2, 3, 4])

 

 

Python vs Numpy¶

 

In [85]:

np.array([1,2,3.5, 4.1], float64)

 

 

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[85], line 1
----> 1 np.array([1,2,3.5, 4.1], float64)

NameError: name 'float64' is not defined

 

 

• Python의 데이터형은
  int, float, str, boolean, complex number, list, tuple, set, dict

 

In [86]:

Image("datatype.png")

 

Out[86]:

 

 

• 마무리 퀴즈

 

In [ ]:

# 설치된 Numpy 라이브러리 사용하려면 가장 먼저 해야할 일은?
import numpy as np

 

In [87]:

# array([0,1,2,3])와 같이 출력되도록 1차원 배열 만들기
a = np.array([0,1,2,3], int)
a

 

Out[87]:

array([0, 1, 2, 3])

 

In [ ]:

# Array 객체에서 속성의 종류는 무엇이 있었는가? 3개이상
a.dtype # 배열 원소 종류
a.ndim # 배열의 차원 수 or 배열의 축 수 
a.shape # 배열 각 차원의 크기를 (n,m) 형태 튜플로

 

 

추가학습(다음 블로그 참고)¶

 

 

https://chancoding.tistory.com/11

 

 

배열 선언¶

 

In [88]:

a = [1,2,3,4,5] #List
type(a)

 

Out[88]:

list

 

In [89]:

b = np.array([1,2,3,4,5]) # Array
type(b)

 

Out[89]:

numpy.ndarray

 

In [90]:

c = np.array(1,2,3,4,5) # 옳지 않은 방법

 

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[90], line 1
----> 1 c = np.array(1,2,3,4,5)

TypeError: array() takes from 1 to 2 positional arguments but 5 were given

 

 

numpy를 통해 배열은 선언하기 위해서는 np.array() 사용
c의 경우 에러 발생. 배열 선언 시에는 꼭 대괄호 [] 사용

 

 

배열의 차원¶

 

 

넘파이의 각 차원은 axes(축)으로 불림

 

In [93]:

np.array([1,2,3,4,5])

 

Out[93]:

array([1, 2, 3, 4, 5])

 

 

위 배열은 1차원 배열이며 1차원 배열의 길이는 5

 

In [94]:

np.array([[1,2,3,4,5],[6,7,8,9,10]])

 

Out[94]:

array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])

 

 

위 배열은 2차원 배열
첫 번째 차원은 [1,2,3,4,5]으로 길이가 5
두 번째 차원은 [6,7,8,9,10]으로 길이가 5
여기에 계속해서 차원 추가 가능
따라서 1,2,3,...n개의 차원으로 계속해서 많은 차원의 배열 선언 가능
나중에 딥러닝/머신러닝 진행 시 각 차원이 너무 많아져서 계산이 느려지는 문제 직면

 

 

넘파이 객체¶

 

 

넘파이의 class는 ndarray이며 일반적으로는 그냥 array 또는 배열이라고 이야기
ndarry 객체의 속성은 다음과 같다

 

 

ndarray.ndim¶

 

 

배열의 차원 수 or 배열의 축 수

 

In [99]:

b = np.array([1,2,3,4,5])
b.ndim

 

Out[99]:

1

 

In [100]:

c = np.array([[1.,0.,0.],
             [0.,1.,2.]])
c.ndim

 

Out[100]:

2

 

 

ndarray.shape¶

 

 

배열 각 차원의 크기를 튜플 형태로 표현
n행과 m열 행렬의 경우 (n, m) 형태의 튜플로 나타냄

 

In [113]:

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

 

In [114]:

c = np.array([[1.,0.,0.],
              [0.,1.,2.]])

 

In [115]:

d = np.array([[1.,0.,0.],
             [0.,1.,2.],
             [3.,4.,7.],
             [3.,0.,1.]])

 

In [116]:

b.shape

 

Out[116]:

(5,)

 

In [117]:

c.shape

 

Out[117]:

(2, 3)

 

In [118]:

d.shape

 

Out[118]:

(4, 3)

 

 

배열 b는 1차원 길이가 5인 배열이므로 shape를 보면 (5,)
배열 c는 2차원이며 각 차원의 길이가 3인 배열이므로 (2,3). 2행 3열로 이루어진 배열
배열 d는 4차원이며 각 차원의 길이가 3인 배열이므로 (4,3). 4행 3열로 이루어진 배열

 

 

ndarry.shape가 (5,)일 때와 (1,5)일 때의 차이¶

 

In [140]:

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

 

Out[140]:

array([1, 2, 3, 4, 5])

 

In [141]:

a.shape

 

Out[141]:

(5,)

 

 

• a는 원소의 개수가 총 5개인 1차원 배열

 

In [145]:

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

 

Out[145]:

array([[1, 2, 3, 4, 5]])

 

In [146]:

b.shape

 

Out[146]:

(1, 5)

 

 

ndarray.dtype¶

 

 

배열의 원소의 종류를 알 수 있음.
기본적으로 넘파이의 원소들은 모두 같은 데이터 타입을 가짐
numpy.int32, numpy.int16, numpy.float64 등이 있음

 

In [119]:

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

 

In [121]:

c = np.array([[1., 0., 0.],
            [0., 1., 2.]])

 

In [122]:

b.dtype

 

Out[122]:

dtype('int32')

 

In [123]:

c.dtype

 

Out[123]:

dtype('float64')

 

 

배열 b는 정수형 요소들로 이루어져 있으므로 data의 type은 int32로 출력
배열 c는 실수형 데이터 타입으로 이루어져 있어 data의 type은 float64으로 출력

 

 

2차원, 3차원 배열 만들기¶

 

 

• np.array() 함수를 써서 만들기
• arange()와 reshap()를 써서 만들기
• 3차원 배열 만들기

 

 

2차원 배열 만들기 1¶

 

 

np.array()함수 써서 만들기¶

 

In [125]:

arr1 = np.array([[1,2], [3,4]])
arr2 = np.array([[5,6], [7,8]])
arr1

 

Out[125]:

array([[1, 2],
       [3, 4]])

 

In [126]:

arr2

 

Out[126]:

array([[5, 6],
       [7, 8]])

 

 

• 중첩리스트

 

 

2차원 배열 만들기 2¶

 

 

arange와 reshape로 만들기¶

 

In [127]:

a = np.arange(8)

 

In [128]:

a.shape

 

Out[128]:

(8,)

 

In [129]:

a.reshape(2,4)

 

Out[129]:

array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

 

In [130]:

np.arange(8).reshape(2,4)

 

Out[130]:

array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

 

In [131]:

np.arange(6, dtype = np.float32).reshape(2,3)

 

Out[131]:

array([[0., 1., 2.],
       [3., 4., 5.]], dtype=float32)

 

 

• arange()를 쓰면 데이터타입도 정할 수 있음

 

 

3차원 배열 만들기¶

 

In [133]:

n = np.array([[[1,2],[3,4]],
             [[5,6],[7,8]]])
n

 

Out[133]:

array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])

 

In [135]:

n.shape

 

Out[135]:

(2, 2, 2)

 

In [136]:

np.arange(8).reshape(2,2,2)

 

Out[136]:

array([[[0, 1],
        [2, 3]],

       [[4, 5],
        [6, 7]]])

 

In [137]:

np.arange(24).reshape(2,3,4)

 

Out[137]:

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

 

In [138]:

np.arange(24).reshape(2,3,4).ndim

 

Out[138]:

3

 

 

차원의 의미¶

 

 

ndim은 배열의 차원 수 혹은 배열의 축 수를 의미한다.
여기서 차원의 수는 reshape함수에 들어가는 매개변수의 개수를 뜻한다.

 

In [150]:

np.arange(24).reshape(2,3,4).ndim # x,y,z

 

Out[150]:

3

 

In [151]:

np.arange(12).reshape(2,6).ndim # x,y

 

Out[151]:

2

 

In [154]:

np.arange(6).reshape(6,).ndim # x

 

Out[154]:

1

 

 

배열의 연산(Operation)¶

 

 

• 리스트의 연산과 비슷하지만, 약간 다르다
• numpy 함수를 쓰는 것보다 객체.함수()가 편리
• Numpy의 연산은 원소들끼리 이루어짐 element wise
• array의 형태(shape)가 안맞으면, 자동으로 맞추어 주기도 함. broadcasting

 

 

List Operation 연습¶

 

In [155]:

a = [1,2,3,4]
b = [5,6,7,8]
print(a,b)
type(a)

 

 

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

Out[155]:

list

 

In [158]:

a + b

 

Out[158]:

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

 

In [159]:

a - b

 

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[159], line 1
----> 1 a - b

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

 

In [160]:

a*3

 

Out[160]:

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

 

In [161]:

a[1]

 

Out[161]:

2

 

In [162]:

a[1] = 10
a

 

Out[162]:

[1, 10, 3, 4]

 

 

1D Array Operation¶

 

 

1D Array¶

 

 

• 사칙연산 +, -, *, /
• 거듭제곱, 제곱근
• 지수, 로그
• 삼각함수

 

In [164]:

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

 

In [165]:

b = np.array([5,6,7,8])

 

In [166]:

print(a,b)

 

 

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

 

In [167]:

type(a)

 

Out[167]:

numpy.ndarray

 

In [168]:

a.shape

 

Out[168]:

(4,)

 

In [169]:

a.size

 

Out[169]:

4

 

 

1차원 array의 사칙연산¶

 

In [170]:

a+b

 

Out[170]:

array([ 6,  8, 10, 12])

 

In [171]:

np.add(a,b)

 

Out[171]:

array([ 6,  8, 10, 12])

 

In [172]:

a-b

 

Out[172]:

array([-4, -4, -4, -4])

 

In [173]:

np.subtract(a,b)

 

Out[173]:

array([-4, -4, -4, -4])

 

 

• element wise

 

In [175]:

a*b

 

Out[175]:

array([ 5, 12, 21, 32])

 

In [176]:

np.multiply(a,b)

 

Out[176]:

array([ 5, 12, 21, 32])

 

In [177]:

a/b

 

Out[177]:

array([0.2       , 0.33333333, 0.42857143, 0.5       ])

 

In [178]:

np.divide(a,b)

 

Out[178]:

array([0.2       , 0.33333333, 0.42857143, 0.5       ])

 

In [179]:

a*b

 

Out[179]:

array([ 5, 12, 21, 32])

 

In [181]:

a**b

 

Out[181]:

array([    1,    64,  2187, 65536])

 

In [182]:

a*3

 

Out[182]:

array([ 3,  6,  9, 12])

 

In [183]:

a+1

 

Out[183]:

array([2, 3, 4, 5])

 

 

• broadcasting

 

 

2D Array Operation¶

 

In [184]:

arr1 = np.array([[1,2], [3,4]])

 

In [185]:

arr2 = np.array([[5,6], [7,8]])

 

In [186]:

arr1

 

Out[186]:

array([[1, 2],
       [3, 4]])

 

In [187]:

arr2

 

Out[187]:

array([[5, 6],
       [7, 8]])

 

 

2차원 array의 곱셈¶

 

In [188]:

np.multiply(arr1, arr2) 

 

Out[188]:

array([[ 5, 12],
       [21, 32]])

 

In [189]:

arr1*arr2

 

Out[189]:

array([[ 5, 12],
       [21, 32]])

 

 

matrix의 곱셈¶

 

 

• 행렬의 곱셈 참고

 

 

https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=junhyuk7272&logNo=50128686426

 

In [191]:

Image("matrixmul.png")

 

Out[191]:

 

In [192]:

np.matmul(arr1, arr2)

 

Out[192]:

array([[19, 22],
       [43, 50]])

 

In [193]:

arr1@arr2

 

Out[193]:

array([[19, 22],
       [43, 50]])

 

 

• 2X2여서 np.dot(arr1, arr2)도 위와 같다

 

In [195]:

np.dot(arr1, arr2) #np.dot은 2개의 input만을 받음

 

Out[195]:

array([[19, 22],
       [43, 50]])

 

 

• np.dot 참고출처

 

 

https://jimmy-ai.tistory.com/75

 

 

• 마무리 퀴즈

 

In [197]:

#다음과 같이 출력되도록 2차원 배열을 2가지 방법으로 만들기
#array([[5,6],
#       [7,8]])
#1. 
arr1 = np.array([[5,6], [7,8]])

 

In [198]:

arr1

 

Out[198]:

array([[5, 6],
       [7, 8]])

 

In [201]:

arr2 = np.arange(5,9).reshape(2,2)

 

In [202]:

arr2

 

Out[202]:

array([[5, 6],
       [7, 8]])

 

In [205]:

#2
arr = np.arange(36).reshape(3,4,3)

 

 

Numpy 내장함수를 이용해 array 만들기¶

 

 

• arange
• linspace
• zeros
• ones
• empty
• full
• tile
• **_like

 

 

arange¶

 

 

• arange(start, stop, step, dtype)

 

In [211]:

b = np.arange(1,9,2)
b

 

Out[211]:

array([1, 3, 5, 7])

 

In [212]:

a = np.arange(9, dtype = np.float32)
a

 

Out[212]:

array([0., 1., 2., 3., 4., 5., 6., 7., 8.], dtype=float32)

 

 

linspace¶

 

 

• linspace(start, stop, numbers of element)

 

In [213]:

c = np.linspace(0,1,6)
c

 

Out[213]:

array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])

 

In [216]:

d = np.linspace(0,1,5, endpoint = False)
d

 

Out[216]:

array([0. , 0.2, 0.4, 0.6, 0.8])

 

 

endpoint의 의미¶

 

 

endpoint=True 혹은 endpoint=False를 적을 수 있는데
이것이 적혀있지 않으면 디폴트(Default)로 True이며,
이는 stop으로 주어진 값을 포함시킬 것인지 아닌지를 선택하는 옵션

 

 

np.ones¶

 

 

• ones(shape [, dtype, order])

 

In [218]:

a = np.ones((3,3), int) # shape (3,3)은 튜플
a

 

Out[218]:

array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])

 

In [219]:

a*3

 

Out[219]:

array([[3, 3, 3],
       [3, 3, 3],
       [3, 3, 3]])

 

 

np.zeros¶

 

 

• zeros(shape [, dtype, order])

 

In [223]:

b = np.zeros((3,3))
b

 

Out[223]:

array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

 

In [224]:

b[2,0] = 3 # sparse matrix : 행렬의 대부분의 요소가 0인 행렬
b

 

Out[224]:

array([[0., 0., 0.],
       [0., 0., 0.],
       [3., 0., 0.]])

 

 

np.diag¶

 

 

• diagonal은 대각선

 

In [228]:

a = np.diag([1,2,3])
a

 

Out[228]:

array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])

 

In [229]:

c = np.arange(9).reshape(3,3)
np.diag(c)

 

Out[229]:

array([0, 4, 8])

 

 

np.identity¶

 

 

np.identity()는 정사각행렬이 정해져 있다¶

• np.identity()는 대각행렬이 1이고 나머지는 모두 0인 정사각행렬

 

In [232]:

d = np.identity(4)
d

 

Out[232]:

array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

 

In [233]:

np.identity(3)

 

Out[233]:

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

 

 

np.eye(4)와 np.identity(4)는 같다¶

 

In [234]:

d = np.eye(4,3)
d

 

Out[234]:

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])

 

In [235]:

np.eye(4,3)

 

Out[235]:

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])

 

In [236]:

np.eye(4)

 

Out[236]:

array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

 

 

• np.identity()와 np.eye()의 차이
  Identity 행렬은 항상 nxn의 행렬이라면, eye는 원하는 NxM으로 행렬을 만들 수 있다.

 

 

np.tile¶

 

 

• np.tile(A, repeat_shape)
• A 배열이 repeat_shape 형태로 반복되어 쌓인 형태가 반환

 

In [237]:

a = np.array([0,1,2])
np.tile(a,2) # repeat a 2 times

 

Out[237]:

array([0, 1, 2, 0, 1, 2])

 

In [238]:

np.tile(a, (3,2))

 

Out[238]:

array([[0, 1, 2, 0, 1, 2],
       [0, 1, 2, 0, 1, 2],
       [0, 1, 2, 0, 1, 2]])

 

 

np.full¶

 

 

• np.full(shape,fill_value)
• 모든 값이 사용자 지정값인 배열 생성

 

In [240]:

np.full((2,2),3)

 

Out[240]:

array([[3, 3],
       [3, 3]])

 

In [241]:

np.full((4,3),2)

 

Out[241]:

array([[2, 2, 2],
       [2, 2, 2],
       [2, 2, 2],
       [2, 2, 2]])

 

 

np.empty¶

 

 

• 선언한 행렬에, 무작위의 값을 모든 값에 입력

 

In [243]:

np.empty((2,3)) # null에 해당하는 주소값, 초기화 안함

 

Out[243]:

array([[6.23042070e-307, 4.67296746e-307, 1.69121096e-306],
       [9.34609111e-307, 1.42413555e-306, 1.78019082e-306]])

 

 

***_like() 함수로 배열만들기¶

 

 

• zeros_like()
• ones_like()
• empty_like()
• full_like()

 

 

zeros_like¶

 

 

• 형태와 데이터타입을 유지하면서 0으로 채움

 

In [246]:

a = np.arange(6).reshape(2,3)
a

 

Out[246]:

array([[0, 1, 2],
       [3, 4, 5]])

 

In [247]:

b = np.arange(3, dtype = np.float)
print(b)
b.dtype

 

 

[0. 1. 2.]

 

C:\Users\user\AppData\Local\Temp\ipykernel_9424\157655229.py:1: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.
Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
  b = np.arange(3, dtype = np.float)

Out[247]:

dtype('float64')

 

In [249]:

np.zeros_like(a)

 

Out[249]:

array([[0, 0, 0],
       [0, 0, 0]])

 

In [250]:

np.zeros_like(b)

 

Out[250]:

array([0., 0., 0.])

 

 

ones_like, empty_like¶

 

 

• 형태와 데이터타입을 유지하면서..

 

In [251]:

np.ones_like(a)

 

Out[251]:

array([[1, 1, 1],
       [1, 1, 1]])

 

In [252]:

np.ones_like(b)

 

Out[252]:

array([1., 1., 1.])

 

In [253]:

np.empty_like(a)

 

Out[253]:

array([[         0, 1072693248,          0],
       [1072693248,          0, 1072693248]])

 

In [254]:

np.empty_like(b)

 

Out[254]:

array([1., 1., 1.])

 

 

full_like¶

 

 

• 형태와 데이터타입을 유지하면서..

 

In [255]:

np.full_like(a)

 

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[255], line 1
----> 1 np.full_like(a)

File <__array_function__ internals>:179, in full_like(*args, **kwargs)

TypeError: _full_like_dispatcher() missing 1 required positional argument: 'fill_value'

 

In [256]:

np.full_like(a,3)

 

Out[256]:

array([[3, 3, 3],
       [3, 3, 3]])

 

In [257]:

np.full_like(b, 3.1)

 

Out[257]:

array([3.1, 3.1, 3.1])

 

 

copy()의 두가지 방법¶

 

 

• 기본 배열로부터 새로운 배열을 생성하기 위해서는 copy 함수로 명시적으로 사용해야 함
• copy 함수로 복사한 배열은 원본 배열과 완전히 다른 새로운 객체
• slice, indexing은 새로운 객체가 아닌 기존 배열의 뷰(View)
• 반환한 배열의 값을 변경하면 원본 배열이 변경됨

 

 

copy() 방법1¶

 

In [259]:

A = np.arange(1,6)
A

 

Out[259]:

array([1, 2, 3, 4, 5])

 

In [260]:

B = A.copy() # B = np.copy(A)
B

 

Out[260]:

array([1, 2, 3, 4, 5])

 

In [261]:

B = np.copy(A)
B

 

Out[261]:

array([1, 2, 3, 4, 5])

 

In [262]:

B[3] = 0
B

 

Out[262]:

array([1, 2, 3, 0, 5])

 

In [264]:

A #A는 안변함

 

Out[264]:

array([1, 2, 3, 4, 5])

 

 

copy() 방법2¶

 

In [265]:

C = A #이렇게 할당
C

 

Out[265]:

array([1, 2, 3, 4, 5])

 

In [267]:

C[3] = 0
C

 

Out[267]:

array([1, 2, 3, 0, 5])

 

In [269]:

A #A도 변함 View

 

Out[269]:

array([1, 2, 3, 0, 5])

 

 

• 퀴즈

 

In [270]:

np.arange(1,9,2)

 

Out[270]:

array([1, 3, 5, 7])

 

In [271]:

np.linspace(0,1,6)

 

Out[271]:

array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])

 

In [272]:

np.ones((3,3), int)

 

Out[272]:

array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])

 

In [273]:

# ***like에는 어떤 것들이 있나?

 

 

zeros_like, ones_like, empty_like, full_like

 

In [274]:

#copy와 비교해 view란?

 

 

copy 깊은복사 view 얕은복사

 

 

배열의 결합. stack으로 만들기¶

 

 

• hstack
• vstack
• dstack
• concatenate

 

 

stack이란:FIFO. 선착순의 반대

 

 

vstack¶

 

 

• 배열을 세로로 결합

 

In [277]:

a = np.arange(5)
a*10

 

Out[277]:

array([ 0, 10, 20, 30, 40])

 

In [278]:

np.vstack([a*10, a*20])

 

Out[278]:

array([[ 0, 10, 20, 30, 40],
       [ 0, 20, 40, 60, 80]])

 

In [279]:

np.vstack([a*10, a*20]).shape

 

Out[279]:

(2, 5)

 

 

hstack¶

 

 

• 배열을 가로로 결합

 

In [281]:

np.hstack([a*10, a*20])

 

Out[281]:

array([ 0, 10, 20, 30, 40,  0, 20, 40, 60, 80])

 

In [3]:

import numpy as np
a = [1,2,3]
b = [4,5,6]
np.vstack([a,b]) # 리스트이거나

 

Out[3]:

array([[1, 2, 3],
       [4, 5, 6]])

 

In [4]:

a = np.array([1,2,3])
b = np.array([4,5,6])
np.vstack([a,b]) # array이거나

 

Out[4]:

array([[1, 2, 3],
       [4, 5, 6]])

 

 

dstack¶

 

In [7]:

np.dstack((a,b)) # stack arrays in sequence depth wise

 

Out[7]:

array([[[1, 2]],

       [[2, 3]],

       [[3, 4]]])

 

In [8]:

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

 

In [9]:

print(a)

 

 

[[1]
 [2]
 [3]]

 

In [10]:

print(b)

 

 

[[2]
 [3]
 [4]]

 

In [11]:

np.dstack((a,b))

 

Out[11]:

array([[[1, 2]],

       [[2, 3]],

       [[3, 4]]])

 

 

배열의 분리 spliting¶

 

 

• 수평분리 hsplit와 수직분리 vsplit

 

In [13]:

from IPython.display import Image
Image("hsplit.png")

 

Out[13]:

 

 

• np.hsplit(a,2)

 

In [22]:

a = np.arange(1,25).reshape((4,6))
a

 

Out[22]:

array([[ 1,  2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11, 12],
       [13, 14, 15, 16, 17, 18],
       [19, 20, 21, 22, 23, 24]])

 

In [23]:

a.shape

 

Out[23]:

(4, 6)

 

In [20]:

a[:,:3]

 

Out[20]:

array([[ 1,  2,  3],
       [ 7,  8,  9],
       [13, 14, 15],
       [19, 20, 21]])

 

In [21]:

a[:,3:]

 

Out[21]:

array([[ 4,  5,  6],
       [10, 11, 12],
       [16, 17, 18],
       [22, 23, 24]])

 

 

• np.vsplit(a,2)

 

In [27]:

b = np.arange(1,25).reshape((4,6))

 

In [28]:

b.shape

 

Out[28]:

(4, 6)

 

In [29]:

b[:2]

 

Out[29]:

array([[ 1,  2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11, 12]])

 

In [30]:

b[2:]

 

Out[30]:

array([[13, 14, 15, 16, 17, 18],
       [19, 20, 21, 22, 23, 24]])

 

 

hsplit¶

 

In [31]:

a = np.arange(1,25).reshape((4,6))
a

 

Out[31]:

array([[ 1,  2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11, 12],
       [13, 14, 15, 16, 17, 18],
       [19, 20, 21, 22, 23, 24]])

 

In [32]:

np.hsplit(a,2)

 

Out[32]:

[array([[ 1,  2,  3],
        [ 7,  8,  9],
        [13, 14, 15],
        [19, 20, 21]]),
 array([[ 4,  5,  6],
        [10, 11, 12],
        [16, 17, 18],
        [22, 23, 24]])]

 

In [33]:

np.hsplit(a,3)

 

Out[33]:

[array([[ 1,  2],
        [ 7,  8],
        [13, 14],
        [19, 20]]),
 array([[ 3,  4],
        [ 9, 10],
        [15, 16],
        [21, 22]]),
 array([[ 5,  6],
        [11, 12],
        [17, 18],
        [23, 24]])]

 

 

vsplit¶

 

In [34]:

np.vsplit(a,2)

 

Out[34]:

[array([[ 1,  2,  3,  4,  5,  6],
        [ 7,  8,  9, 10, 11, 12]]),
 array([[13, 14, 15, 16, 17, 18],
        [19, 20, 21, 22, 23, 24]])]

 

In [35]:

np.vsplit(a,3)

 

 

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[35], line 1
----> 1 np.vsplit(a,3)

File <__array_function__ internals>:180, in vsplit(*args, **kwargs)

File ~\anaconda3\lib\site-packages\numpy\lib\shape_base.py:997, in vsplit(ary, indices_or_sections)
    995 if _nx.ndim(ary) < 2:
    996     raise ValueError('vsplit only works on arrays of 2 or more dimensions')
--> 997 return split(ary, indices_or_sections, 0)

File <__array_function__ internals>:180, in split(*args, **kwargs)

File ~\anaconda3\lib\site-packages\numpy\lib\shape_base.py:872, in split(ary, indices_or_sections, axis)
    870     N = ary.shape[axis]
    871     if N % sections:
--> 872         raise ValueError(
    873             'array split does not result in an equal division') from None
    874 return array_split(ary, indices_or_sections, axis)

ValueError: array split does not result in an equal division

 

In [36]:

np.vsplit(a,4)

 

Out[36]:

[array([[1, 2, 3, 4, 5, 6]]),
 array([[ 7,  8,  9, 10, 11, 12]]),
 array([[13, 14, 15, 16, 17, 18]]),
 array([[19, 20, 21, 22, 23, 24]])]

 

 

Numpy의 shape 변경 함수¶

 

 

• reshape
• flatten
• ravel

 

 

reshape¶

 

In [37]:

a = np.arange(20)
a

 

Out[37]:

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19])

 

In [39]:

b = np.reshape(a, (4,5)) # better expression

 

In [41]:

a = np.arange(24)
a

 

Out[41]:

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23])

 

In [43]:

a.reshape(2,12)

 

Out[43]:

array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])

 

In [44]:

a.reshape(2,-1) # -1은 자동으로 맞추어 주라는 뜻

 

Out[44]:

array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])

 

In [45]:

a.reshape(-1, 6)

 

Out[45]:

array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

 

In [46]:

Image("reshape.png")

 

Out[46]:

 

 

flatten, ravel¶

 

 

• flatten, ravel 모두 다차원 배열을 1차원으로 바꿈
• flatten은 copy(복사)하므로 원본 변경 X
• ravel은 변경하면 원본도 같이 변경

 

In [47]:

c = b.flatten() #return a copy
c

 

Out[47]:

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19])

 

In [49]:

d = b.ravel() # flatten과 차이점
d

 

Out[49]:

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19])

 

In [50]:

c[3] = 30
print(c)

 

 

[ 0  1  2 30  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

 

In [51]:

print(b)

 

 

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

 

In [52]:

d[3] = 30
print(d)

 

 

[ 0  1  2 30  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

 

In [53]:

print(b)

 

 

[[ 0  1  2 30  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

 

 

transpose¶

 

In [55]:

Image("transpose.png")

 

Out[55]:

 

In [6]:

import numpy as np

 

In [7]:

a = np.array([[0,1,2,3]])
a

 

Out[7]:

array([[0, 1, 2, 3]])

 

In [9]:

b = a.T #T attribute 사용
b

 

Out[9]:

array([[0],
       [1],
       [2],
       [3]])

 

In [10]:

a = np.arange(6).reshape(2,3)
a

 

Out[10]:

array([[0, 1, 2],
       [3, 4, 5]])

 

In [12]:

np.transpose(a) # transpose() 함수 사용

 

Out[12]:

array([[0, 3],
       [1, 4],
       [2, 5]])

 

 

• 마무리 간단퀴즈

 

In [13]:

# a = np.array([1,2,3])이고 b = np.array([4,5,6])일 때,
# array([[1,2,3],
#       [4,5,6]])이 되도록 결합

 

In [14]:

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

 

In [16]:

np.vstack([a,b])

 

Out[16]:

array([[1, 2, 3],
       [4, 5, 6]])

 

In [17]:

# np.flatten()과 np.ravel()이 차이

 

 

flatten과는 다르게 ravel은 같은 메모리 공유

 

In [19]:

# [[1,2],                         [[1,3]                               
# [3,4]]인 배열을 만들고 전치하여   [2,4]]로 만들기

 

In [22]:

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

 

In [23]:

b = a.T

 

In [24]:

b

 

Out[24]:

array([[1, 3],
       [2, 4]])

 

 

두 배열 비교¶

 

 

• 같다(==)
• 크다, 작다
• 배열 전체를 하나로 비교 (np.array_equal)

 

 

Comparison¶

 

In [25]:

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

 

In [26]:

print(a,b)
type(a)

 

 

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

Out[26]:

numpy.ndarray

 

In [27]:

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

 

In [30]:

a == b # 각각 비교

 

Out[30]:

array([False, False, False, False])

 

In [31]:

a > b

 

Out[31]:

array([False, False, False, False])

 

In [32]:

np.array_equal(a,b)

 

Out[32]:

False

 

 

정렬하기 sort()¶

 

 

• numpy.sort()와 객체.sort()는 다르다.
• 1차원 배열의 정렬, 역순으로 정렬
• 2차원 배열의 정렬과 축기준으로 정렬하기

 

 

np.sort()¶

 

 

np.sort() 함수와 객체.sort()의 차이¶

 

In [34]:

a = np.array([4,2,6,5,1,3,0])
a

 

Out[34]:

array([4, 2, 6, 5, 1, 3, 0])

 

In [35]:

np.sort(a) #View

 

Out[35]:

array([0, 1, 2, 3, 4, 5, 6])

 

In [36]:

a

 

Out[36]:

array([4, 2, 6, 5, 1, 3, 0])

 

In [37]:

a.sort() #배열 자체를 정렬

 

In [40]:

a

 

Out[40]:

array([0, 1, 2, 3, 4, 5, 6])

 

 

역순 정렬¶

 

In [41]:

a = np.array([4,2,6,5,1,3,0])

 

In [42]:

np.sort(a)[::-1] ## 정렬한 후 step이 뒤에서 읽어옴

 

Out[42]:

array([6, 5, 4, 3, 2, 1, 0])

 

 

축을 지정해 정렬¶

 

In [43]:

x = np.array([[2,1,6],
            [0,7,4],
            [5,3,2]])
x

 

Out[43]:

array([[2, 1, 6],
       [0, 7, 4],
       [5, 3, 2]])

 

In [44]:

np.sort(x, axis=0) # row - wise 행끼리

 

Out[44]:

array([[0, 1, 2],
       [2, 3, 4],
       [5, 7, 6]])

 

In [45]:

np.sort(x, axis=1) #coloum - wise 열끼리

 

Out[45]:

array([[1, 2, 6],
       [0, 4, 7],
       [2, 3, 5]])

 

 

인덱싱(Indexing)¶

 

 

1D Indexing¶

 

In [46]:

np.array([0,1,2,3])

 

Out[46]:

array([0, 1, 2, 3])

 

In [47]:

a = np.array([0,1,2,3])
a.ndim #차원의 수

 

Out[47]:

1

 

In [48]:

a.size

 

Out[48]:

4

 

In [50]:

a.nbytes

 

Out[50]:

16

 

In [51]:

a.dtype

 

Out[51]:

dtype('int32')

 

In [54]:

a[0] = 10
a

 

Out[54]:

array([10,  1,  2,  3])

 

In [55]:

a[0] = 10.5

 

In [56]:

a

 

Out[56]:

array([10,  1,  2,  3])

 

 

2D Indexing¶

 

In [57]:

a = np.array([[0,1,2,3],
             [10,11,12,13]])

 

In [58]:

a

 

Out[58]:

array([[ 0,  1,  2,  3],
       [10, 11, 12, 13]])

 

In [59]:

a.ndim

 

Out[59]:

2

 

In [60]:

a.shape

 

Out[60]:

(2, 4)

 

In [61]:

a.size

 

Out[61]:

8

 

In [63]:

a[1,3]

 

Out[63]:

13

 

In [64]:

a[1,3] = -1 # a[1,3]자리에 -1대입

 

In [65]:

a

 

Out[65]:

array([[ 0,  1,  2,  3],
       [10, 11, 12, -1]])

 

In [66]:

a[1]

 

Out[66]:

array([10, 11, 12, -1])

 

In [67]:

a[1,]

 

Out[67]:

array([10, 11, 12, -1])

 

In [68]:

a[,1]

 

 

  Cell In[68], line 1
    a[,1]
      ^
SyntaxError: invalid syntax

 

In [69]:

a[:,1]

 

Out[69]:

array([ 1, 11])

 

 

• 간단 퀴즈

 

In [81]:

a = np.arange(0, 60).reshape(6, 10)[:,:6]
a

 

Out[81]:

array([[ 0,  1,  2,  3,  4,  5],
       [10, 11, 12, 13, 14, 15],
       [20, 21, 22, 23, 24, 25],
       [30, 31, 32, 33, 34, 35],
       [40, 41, 42, 43, 44, 45],
       [50, 51, 52, 53, 54, 55]])

 

In [84]:

a = np.array([0,1,2,3,4,5])
b = np.array([[0],[10],[20],[30],[40],[50]])
a = a+b
a

 

Out[84]:

array([[ 0,  1,  2,  3,  4,  5],
       [10, 11, 12, 13, 14, 15],
       [20, 21, 22, 23, 24, 25],
       [30, 31, 32, 33, 34, 35],
       [40, 41, 42, 43, 44, 45],
       [50, 51, 52, 53, 54, 55]])

 

In [87]:

a[:,2]

 

Out[87]:

array([ 2, 12, 22, 32, 42, 52])

 

 

슬라이싱(Slicing)¶

 

 

• var[lower:upper:step] upper은 포함안돼

 

 

1D slicing¶

 

 

• 1차원 배열은 리스트에서의 slicing과 같다.

 

In [88]:

a = np.array([10,11,12,13,14])
a

 

Out[88]:

array([10, 11, 12, 13, 14])

 

In [89]:

a = np.array([10,11,12,13,14])
a

 

Out[89]:

array([10, 11, 12, 13, 14])

 

In [90]:

a[1:3]

 

Out[90]:

array([11, 12])

 

In [91]:

a[1:-2]

 

Out[91]:

array([11, 12])

 

In [92]:

a[-4:3]

 

Out[92]:

array([11, 12])

 

In [93]:

a[-2:1]

 

Out[93]:

array([], dtype=int32)

 

In [95]:

a = np.array([10,11,12,13,14])

 

In [96]:

a

 

Out[96]:

array([10, 11, 12, 13, 14])

 

In [97]:

a[:3]

 

Out[97]:

array([10, 11, 12])

 

In [98]:

a[-2:]

 

Out[98]:

array([13, 14])

 

In [99]:

a[::2]

 

Out[99]:

array([10, 12, 14])

 

 

2D slicing¶

 

 

• 2차원 배열은 1차원 배열이 2개 있는 것이다. (and 연산)

 

In [106]:

a = np.array([0,1,2,3,4,5])
b = [[0], [10], [20], [30], [40], [50]]
a = a+b
a

 

Out[106]:

array([[ 0,  1,  2,  3,  4,  5],
       [10, 11, 12, 13, 14, 15],
       [20, 21, 22, 23, 24, 25],
       [30, 31, 32, 33, 34, 35],
       [40, 41, 42, 43, 44, 45],
       [50, 51, 52, 53, 54, 55]])

 

In [107]:

a[4:,4:]

 

Out[107]:

array([[44, 45],
       [54, 55]])

 

In [108]:

a[:,2]

 

Out[108]:

array([ 2, 12, 22, 32, 42, 52])

 

In [109]:

a[2::2,::2]

 

Out[109]:

array([[20, 22, 24],
       [40, 42, 44]])

 

 

var[lower:upper:step]

 

 

slicing으로 값 수정하기¶

 

In [110]:

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

 

Out[110]:

array([0, 1, 2, 3, 4])

 

In [111]:

a[-2:]

 

Out[111]:

array([3, 4])

 

In [112]:

a[-2:] = [13,14]

 

In [113]:

a

 

Out[113]:

array([ 0,  1,  2, 13, 14])

 

In [114]:

a[-2:]=11
a

 

Out[114]:

array([ 0,  1,  2, 11, 11])

 

 

slicing은 원본 View¶

 

 

• slice한 것은 복사품이 아니라, 원본의 참조

 

In [115]:

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

 

Out[115]:

array([0, 1, 2, 3, 4])

 

In [116]:

b = a[2:4]
b

 

Out[116]:

array([2, 3])

 

In [117]:

b[0] = 10

 

In [118]:

b

 

Out[118]:

array([10,  3])

 

In [119]:

a

 

Out[119]:

array([ 0,  1, 10,  3,  4])

 

 

• changing b change a

 

 

그림으로 정리¶

 

In [122]:

from IPython.display import Image
Image("slicing.png")

 

Out[122]:

 

 

• 마무리 퀴즈

 

In [126]:

a = np.array([0,1,2,3,4])
b = np.array([[0], [5],[10], [15], [20]])
a =a+b

 

In [127]:

a[4]

 

Out[127]:

array([20, 21, 22, 23, 24])

 

In [128]:

a[:,1:4:2]

 

Out[128]:

array([[ 1,  3],
       [ 6,  8],
       [11, 13],
       [16, 18],
       [21, 23]])

 

In [129]:

a[1:4:2,:4:2]

 

Out[129]:

array([[ 5,  7],
       [15, 17]])

 

 

팬시 인덱싱(Fancy Indexing)이란¶

 

 

• 정수 배열을 indexer로 사용해서 Indexing하는 방법
• 정수나 불린(Boolean) 값을 가지는 다른 Numpy 배열로 배열을 인덱싱할 수 있는 기능

 

 

• indexing by position
• indexing by boolean
• indexing by condition

 

 

Fancy Indexing.position¶

 

In [145]:

a = np.arange(0,80,step=10)

 

In [146]:

a

 

Out[146]:

array([ 0, 10, 20, 30, 40, 50, 60, 70])

 

In [147]:

indices = [1,2,-3]

 

In [148]:

a[indices] = 99 # index에 있는 값 바꾸기
a

 

Out[148]:

array([ 0, 99, 99, 30, 40, 99, 60, 70])

 

In [149]:

a[indices]

 

Out[149]:

array([99, 99, 99])

 

In [150]:

a[[1,2,-3]]

 

Out[150]:

array([99, 99, 99])

 

 

Fancy Indexing.boolean¶

 

In [151]:

a = np.arange(0,80,step=10)

 

In [152]:

a

 

Out[152]:

array([ 0, 10, 20, 30, 40, 50, 60, 70])

 

In [153]:

mask = np.array([0,1,1,0,0,1,0,0], dtype = bool)

 

In [154]:

a[mask]

 

Out[154]:

array([10, 20, 50])

 

In [155]:

mask = np.array([False, True, True, False, False, True, False, False])

 

In [157]:

a[mask]

 

Out[157]:

array([10, 20, 50])

 

In [158]:

a = np.arange(0,80,step = 10)

 

In [159]:

a

 

Out[159]:

array([ 0, 10, 20, 30, 40, 50, 60, 70])

 

In [160]:

a>40

 

Out[160]:

array([False, False, False, False, False,  True,  True,  True])

 

In [161]:

a[a>40]

 

Out[161]:

array([50, 60, 70])

 

In [162]:

mask = a>40
a[mask]

 

Out[162]:

array([50, 60, 70])

 

 

2차원 팬시 인덱싱¶

 

In [163]:

# 미리 알아두어야 할 것
a = np.arange(12).reshape(3,4)

 

In [164]:

a

 

Out[164]:

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

 

In [167]:

[a[0,1], a[1,2], a[2,0], a[2,3]]

 

Out[167]:

[1, 6, 8, 11]

 

In [169]:

a[[0,1,2,2], [1,2,0,3]] # (0,1)(1,2)(2,0)(2,3)

 

Out[169]:

array([ 1,  6,  8, 11])

 

In [175]:

a = np.arange(0, 60).reshape(6,10)[:,:6]
a

 

Out[175]:

array([[ 0,  1,  2,  3,  4,  5],
       [10, 11, 12, 13, 14, 15],
       [20, 21, 22, 23, 24, 25],
       [30, 31, 32, 33, 34, 35],
       [40, 41, 42, 43, 44, 45],
       [50, 51, 52, 53, 54, 55]])

 

In [176]:

a[[0,1,2,3,4],
 [1,2,3,4,5]]

 

Out[176]:

array([ 1, 12, 23, 34, 45])

 

In [177]:

a[3:, [0,2,5]]

 

Out[177]:

array([[30, 32, 35],
       [40, 42, 45],
       [50, 52, 55]])

 

In [178]:

mask = np.array([1,0,1,0,0,1], dtype = bool)

 

In [179]:

a[3:, mask]

 

Out[179]:

array([[30, 32, 35],
       [40, 42, 45],
       [50, 52, 55]])

 

In [180]:

a[mask, 2]

 

Out[180]:

array([ 2, 22, 52])

 

 

• 마무리 퀴즈

 

In [186]:

a = np.array([0,1,2,3,4])
b = [[0],[5],[10],[15],[20]]
a = a+b
a

 

Out[186]:

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

 

In [187]:

a[[0,1,2,3],[1,2,3,4]]

 

Out[187]:

array([ 1,  7, 13, 19])

 

 

브로드캐스팅(Broadcasting)¶

 

 

• 차원(dimension)이 다른 두 배열의 연산에서
• 낮은 차원의 배열이 차원을 맞추어 주도록 변화
• 데이터의 복사를 하지 않으므로 빠르다

 

 

브로드캐스팅¶

 

In [188]:

Image("broadcasting.png")

 

Out[188]:

 

In [189]:

a = np.ones((3,5))
a

 

Out[189]:

array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])

 

In [194]:

b = np.ones((5,))
b

 

Out[194]:

array([1., 1., 1., 1., 1.])

 

In [195]:

a+b

 

Out[195]:

array([[2., 2., 2., 2., 2.],
       [2., 2., 2., 2., 2.],
       [2., 2., 2., 2., 2.]])

 

In [196]:

a+2

 

Out[196]:

array([[3., 3., 3., 3., 3.],
       [3., 3., 3., 3., 3.],
       [3., 3., 3., 3., 3.]])

 

In [201]:

a = np.ones((3,5))
a

 

Out[201]:

array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])

 

In [202]:

b = np.array([1,2])

 

In [203]:

b

 

Out[203]:

array([1, 2])

 

In [204]:

a+b

 

 

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[204], line 1
----> 1 a+b

ValueError: operands could not be broadcast together with shapes (3,5) (2,) 

 

In [205]:

Image("broadcastingerror.png")

 

Out[205]:

 

In [206]:

a = np.array([[0], [10], [20], [30]])
b = np.array([0,1,2])

 

In [207]:

a+b

 

Out[207]:

array([[ 0,  1,  2],
       [10, 11, 12],
       [20, 21, 22],
       [30, 31, 32]])

 

 

Array Calculation(=Computation) by Universal Functions¶

 

 

• 수학함수 : sum, prod, min, max, argmin, argmax
• 통계함수 : mean, std, var
• 진리값 : any, all

 

 

sum()¶

 

In [209]:

a = np.array([[1,2,3], [4,5,6]])
a

 

Out[209]:

array([[1, 2, 3],
       [4, 5, 6]])

 

In [210]:

np.sum(a)

 

Out[210]:

21

 

In [211]:

np.sum(a)

 

Out[211]:

21

 

In [212]:

a.shape

 

Out[212]:

(2, 3)

 

In [213]:

np.sum(a,axis=0) #행끼리 더해

 

Out[213]:

array([5, 7, 9])

 

In [214]:

np.sum(a,axis=1) #열끼리 더해

 

Out[214]:

array([ 6, 15])

 

 

min(), max()¶

 

In [215]:

np.min(a)

 

Out[215]:

1

 

In [216]:

np.min(a, axis = 0)

 

Out[216]:

array([1, 2, 3])

 

In [217]:

np.min(a, axis=1)

 

Out[217]:

array([1, 4])

 

In [218]:

np.max(a)

 

Out[218]:

6

 

In [219]:

np.max(a,axis=0)

 

Out[219]:

array([4, 5, 6])

 

In [220]:

np.max(a,axis=1)

 

Out[220]:

array([3, 6])

 

 

argmin(), argmax¶

 

 

• argmin(): 가장 작은 원소의 인덱스 반환
• argmax(): 가장 큰 원소의 인덱스 반환

 

In [221]:

np.argmin(a)

 

Out[221]:

0

 

In [222]:

np.argmax(a)

 

Out[222]:

5

 

 

mean(), std(), var()¶

 

In [224]:

np.mean(a)

 

Out[224]:

3.5

 

In [225]:

a.mean()

 

Out[225]:

3.5

 

In [226]:

np.mean(a,axis=0)

 

Out[226]:

array([2.5, 3.5, 4.5])

 

In [227]:

a.mean(axis=0)

 

Out[227]:

array([2.5, 3.5, 4.5])

 

In [228]:

np.mean(a, axis=1)

 

Out[228]:

array([2., 5.])

 

In [229]:

a.std()

 

Out[229]:

1.707825127659933

 

In [230]:

a.std(axis=0)

 

Out[230]:

array([1.5, 1.5, 1.5])

 

In [231]:

a.std(axis=1)

 

Out[231]:

array([0.81649658, 0.81649658])

 

In [232]:

a.var(axis=0)

 

Out[232]:

array([2.25, 2.25, 2.25])

 

 

where¶

 

In [233]:

a = np.array([6,8,7,9,10], dtype = int)
a

 

Out[233]:

array([ 6,  8,  7,  9, 10])

 

In [234]:

np.where(a>7) #return index

 

Out[234]:

(array([1, 3, 4], dtype=int64),)

 

In [235]:

index = np.where(a>7)
print(index) # index
a[index] # value

 

 

(array([1, 3, 4], dtype=int64),)

Out[235]:

array([ 8,  9, 10])

 

In [236]:

a = np.arange(1,7).reshape(2,3)
a

 

Out[236]:

array([[1, 2, 3],
       [4, 5, 6]])

 

In [237]:

np.where(a>2)

 

Out[237]:

(array([0, 1, 1, 1], dtype=int64), array([2, 0, 1, 2], dtype=int64))

 

In [238]:

a[np.where(a>2)]

 

Out[238]:

array([3, 4, 5, 6])

 

 

• 마무리 퀴즈

 

 

• 아래와 같은 array를 만듦

 

In [240]:

a = np.arange(-15, 15).reshape(5,6)**2

 

In [241]:

a

 

Out[241]:

array([[225, 196, 169, 144, 121, 100],
       [ 81,  64,  49,  36,  25,  16],
       [  9,   4,   1,   0,   1,   4],
       [  9,  16,  25,  36,  49,  64],
       [ 81, 100, 121, 144, 169, 196]])

 

 

1. 각 행별로 최댓값은 각각 얼마?¶

 

In [243]:

np.max(a, axis = 1)

 

Out[243]:

array([225,  81,   9,  64, 196])

 

 

2. 각 열별로 평균?¶

 

In [244]:

np.mean(a, axis=0)

 

Out[244]:

array([81., 76., 73., 72., 73., 76.])

 

 

파이썬은 왜 느린가? 넘파이는 왜 빠른가?¶

 

 

• Numpy의 메모리 저장 위치 vs Python
• Numpy does not make new one (strides)
• C is faster than any interpreter language

 

 

strides¶

 

 

strides는 '걸음걸이'라는 뜻을 가지고 있는 단어
numpy에서는 각 dimensions를 건너가는데 몇 bytes나 뛰어넘어야 하는지에 대한 정보
예를 들어 [[1,2,3],[4,5,6]]이라는 2차원의 array가 있음
strides를 사용하면 (dimensions 간의 간격, 앨리먼트 간의 간격)으로 결과 출력 각 dimension의 간격은 [1,2,3]의 용량과 같으므로 4바이트인 int32형 3개 = 12bytes인 것

 

In [245]:

a = np.arange(6)
a

 

Out[245]:

array([0, 1, 2, 3, 4, 5])

 

In [246]:

a.strides

 

Out[246]:

(4,)

 

In [247]:

b = a.reshape(2,3)
b

 

Out[247]:

array([[0, 1, 2],
       [3, 4, 5]])

 

In [248]:

b.strides

 

Out[248]:

(12, 4)

 

 

메모리 저장구조¶

 

In [249]:

a = np.array([[0,1,2],
            [3,4,5]])

 

In [250]:

a.shape

 

Out[250]:

(2, 3)

 

In [251]:

a.T

 

Out[251]:

array([[0, 3],
       [1, 4],
       [2, 5]])

 

In [253]:

a.T.shape

 

Out[253]:

(3, 2)

 

In [ ]: