Numpy_03

In [3]:

import numpy as np

Numpy 배열의 함수 이용하기¶

np.sqrt(배열명) : 제곱근 구하기¶

np.log10(배열명) : 로그 구하기¶

In [4]:

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

Out[4]:

array([1.        , 1.41421356, 1.73205081, 2.        , 2.23606798])

In [5]:

np.log10([10,100,2000])

Out[5]:

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

퀴즈¶

: 1~10까지의 ndarray 배열 생성후¶

np.log10(), np.sqrt() 함수 적용하기¶

소숫점 결과는 3번째 자리에서 반올림한다.¶

In [9]:

np.set_printoptions(precision=2)

In [10]:

arr = np.arange(1,11)
arr

Out[10]:

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

In [11]:

np.log10(arr)

Out[11]:

array([0.  , 0.3 , 0.48, 0.6 , 0.7 , 0.78, 0.85, 0.9 , 0.95, 1.  ])

In [12]:

np.sqrt(arr)

Out[12]:

array([1.  , 1.41, 1.73, 2.  , 2.24, 2.45, 2.65, 2.83, 3.  , 3.16])

In [ ]:

두개의 배열에서 큰 숫자 또는 작은 숫자만 추출하기¶

• np.maximum(배열1, 배열2)
• np.minimum(배열1, 배열2)

In [13]:

arr1 = np.random.randn(10)
arr1

Out[13]:

array([ 0.03, -0.06, -0.5 , -1.18,  0.89,  0.55, -1.63,  1.59,  1.5 ,
        0.13])

In [14]:

arr2 = np.random.randn(10)
arr2

Out[14]:

array([-0.13, -1.02,  1.4 , -0.78,  0.41, -0.87,  0.34, -0.09,  0.09,
        0.41])

2개의 선언된 배열에서 큰값 또는 작은값만 지정하여 새로운 ndArray 배열 생성

In [15]:

arr3 = np.maximum(arr1,arr2)
arr3

Out[15]:

array([ 0.03, -0.06,  1.4 , -0.78,  0.89,  0.55,  0.34,  1.59,  1.5 ,
        0.41])

In [16]:

arr4 = np.minimum(arr1,arr2)
arr4

Out[16]:

array([-0.13, -1.02, -0.5 , -1.18,  0.41, -0.87, -1.63, -0.09,  0.09,
        0.13])

np.argmax() , np.argmin()¶

• 배열내 최대값 또는 최소값의 인덱스를 반환한다.
• np.argmax(배열명), np.argmin(배열명)
• np.argmax(배열명, axis=0), np.argmin(배열명, axis=1)

In [171]:

arrA = ([1,100,-10,45, 33, 50, 200])
arrA

Out[171]:

[1, 100, -10, 45, 33, 50, 200]

In [172]:

np.argmax(arrA)

Out[172]:

6

In [173]:

np.argmin(arrA)

Out[173]:

2

In [19]:

arrB = ( [1, 2, 4, 7],
         [9, 88, 6, 45],
         [100, 6, 4, 88])
arrB

Out[19]:

([1, 2, 4, 7], [9, 88, 6, 45], [100, 6, 4, 88])

세로열에서 제일 큰 값의 인덱스 표시¶

In [20]:

np.argmax(arrB, axis=0)

Out[20]:

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

가로행에서 제일 큰 값의 인덱스 표시¶

In [21]:

np.argmax(arrB, axis=1)

Out[21]:

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

In [ ]:

배열 원소 전체의 합과 평균 구하기¶

• 배열이름.sum()
• 배열이름.mean()

1~10까지의 합과 평균 구하기¶

In [30]:

arr1 = np.arange(1,11)
arr1

Out[30]:

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

In [31]:

arr1.sum()

Out[31]:

55

In [32]:

arr1.mean()

Out[32]:

5.5

3행3열의 정규분포를 이용한 난수 배열 생성 후 합과 평균 구하기¶

In [23]:

arr2 = np.random.randn(3,3)
arr2

Out[23]:

array([[ 0.53, -1.1 ,  0.6 ],
       [-0.46, -0.78, -0.21],
       [ 2.04,  1.27, -0.32]])

In [24]:

# 모든원소의 합
arr2.sum()

Out[24]:

1.5695573705452763

In [25]:

# 모든원소의 평균값
arr2.mean()

Out[25]:

0.1743952633939196

1~50 사이의 정수 난수로 구성된 4행 4열의 배열 생성 후 합과 평균 구하기¶

In [39]:

arr3 = np.random.randint(1,51,size=(4,4))
arr3

Out[39]:

array([[10, 16, 23, 39],
       [45, 16, 11,  1],
       [ 6,  9, 21, 16],
       [25, 32, 43, 37]])

In [40]:

arr3.sum()

Out[40]:

350

In [41]:

arr3.mean()

Out[41]:

21.875

각 열과 행 단위로 합 구하기¶

• 배열이름.sum(axis=0) : 열단위
• 배열이름.sum(axis=1) : 행단위

In [42]:

arr2d = np.random.randn(3,3)
arr2d

Out[42]:

array([[ 0.26906324,  2.70576033, -1.789695  ],
       [ 0.19655628,  0.43899469, -0.02146596],
       [-0.01852145,  0.75223277,  1.10178681]])

In [43]:

# 세로 컬럼의 합
arr2d.sum(axis=0)

Out[43]:

array([ 0.44709807,  3.89698779, -0.70937415])

In [44]:

# 가로 행의 합 
arr2d.sum(axis=1)

Out[44]:

array([1.18512856, 0.61408501, 1.83549813])

In [27]:

# 1~20 사이의 정수값을 이용해서 3행 2열 넘파이 배열 생성 
arr2dInt = np.random.randint(1,21,size=(3,2))
arr2dInt

Out[27]:

array([[11,  9],
       [ 5, 19],
       [ 2, 16]])

In [28]:

# 세로 컬럼의 합
arr2dInt.sum(axis=0)

Out[28]:

array([18, 44])

In [29]:

# 가로 행의 합 
arr2dInt.sum(axis=1)

Out[29]:

array([20, 24, 18])

각 열과 행 단위로 평균 구하기¶

• 배열이름.mean(axis=0) : 열단위
• 배열이름.mean(axis=1) : 행단위

In [30]:

# 
arr2dInt = np.random.randint(1,41,size=(2,5))
arr2dInt

Out[30]:

array([[26, 40,  3, 28, 40],
       [10, 31, 12,  8, 38]])

In [31]:

arr2dInt.mean(axis=0)

Out[31]:

array([18. , 35.5,  7.5, 18. , 39. ])

In [32]:

arr2dInt.mean(axis=1)

Out[32]:

array([27.4, 19.8])

Numpy 배열의 병합( concatenate) 1¶

• np.vstack((배열명1,배열명2)) : 행으로 합치기
• np.hstack((배열명1,배열명2)) : 열로 합치기

In [33]:

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

행으로 합치기¶

In [34]:

np.vstack((a,b))

Out[34]:

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

열로 합치기¶

In [35]:

np.hstack((a,b))

Out[35]:

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

1행 3열인 두개의 ndArray 가로와 세로로 합치기¶

In [62]:

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

Out[62]:

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

In [64]:

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

Out[64]:

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

In [66]:

np.vstack((a,b))

Out[66]:

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

In [65]:

np.hstack((a,b))

Out[65]:

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

Numpy 배열의 병합( concatenate) 2¶

• 가로, 세로 방향으로 넘파이 배열 합치기
• np.concatenate((배열1, 배열2), axis=0/1)
• axis = 0 : 세로로 합치기
• axis = 1 : 가로로 합치기

In [36]:

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

In [37]:

a

Out[37]:

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

In [38]:

b

Out[38]:

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

np.vstack()과 비슷. 행으로 합치기¶

In [68]:

np.concatenate( (a,b), axis=0)

Out[68]:

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

np.hstack()과 비슷. 행으로 합치기¶

In [39]:

np.concatenate( (a,b), axis=1)

Out[39]:

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

수학적인 행렬의 곱 (DOT product)¶

배열1.dot(배열2)¶

• 수학적인 행렬곱 계산으로 1행과 1열의 곱, 1행과2열의 곱 ...
• 적용되는 배열의 행과 열수가 서로 반대이어야 한다.

In [72]:

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

Out[72]:

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

In [73]:

b = np.arange(7,13).reshape(3,2)
b

Out[73]:

array([[ 7,  8],
       [ 9, 10],
       [11, 12]])

In [74]:

a.dot(b)

Out[74]:

array([[ 58,  64],
       [139, 154]])

정렬과 관련된 함수 이용하기 - 1차원¶

• np.sort(배열이름) : 오름차순
• np.sort(배열이름)[::-1] : 내림차순

In [40]:

arr = np.random.randn(10)
arr

Out[40]:

array([-1.19,  1.82,  0.34, -0.7 ,  0.32, -1.29, -0.58,  0.  ,  0.19,
       -0.31])

In [41]:

np.sort(arr)

Out[41]:

array([-1.29, -1.19, -0.7 , -0.58, -0.31,  0.  ,  0.19,  0.32,  0.34,
        1.82])

In [42]:

np.sort(arr)[::-1]

Out[42]:

array([ 1.82,  0.34,  0.32,  0.19,  0.  , -0.31, -0.58, -0.7 , -1.19,
       -1.29])

정렬과 관련된 함수 이용하기 – 2차원¶

• np.sort(배열이름, axis=0) – 열방향으로 정렬하기
• np.sort(배열이름, axis=1) – 행방향으로 정렬하기

In [43]:

arr2d = np.random.randn(3,4)
arr2d

Out[43]:

array([[-0.29,  1.06,  0.61,  0.49],
       [ 0.82,  0.74,  0.48,  1.09],
       [ 0.94, -1.21, -1.77,  0.55]])

컬럼방향, 세로로 정렬하기

In [44]:

np.sort(arr2d,axis=0)

Out[44]:

array([[-0.29, -1.21, -1.77,  0.49],
       [ 0.82,  0.74,  0.48,  0.55],
       [ 0.94,  1.06,  0.61,  1.09]])

In [47]:

np.sort(arr2d,axis=0)[::-1]

Out[47]:

array([[ 0.94,  1.06,  0.61,  1.09],
       [ 0.82,  0.74,  0.48,  0.55],
       [-0.29, -1.21, -1.77,  0.49]])

행방향, 가로로 정렬하기

In [48]:

np.sort(arr2d,axis=1)

Out[48]:

array([[-0.29,  0.49,  0.61,  1.06],
       [ 0.48,  0.74,  0.82,  1.09],
       [-1.77, -1.21,  0.55,  0.94]])

In [49]:

np.sort(arr2d,axis=1)[::-1]

Out[49]:

array([[-1.77, -1.21,  0.55,  0.94],
       [ 0.48,  0.74,  0.82,  1.09],
       [-0.29,  0.49,  0.61,  1.06]])

중복값 제거하기¶

np.unique(배열명)¶

In [51]:

names = np.array(['Charles','Julia', 
                  'Hayoung','Charles', 
                  'Hayoung','Julia',
                  'Julia'])
names

Out[51]:

array(['Charles', 'Julia', 'Hayoung', 'Charles', 'Hayoung', 'Julia',
       'Julia'], dtype='<U7')

In [83]:

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

Out[83]:

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

In [84]:

np.unique(names)

Out[84]:

array(['Charles', 'Hayoung', 'Julia'], dtype='<U7')

In [85]:

np.unique(ints)

Out[85]:

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

단위행렬(Identity)¶

• 대각선의 원소가 모두 1이며 나머지 원소는 모두 0인
• 구조는 정사각 행렬. 행수와 열수가 같다.
• np.identity(대각선숫자)
• np.identity(n=대각선숫자, dtype=데이타형)

In [52]:

# 데이터형은 실수 
np.identity(3)

Out[52]:

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

In [53]:

# 정수형 
np.identity(n=4, dtype=int)

Out[53]:

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

In [55]:

# 문자열형 
np.identity(n=5, dtype=np.str)

Out[55]:

array([['1', '', '', '', ''],
       ['', '1', '', '', ''],
       ['', '', '1', '', ''],
       ['', '', '', '1', ''],
       ['', '', '', '', '1']], dtype='<U1')

대각선이 1인 행렬만들기¶

• np.eye(N=1의숫자, M=열수, dtype=데이터형)
• np.eye(1의숫자) : 단위행렬과 같다. 정사각형 구조
• np.eye(1의숫자, 열수, k=startIndex)
• 행수와 열수가 달라도 된다.

1의 숫자가 3이고 컬럼수가 4인 정수형 배열

In [89]:

np.eye(N=3,M=4,dtype=int)

Out[89]:

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

단위행렬과 같다. 1의 수가 5개인 실수형 배열

In [90]:

np.eye(5)

Out[90]:

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

1의 갯수가 4개이며 컬럼수는 7개, 1의 시작인덱스는 1행3열

In [91]:

np.eye(4,7,k=2)

Out[91]:

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

In [94]:

np.eye(4,7,k=0)

Out[94]:

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

대각행렬의 값을 추출함 : np.diag()¶

• np.diag(배열이름)
• np.diag(배열이름, k=startIndex)

In [96]:

matrix = np.arange(9).reshape(3,3)
matrix

Out[96]:

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

In [97]:

np.diag(matrix)

Out[97]:

array([0, 4, 8])

In [98]:

np.diag(matrix, k=1)

Out[98]:

array([1, 5])

All& Any¶

• 배열의 데이터 전부(and) 또는 일부(or)가 조건에 만족 여부 반환
• any(조건식) => or
• all(조건식) => and

In [58]:

a = np.arange(10)
a

Out[58]:

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

In [60]:

# 넘파이배열에서는 비교 조건식을 적용하면 각각 아이템을 비교하여 
#  True/ False 로 반환한다
a <= 0

Out[60]:

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

In [61]:

a > 5

Out[61]:

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

any, all => True/ False 한개만 반환¶

In [136]:

np.any(a<5)

Out[136]:

True

In [137]:

np.any(a>5), np.any(a<0)

Out[137]:

(True, False)

In [138]:

np.all(a<5)

Out[138]:

False

In [62]:

np.all(a<100)

Out[62]:

True

비교 연산 1 - 두개 배열의 같은 위치 비교¶

• Numpy는 배열간의 크기가 동일할 때 원소간 비교의 결과를 Boolean Type 으로 반환하여 돌려준다

In [141]:

test_a = np.array([1,5,7])
test_b = np.array([5,2,1])

In [142]:

test_a > test_b

Out[142]:

array([False,  True,  True])

In [143]:

test_a == test_b

Out[143]:

array([False, False, False])

비교 연산 2¶

• np.logical_and (조건식1, 조건식2)
• np.logical_not (조건식)
• np.logical_or (조건식1, 조건식2)

In [150]:

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

Out[150]:

array([1, 9, 0])

In [151]:

np.logical_and(a > 0, a < 10)

Out[151]:

array([ True,  True, False])

In [152]:

np.logical_or(a > 0, a < 10)

Out[152]:

array([ True,  True,  True])

In [154]:

np.logical_not(a < 5)

Out[154]:

array([False,  True, False])

np.where¶

• np.where(조건식, True, False) : 조건식에 만족하면 True 해당하는 값 표시, 그렇지 않으면 False에 해당하는 값 표시
• np.where(조건식) : 조건식에 만족하면 값 표시

In [155]:

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

Out[155]:

array([1, 3, 0])

a가 true 값이면 1번째 True 값이 표시, False이면 2번째 값 False 값이 표시¶

In [159]:

np.where(a > 1, 5, 10)

Out[159]:

array([10,  5, 10])

b가 조건식에 만족하면 인덱스값이 출력¶

In [63]:

b = np.arange(5, 16)
b

Out[63]:

array([ 5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])

In [64]:

b > 10

Out[64]:

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

In [65]:

np.where(b > 10)

Out[65]:

(array([ 6,  7,  8,  9, 10], dtype=int64),)

np.isnan()¶

• np.isnan(넘파이배열명)
• Null 값인지 True / False
• np.NaN => 넘파이배열에서 null값을 의미한다.

In [168]:

c = np.array([np.NaN, 0, 4, 1.5])
c

Out[168]:

array([nan, 0. , 4. , 1.5])

In [170]:

np.isnan(c)

Out[170]:

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