Python

05.Python Numpy

owo_v 2020. 9. 7. 16:52

 

 

 

 

 

Nmupy 설치

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

pip install Nmupy
conda install Nmupy

In [1]:
import numpy as np
 

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

Numpy : 단일 데이터 타입의 데이터 원소를 가질 수 있음

In [63]:
import numpy as np
A = np.array([1,2,3])
In [64]:
A
Out[64]:
array([1, 2, 3])
In [65]:
len(A)
Out[65]:
3
In [66]:
type(A[0])
Out[66]:
numpy.int32
In [67]:
A =[1,2,3]
B = [-1,-2,-3]
C = []

for a,b in zip(A,B):
    C.append(a+b)

print(C)
 
[0, 0, 0]
In [68]:
import numpy as np

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

C
Out[68]:
array([0, 0, 0])
In [73]:
import numpy as np

a=np.array([0.1,0.2,0.3])
print(a)
print(a.dtype)
print(type(a[0]))
a[0]
 
[0.1 0.2 0.3]
float64
<class 'numpy.float64'>
Out[73]:
0.1
In [15]:
a=np.array([1,2,3])
print(a)
print(a.dtype)
print(type(a[0]))
 
[1 2 3]
int32
<class 'numpy.int32'>
 

dtype=''을 사용하여 데이터 타입을 지정할 수 있다

In [17]:
c=np.array([1,2,3], dtype=np.float64)
In [18]:
print(c)
print(c.dtype)
 
[1. 2. 3.]
float64
In [75]:
c=np.array([1.,2.,3.])
print(c)
print(c.dtype)
 
[1. 2. 3.]
float64
 

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

In [22]:
d = np.array([1.1,2.2,3.3,4.7])
print(d.dtype)
 
float64
In [24]:
e = d.astype(np.int32)
print(e.dtype)
 
int32
 

numpy.ndarray

  • numpy 배열의 타입은 numpy.ndarray 클래스임
In [28]:
A = np.array([[1,2,3],[4,5,6]])
print(A)
print(type(A))
 
[[1 2 3]
 [4 5 6]]
<class 'numpy.ndarray'>
 

numpy.ndim

  • 배열을 구성하는 차원의 개수
In [77]:
B = np.array([1,2,3])
print(B.ndim)

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

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

ndarray.shape

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

ndarry.size

  • 배열에 있는 모든 원소의 개수 (shape의 모든 원소를 곱한 값)
In [37]:
B = np.array([1,2,3])
print(B.ndim)
print(B.shape) #튜플은 값이 1개만 나왔을 때 뒤에 ,를 붙여줘야 튜플인걸 알 수 있다 
print(B.size)
 
1
(3,)
3
In [38]:
A = np.array([[1,2,3],[4,5,6]])
print(A.ndim)
print(A.shape)
print(A.size)
 
2
(2, 3)
6
In [39]:
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 [40]:
B = np.array([1,2,3])
print(B.dtype)
print(B.itemsize)
print(B.data)
 
int32
4
<memory at 0x00000261BA95BA00>
In [41]:
A = np.array([[1,2,3],[4,5,6]])
print(A.dtype)
print(A.itemsize)
print(A.data)
 
int32
4
<memory at 0x00000261BB0F1380>
In [42]:
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 0x00000261BAD47D60>
 

min/max/sum/mean

In [44]:
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 [84]:
c = np.array([[1,2,3],[4,5,6]])
c
Out[84]:
array([[1, 2, 3],
       [4, 5, 6]])
In [86]:
c.sum(axis = 0) #열방향으로 계산
Out[86]:
array([5, 7, 9])
In [87]:
c.sum(axis = 1) #행방향으로 계산
Out[87]:
array([ 6, 15])
In [ ]:
! conda install -c conda-forge opencv
In [91]:
import cv2
print(cv2.__version__)
 
4.0.1
Collecting package metadata (current_repodata.json): ...working... done
Solving environment: ...working... done

# All requested packages already installed.
In [99]:
import cv2

image = cv2.imread("image/cat.jpg", cv2.IMREAD_COLOR)
cv2.imshow("Ball", image)
cv2.waitKey(0)
cv2.destroyAllWindows()
In [100]:
import cv2

image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("Ball", image_gray)
cv2.waitKey(0)
cv2.destroyAllWindows()
In [102]:
print(image.ndim)
print(image.shape)
print(image.size)
 
3
(448, 680, 3)
913920
In [103]:
print(image_gray.ndim)
print(image_gray.shape)
print(image_gray.size)
 
2
(448, 680)
304640
 

Numpy 배열 원소 접근방법

In [107]:
A = np.array([1,2,3])
A
Out[107]:
array([1, 2, 3])
In [108]:
print(A.shape)
 
(3,)
In [109]:
for i in range(A.size):
    print(A[i])
 
1
2
3
In [114]:
B = np.array([[1,2,3],[4,5,6]])
print(B)
 
[[1 2 3]
 [4 5 6]]
In [117]:
B[0]
Out[117]:
array([1, 2, 3])
In [118]:
B[1]
Out[118]:
array([4, 5, 6])
In [120]:
print(B[0,2])
 
3
In [123]:
C = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print(C)
 
[[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]
In [124]:
print(C[1,0,2])
 
9
In [126]:
import numpy as np

C = np.arange(24).reshape(2,3,4)
print(C)
print(C.shape)
 
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
(2, 3, 4)
In [127]:
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 [3]:
import sys
np.set_printoptions(threshold=sys.maxsize)
 
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-3-8c0575bca367> in <module>
      1 import sys
----> 2 np.set_printoptions(threshold=sys.maxsize)

NameError: name 'np' is not defined
In [5]:
import numpy as np
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 [136]:
import timeit
timeit.timeit('B**2', setup = 'import numpy as np; B=np.arange(100)')
Out[136]:
0.6123120999982348
In [138]:
import timeit
timeit.timeit('[i**2 for i in A]', setup='A=range(100)')
Out[138]:
20.85462539999935
In [139]:
import numpy as np
a = np.array([1,2,3,4])
print(a.shape)
 
(4,)
In [141]:
a.shape = 1,4
In [142]:
print(a)
 
[[1 2 3 4]]
In [143]:
a.shape
Out[143]:
(1, 4)
In [144]:
a.shape =4,1
In [145]:
print(a)
 
[[1]
 [2]
 [3]
 [4]]
In [146]:
print(a.shape)
 
(4, 1)
 

배열 생성 및 shape 변환

In [153]:
import numpy as np
A = np.zeros((2,3))
print(A)
print(A.dtype)
 
[[0. 0. 0.]
 [0. 0. 0.]]
float64
In [157]:
import numpy as np
A = np.zeros((2,3),dtype='uint8')
print(A)
print(A.dtype)
 
[[0 0 0]
 [0 0 0]]
uint8
In [154]:
import numpy as np
A = np.ones((2,3))
print(A)
print(A.dtype)
 
[[1. 1. 1.]
 [1. 1. 1.]]
float64
In [155]:
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 [160]:
C = np.empty((5,6))
print(C)
print(C.dtype)
 
[[1.29381329e-311 9.58487353e-322 0.00000000e+000 0.00000000e+000
  1.37961302e-306 1.16097020e-028]
 [3.11548378e-033 2.26402178e-076 1.58820501e-047 5.01163173e+217
  8.37170074e-144 2.82793694e-056]
 [7.61485364e+169 5.49513217e-090 9.85481600e+165 5.01163190e+217
  5.49419094e-143 6.47287734e+170]
 [7.50189709e+247 1.35617292e+248 2.77720910e+179 2.36594455e+179
  1.58831413e-076 1.32494912e-075]
 [5.99871455e-066 5.04621361e+180 8.37170571e-144 9.30350598e+199
  5.60230216e-067 5.81186265e+294]]
float64
 

np.random.random(가로,세로) : 0~1사이의 실수를 랜덤으로 생성

In [161]:
import random
import numpy as np


D = np.random.random((3,3))
print(D)
 
[[0.68312204 0.05925184 0.50230664]
 [0.31409232 0.79629292 0.52438422]
 [0.04412483 0.25362606 0.17246494]]
 

np.random.randint(시작,끝,(가로,세로)) : 시작~끝사이의 실수를 랜덤으로 생성

In [162]:
import random
import numpy as np


E = np.random.randint(1,10,(2,3))
print(E)
 
[[8 1 8]
 [1 9 1]]
 

연속원소 배열 생성함수

  • np.arange(시작,마지막,간격)
  • np.arange(시작,마지막)
  • np.arange(마지막)
In [164]:
#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 [165]:
A = np.linspace(0,10,10)
print(A)
 
[ 0.          1.11111111  2.22222222  3.33333333  4.44444444  5.55555556
  6.66666667  7.77777778  8.88888889 10.        ]
In [166]:
print(A.size)
 
10
In [167]:
#샘플개수를 정하지 않으면 기본값은 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 [171]:
#0~15까지 16개 1차원 배열

A = np.arange(16)

B = A.reshape(4,4)

print(A)
print()
print(B)
print()
print(B.shape)
print()
print(B.base)
print()
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]]

(4, 4)

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

True
In [174]:
C = B.reshape(2,8).copy()
In [175]:
C[0] = 0
print(C)
print(B)
 
[[ 0  0  0  0  0  0  0  0]
 [ 8  9 10 11 12 13 14 15]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
In [183]:
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 [176]:
C = np.arange(16)
print(C)
 
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
In [179]:
D = C.reshape(8,-1)
print(D)
 
[[ 0  1]
 [ 2  3]
 [ 4  5]
 [ 6  7]
 [ 8  9]
 [10 11]
 [12 13]
 [14 15]]
In [181]:
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 [185]:
A = np.array([[1,2],[3,4]])
print(A)
 
[[1 2]
 [3 4]]
In [187]:
B = A.ravel()
print(B)
print(B.shape)
 
[1 2 3 4]
(4,)
In [188]:
print(B.base is A)
 
True
In [189]:
A = np.array([[[1,2],[3,4]],[[1,2],[3,4]]])
print(A)
 
[[[1 2]
  [3 4]]

 [[1 2]
  [3 4]]]
In [190]:
B = A.ravel()
print(B)
print(B.shape)
 
[1 2 3 4 1 2 3 4]
(8,)
 

newaxis()

  • 차원을 증가시킴
In [191]:
a = np.array([1,2,3])
a = a[:,np.newaxis]
print(a.shape)
print(a)
 
(3, 1)
[[1]
 [2]
 [3]]
In [193]:
a = np.array([1,2,3])
a = a[np.newaxis,:]
print(a.shape)
print(a)
 
(1, 3)
[[1 2 3]]
 

hstack / vstack

  • 결합함수
  • hstack : 가로로 결합
  • vstack : 세로로 결합
In [197]:
import numpy as np
A = np.array([[1,2],[3,4]])
B = np.array([[1,0],[1,0]])
print(A)
print()
print(B)
print()
C = np.hstack((A,B))
print(C)
print()
D = np.vstack((A,B))
print(D)
 
[[1 2]
 [3 4]]

[[1 0]
 [1 0]]

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

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

column_stack()

  • 1차원 벡터를 2차원 벡터로 만든다
In [198]:
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 [199]:
import numpy as np
A = np.array([[1,2],[3,4]])
B = np.array([[1,0],[1,0]])

C =np.concatenate((A,B), axis=0)    #열방향 , 세로로
print(C)
D =np.concatenate((A,B), axis=1)    #행방향 , 가로로
print(D)
 
[[1 2]
 [3 4]
 [1 0]
 [1 0]]
[[1 2 1 0]
 [3 4 1 0]]
 

hsplit / vsplit

  • 가로 또는 세로로 자르기
In [200]:
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 [201]:
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 [203]:
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 [204]:
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 [207]:
C = np.vsplit(B,(2,4))
print(C)
 
[array([[0, 1, 2],
       [3, 4, 5]]), array([[ 6,  7,  8],
       [ 9, 10, 11]]), array([[12, 13, 14],
       [15, 16, 17]])]
In [1]:
from IPython.core.display import display, HTML
display(HTML("<style>.container {width:90% !important; }</style>"))
 
 
In [ ]: