Python 기초06_Numpy

Numpy 설치¶

• 파이썬으로 수치계산을 하기 위한 라이브러리
• 다차원 배열을 효율적으로 구현한 Numpy배열간 빠른 연산을 할 수 있는 루틴 제공
  pip install numpy
  conda install numpy

In [5]:

import numpy as np

• 리스트: 여러 데이터 타입의 데이터 원소를 가질 수 있음
• Numpy : 단일 데이터 타입의 데이터 원소를 가질 수 있음

In [6]:

import numpy as np
A= np.array([1,2,3])

In [7]:

A

Out[7]:

array([1, 2, 3])

In [16]:

A= [1, 2, 3]
B= [-1, -2 -3]
C= []
for a, b in zip(A, B):
    C.append(a+b)
print(C)

[0, -3]

In [19]:

import numpy as np 
A= np.array([1, 2, 3])
B= np.array([-1, -2, -3])
C= A+B
print(C)

[0 0 0]

In [20]:

len(A)

Out[20]:

3

In [23]:

import numpy as np
a= np.array([0.1, 0.2, 0.3])
print(a)
print(a.dtype)
print(type(a[0]))

[0.1 0.2 0.3]
float64
<class 'numpy.float64'>

In [24]:

import numpy as np
b= np.array([1, 2, 3])
print(b)
print(b.dtype)
print(type(b[0]))

[1 2 3]
int32
<class 'numpy.int32'>

dtype= ' '을 사용해서 데이터 타입 지정

In [11]:

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

In [12]:

print(c)
print(c.dtype)

[1 2 3]
int32

In [14]:

d= np.array([1.1, 2.2, 3.3, 4.7])
print(d.dtype)

float64

**astype(자료형)으로 데이터 타입 변환

In [15]:

e= d.astype(np.int32)
print(e.dtype)

int32

- numpy.ndarray¶

• numpy 배열의 타입은 numpy.ndarray 클래스임

In [9]:

import numpy as np
A= np.array([[1, 2, 3], [4, 5, 6]])
print(A)
print(type(A))

[[1 2 3]
 [4 5 6]]
<class 'numpy.ndarray'>

ndarray.ndim¶

• 배열을 구성하는 차원의 개수

In [16]:

A= np.array([[1, 2, 3], [4, 5, 6]])
print(A.ndim)

2

In [18]:

B= np.array([1, 2, 3])
print(B.ndim)

1

In [19]:

C= np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
print(C.ndim)

3

ndarray.shape¶

• 배열을 구성하는 차원의 개수와 차원별 크기를 튜플로 나타냄

In [21]:

B= np.array([1, 2, 3])
print(B.ndim)
print(B.shape)

1
(3,)

In [20]:

A= np.array([[1, 2, 3], [4, 5, 6]])
print(A.ndim)
print(A.shape)

2
(2, 3)

In [22]:

C= np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
print(C.ndim)
print(C.shape)

3
(2, 2, 3)

ndarray.size¶

• 배열에 있는 모든 원소의 개수(shape의 모든 원소를 곱한 값)

In [5]:

import numpy as np
B= np.array([1, 2, 3])
print(B.ndim)
print(B.shape)
print(B.size)

1
(3,)
3

In [8]:

A= np.array([[1, 2, 3], [4, 5, 6]])
print(A.ndim)
print(A.shape)
print(A.size)

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

2
(2, 3)
6
(3, 4)

Out[8]:

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

In [25]:

C= np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
print(C.ndim)
print(C.shape)
print(C.size)

3
(2, 2, 3)
12

ndarray.dtype¶

• 배열원소의 데이터 타입을 나타냄
  ### ndarray.itemsize
• 배열원소 하나의 바이트 크기
  ### ndarray.data
• 배열원소를 실제로 저장하고 있는 버퍼

In [26]:

B= np.array([1, 2, 3])
print(B.dtype)
print(B.itemsize)
print(B.data)

int32
4
<memory at 0x00000194673B2040>

In [27]:

A= np.array([[1, 2, 3], [4, 5, 6]])
print(A.dtype)
print(A.itemsize)
print(A.data)

int32
4
<memory at 0x0000019465F77040>

In [28]:

C= np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
print(C.dtype)
print(C.itemsize)
print(C.data)

int32
4
<memory at 0x000001946588DE50>

min/max/sum/mean¶

In [29]:

b= np.array([1, 2, 3, 4, 5, 6])
print(b.max(), end=" ")
print(b.min(), end=" ")
print(b.sum(), end=" ")
print(b.mean(), end=" ")

6 1 21 3.5

In [30]:

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

Out[30]:

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

In [31]:

c.sum(axis=0) # 열방향으로 계산

Out[31]:

array([5, 7, 9])

In [32]:

c.sum(axis=1) #행방향으로 계산

Out[32]:

array([ 6, 15])

In [36]:

!conda install -c conda-forge opencv

Collecting package metadata (current_repodata.json): ...working... done
Solving environment: ...working... done

# All requested packages already installed.

In [37]:

import cv2

In [ ]:

import cv2
print(cv2.__version__)

In [1]:

import cv2

image = cv2.imread("aa/balloon.jpg", cv2.IMREAD_COLOR)
cv2.imshow("Ball", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

In [5]:

import cv2

image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("Gray", image_gray)
cv2.waitKey(0)
cv2.destroyAllWindows()

In [11]:

#차원의 개수
print(image.ndim)
print(image_gray.ndim)

3
2

In [10]:

# 배열을 구성하는 차원의 개수와 차원별 크기를 튜플로 나타냄
print(image.shape)
print(image_gray.shape)

(230, 219, 3)
(230, 219)

넘파이 배열 원소 접근방법¶

In [14]:

import numpy as np
A= np.array([1,2,3])
A

Out[14]:

array([1, 2, 3])

In [15]:

print(A.shape)

(3,)

In [16]:

for i in range(A.size):
    print(A[i])

1
2
3

In [17]:

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

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

In [18]:

B[1]

Out[18]:

array([4, 5, 6])

In [19]:

print(B[0,2])

3

In [20]:

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

In [22]:

print(C[1,0,2])

9

In [24]:

import numpy as np
C= np.arange(24).reshape(2,3,4)
print(C.shape)

(2, 3, 4)

In [25]:

print(np.arange(10000). reshape(100,100))

[[   0    1    2 ...   97   98   99]
 [ 100  101  102 ...  197  198  199]
 [ 200  201  202 ...  297  298  299]
 ...
 [9700 9701 9702 ... 9797 9798 9799]
 [9800 9801 9802 ... 9897 9898 9899]
 [9900 9901 9902 ... 9997 9998 9999]]

In [98]:

import sys 
np.set_printoptions(threshold=sys.maxsize)
print(np.arange(200). reshape(2,100))

[[  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  25  26  27  28  29  30  31  32  33  34  35
   36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53
   54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71
   72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89
   90  91  92  93  94  95  96  97  98  99]
 [100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
  118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
  136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
  154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
  172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
  190 191 192 193 194 195 196 197 198 199]]

In [73]:

import timeit
timeit.timeit('B**2', setup='import numpy as np; B=np.arange(100)')

Out[73]:

0.6282845999994606

In [96]:

import timeit
timeit.timeit('[i**2 for i in A]', setup='A=range(100)')

Out[96]:

20.08197300000029

In [35]:

import numpy as np
a=np.array([1,2,3,4]) 
print(a.shape)

(4,)

In [36]:

a.shape=1,4

In [37]:

print(a)

[[1 2 3 4]]

In [38]:

a.shape

Out[38]:

(1, 4)

In [39]:

a.shape=4,1

In [40]:

print(a)

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

In [41]:

print(a.shape)

(4, 1)

배열 생성 및 shape 변환¶

In [47]:

import numpy as np
A=np.zeros((2,3))
print(A)
print(A.dtype)
#기본은  float64

[[0. 0. 0.]
 [0. 0. 0.]]
float64

In [44]:

import numpy as np
A=np.zeros((2,3), dtype='uint8')
print(A)
print(A.dtype)

[[0 0 0]
 [0 0 0]]
uint8

In [45]:

import numpy as np
A=np.ones((2,3))
print(A)
print(A.dtype)

[[1. 1. 1.]
 [1. 1. 1.]]
float64

In [46]:

import numpy as np
A=np.ones((2,3), dtype='uint8')
print(A)
print(A.dtype)

[[1 1 1]
 [1 1 1]]
uint8

np.empty(): 초기화 하지 않고 배열 공간 할당하기¶

In [50]:

C=np.empty((5,5))
print(C)
print()
print(C.dtype)

[[6.23042070e-307 4.67296746e-307 1.69121096e-306 8.34441742e-308
  1.37961302e-306]
 [9.34593493e-307 1.33511290e-306 1.33511969e-306 1.69120416e-306
  1.78022342e-306]
 [8.34449382e-308 1.06811422e-306 1.00132143e-307 8.34423068e-308
  8.90071135e-308]
 [1.11257937e-307 1.78022342e-306 2.44776798e-307 1.69119330e-306
  1.69122046e-306]
 [1.86921958e-306 6.89804133e-307 1.11261162e-306 8.34443015e-308
  2.22813476e-312]]

float64

np.random.random()¶

• 0~1 사이의 실수를 랜덤으로 생성

In [52]:

import random
import numpy as np 
D= np.random.random((3,3))
print(D)

[[0.2642987  0.05553899 0.24423954]
 [0.32598247 0.52201816 0.66689007]
 [0.45552892 0.47999297 0.35326953]]

np.random.randint(시작,끝(가로, 세로))¶

• 시작~끝 사이의 실수를 랜덤으로 생성

In [54]:

import random
import numpy as np 
E= np.random.randint(1,10,(2,3))
print(E)

[[4 4 1]
 [8 9 9]]

연속원소 배열 생성함수¶

• np.arrange(시작,마지막,간격)
• np.arrange(시작,마지막)
• np.arrange(마지막)

In [57]:

# 0~50범위에서 5간격으로 숫자를 뽑아 배열 생성
A=np.arange(0,50,5)
print(A)

# 0.1~2.5사이에서 1간격으로 숫자를 뽑아 배열 생성 
B=np.arange(0.1,2.5,1)
print(B)

# 0<= x <10 내에서 배열 생성
C=np.arange(0,10)
print(C)

[ 0  5 10 15 20 25 30 35 40 45]
[0.1 1.1 2.1]
[0 1 2 3 4 5 6 7 8 9]

np.linspace()¶

• 지정한 범위 내에서 원하는 원소 개수로 숫자를 뽑아냄
• np.linspace(시작값, 마지막값, 샘플개수)
• np.linspace(시작값, 마지막값)

In [61]:

A=np.linspace(0,10,10)
print(A.size)
print(A)

10
[ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
  6.66666667  7.77777778  8.88888889 10.        ]

In [60]:

#샘플 개수를 정하지 않으면 기본값은 50
B= np.linspace(0,10)
print(B.size)
print(B)

50
[ 0.          0.20408163  0.40816327  0.6122449   0.81632653  1.02040816
  1.2244898   1.42857143  1.63265306  1.83673469  2.04081633  2.24489796
  2.44897959  2.65306122  2.85714286  3.06122449  3.26530612  3.46938776
  3.67346939  3.87755102  4.08163265  4.28571429  4.48979592  4.69387755
  4.89795918  5.10204082  5.30612245  5.51020408  5.71428571  5.91836735
  6.12244898  6.32653061  6.53061224  6.73469388  6.93877551  7.14285714
  7.34693878  7.55102041  7.75510204  7.95918367  8.16326531  8.36734694
  8.57142857  8.7755102   8.97959184  9.18367347  9.3877551   9.59183673
  9.79591837 10.        ]

In [63]:

# 0~15까지 16개 1차원 배열 

A=np.arange(16)

B= A.reshape(4,4)

print(A)
print(B)
print(A.shape)
print(B.shape)
print(B.base)
print(B.base is A) # B가 배열A의 데이터가 저장된 공간을 공유함 

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

In [64]:

B[0]=-1
print(A)
print(B)

[-1 -1 -1 -1  4  5  6  7  8  9 10 11 12 13 14 15]
[[-1 -1 -1 -1]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

In [66]:

C==B.reshape(2,8).copy()
C[0]= 0
print(C)
print(B)

[0 1 2 3 4 5 6 7 8 9]
[[-1 -1 -1 -1]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

In [67]:

C=np.arange(16)
print(C)

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

In [68]:

D=C.reshape(8,-1)
print(D)

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

In [69]:

E= C.reshape(-1,8)
print(E)

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

ravel()¶

• 주어진 배열을 1차원 배열로 변환하여 리턴

In [70]:

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

[[1 2]
 [3 4]]

In [71]:

B=A.ravel()
print(B)
print(B.shape)

[1 2 3 4]
(4,)

In [72]:

print(B.base is A)

True

In [93]:

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

[[[1 2]
  [3 4]]

 [[1 2]
  [3 4]]]

In [95]:

B= A.ravel() # 몇차원이든 1차원으로 
print(B)
print(B.shape)

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

newaxis()¶

• 차원을 증가시킴

In [76]:

a= np.array([1,2,3])
a=a[:, np.newaxis]
print(a.shape)
print(a)

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

In [77]:

a= np.array([1,2,3])
a=a[np.newaxis, :]
print(a.shape)
print(a)

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

hstack(가로로 결합)/ vstack (세로로 결합)¶

In [79]:

import numpy as np 
A= np.array([[1,2], [3,4]])
B= np.array([[1,0], [0,1]])
print(A)
print(B)
C=np.hstack((A,B))
print(C)
D= np.vstack((A,B))
print(D)

[[1 2]
 [3 4]]
[[1 0]
 [0 1]]
[[1 2 1 0]
 [3 4 0 1]]
[[1 2]
 [3 4]
 [1 0]
 [0 1]]

column_stack()¶

• 1차원 벡터를 2차원 벡터로 만들기

In [81]:

a=np.array([1,2,3])
b=np.array([4,5,6])
c=np.array([7,8,9])
D=np.column_stack((a,b,c))
print(D)

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

concatenate((배열1, 배열2), axis=1)¶

• 지정한 방향을 배열 결합
• axis= 0 :열방향
• axis= 1 :행방향

In [10]:

import numpy as np 
A= np.array([[1,2], [3,4]])
B= np.array([[1,0], [0,1]])

C= np.concatenate((A,B), axis=0) #열방향, 세로로 
print(C)
print()
D= np.concatenate((A,B), axis=1) #열방향, 가로로
print(D)

[[1 2]
 [3 4]
 [1 0]
 [0 1]]

[[1 2 1 0]
 [3 4 0 1]]

hsplit/ vsplit¶

• 가로 또는 세로로 자르기

In [83]:

B= np.arange(18).reshape(3,6)
print(B)

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

In [85]:

C=np.hsplit(B,3)
print(C)

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

In [86]:

b=np.hsplit(B, (2,4))
print(b) 

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

In [87]:

B= np.arange(18).reshape(6,3)
print(B)

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

In [88]:

b=np.vsplit(B, (2,4))
print(b) 

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

In [ ]: