Python - [추가] - 배열 데이터를 효과적으로 다루는 NumPy

배열 생성하기¶

시퀀스 데이터로부터 배열 생성¶

1. arr_obj = np.array(seq_data)
   • 시퀀스 데이터(리스트, 튜플 등)를 배열로 변경
2. 배열의 속성
   • dtype : 배열 요소의 데이터 타입
   • shape : 배열의 모양(차원)을 튜플로 표현

In [1]:

import numpy as np

In [2]:

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

Out[2]:

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

In [3]:

data2 = [0.1, 5, 4, 12, 0.5]
a2 = np.array(data2)
a2

Out[3]:

array([ 0.1,  5. ,  4. , 12. ,  0.5])

In [4]:

a1.dtype

Out[4]:

dtype('int32')

In [5]:

a2.dtype

Out[5]:

dtype('float64')

In [6]:

np.array([0.5, 2, 0.01, 8])

Out[6]:

array([0.5 , 2.  , 0.01, 8.  ])

In [7]:

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

Out[7]:

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

범위를 지정해 배열 생성¶

1. arr_obj = np.arange([start, ] stop[, step])
   • start부터 stop 전까지 step만큼 더해 배열을 생성
   • start 디폴트는 0
   • step 디폴트는 1

1. reshape(m, n)
   • 배열의 차원 조정
   • m x n 행태로 변경
   • 데이터의 개수가 맞아야 함

1. arr_obj = np.linspace(start, stop[, num])
   • start부터 stop까지(포함) num개의 NumPy 배열 생성
   • num 디폴트 값은 1
   • 등간격

In [8]:

np.arange(0, 10, 2)

Out[8]:

array([0, 2, 4, 6, 8])

In [9]:

np.arange(1, 10)

Out[9]:

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

In [10]:

np.arange(5)

Out[10]:

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

In [11]:

a1 = np.arange(1, 10)
a1.shape

Out[11]:

(9,)

In [12]:

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

Out[12]:

(3, 3)

In [13]:

np.arange(12).reshape(4,3)

Out[13]:

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

In [14]:

b1 = np.arange(12).reshape(4,3)
b1.shape

Out[14]:

(4, 3)

In [15]:

b2 = np.arange(5)
b2.shape

Out[15]:

(5,)

In [16]:

np.linspace(1, 10, 10)

Out[16]:

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

In [17]:

np.linspace(0, np.pi, 20 )

Out[17]:

array([0.        , 0.16534698, 0.33069396, 0.49604095, 0.66138793,
       0.82673491, 0.99208189, 1.15742887, 1.32277585, 1.48812284,
       1.65346982, 1.8188168 , 1.98416378, 2.14951076, 2.31485774,
       2.48020473, 2.64555171, 2.81089869, 2.97624567, 3.14159265])

특별한 형태의 배열 생성¶

1. arr_zero_n = np.zeros(n)
2. arr_zero_mxn = np.zeros((m,n))
   • 원소가 0인 배열 생성
3. arr_one_n = np.ones(n)
4. arr_one_mxn = np.ones((m,n))
   • 원소가 1인 배열 생성
5. arr_I = np.eye(n)
   • n x n 단위 행렬 생성

In [18]:

np.zeros(10)

Out[18]:

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

In [19]:

np.zeros((3,4))

Out[19]:

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

In [20]:

np.ones(5)

Out[20]:

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

In [21]:

np.ones((3,5))

Out[21]:

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

In [22]:

print(np.zeros((3,4,3)))

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

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

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

In [23]:

np.eye(3)

Out[23]:

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

배열의 데이터 타입 변환¶

1. 배열의 데이터 타입 기호

   • b : 불
   • i : 부호가 있는 정수
   • u : 부호가 없는 정수
   • f : 실수
   • c : 복소수
   • M : 날짜
   • O : 파이썬 객체
   • S 혹은 a : 바이트 배열
   • U : 유니코드

2. 데이터 타입의 숫자

   • 비트 수 혹은 바이트 수

3. 예

   • 'U8' : 8비트 유니코드
   • 'i32' : 32비트 부호 있는 정수

4. arr_obj = np.astype(타입)

   • 배열을 지정한 타입으로 변환

In [24]:

np.array(['1.5', '0.62', '2', '3.14', '3.141592'])

Out[24]:

array(['1.5', '0.62', '2', '3.14', '3.141592'], dtype='<U8')

In [25]:

str_a1 = np.array(['1.567', '0.123', '5.123', '9', '8'])
num_a1 = str_a1.astype(float)
num_a1

Out[25]:

array([1.567, 0.123, 5.123, 9.   , 8.   ])

In [26]:

str_a1.dtype

Out[26]:

dtype('<U5')

In [27]:

num_a1.dtype

Out[27]:

dtype('float64')

In [28]:

str_a2 = np.array(['1', '3', '5', '7', '9'])
num_a2 = str_a2.astype(int)
num_a2

Out[28]:

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

In [29]:

str_a2.dtype

Out[29]:

dtype('<U1')

In [30]:

num_a2.dtype

Out[30]:

dtype('int32')

In [31]:

num_f1 = np.array([10, 21, 0.549, 4.75, 5.98])
num_i1 = num_f1.astype(int)
num_i1

Out[31]:

array([10, 21,  0,  4,  5])

In [32]:

num_f1.dtype

Out[32]:

dtype('float64')

In [33]:

num_i1.dtype

Out[33]:

dtype('int32')

난수 배열의 생성¶

1. np.random.seed(시드값)
   • 난수 생성 시드값 설정
2. rand_num = np.random.rand()
   • [0. 1) 사이의 실수 난수 생성
3. rand_num = np.random.rand([d0, d1, …, dn])
   • 지정한 차원의 배열 생성
   • [0. 1) 사이의 실수 난수로 채움
4. rand_num = np.random.randn([d0, d1, …, dn])
   • 지정한 차원의 배열 생성
   • 가우시안 표준 정규 분포를 따르는 실수 난수 채움
5. rand_num = np.random.randint([low,] high, [,size])
   • [low, high)사이의 정수 난수를 갖는 배열 생성
   • size는 배열의 크기
     • 튜플로 지정 (d0, d1, … , dn)
   • low의 디폴트 값은 0

In [34]:

np.random.rand(2,3)

Out[34]:

array([[0.90489595, 0.39212714, 0.78862328],
       [0.12148813, 0.74450369, 0.08988644]])

In [35]:

np.random.rand()

Out[35]:

0.15643718220447145

In [36]:

np.random.rand(2,3,4)

Out[36]:

array([[[0.73820641, 0.42577202, 0.41657015, 0.87504651],
        [0.57242593, 0.34377185, 0.84156745, 0.66944234],
        [0.28846366, 0.111814  , 0.87112271, 0.36888092]],

       [[0.01674437, 0.45254855, 0.039231  , 0.97578635],
        [0.35657955, 0.03723221, 0.42644301, 0.3750988 ],
        [0.71855634, 0.39402083, 0.89719648, 0.22539515]]])

In [37]:

np.random.randint(10, size=(3, 4))

Out[37]:

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

In [38]:

np.random.randint(1, 30)

Out[38]:

10

배열의 연산¶

기본 연산¶

In [39]:

arr1 = np.array([10, 20, 30, 40])
arr2 = np.array([1, 2, 3, 4])

In [40]:

arr1 + arr2

Out[40]:

array([11, 22, 33, 44])

In [41]:

arr1 - arr2

Out[41]:

array([ 9, 18, 27, 36])

In [42]:

arr2 * 2

Out[42]:

array([2, 4, 6, 8])

In [43]:

arr2 ** 2

Out[43]:

array([ 1,  4,  9, 16], dtype=int32)

In [44]:

arr1 * arr2

Out[44]:

array([ 10,  40,  90, 160])

In [45]:

arr1 / arr2

Out[45]:

array([10., 10., 10., 10.])

In [46]:

arr1 / (arr2 ** 2)

Out[46]:

array([10.        ,  5.        ,  3.33333333,  2.5       ])

In [47]:

arr1 > 20

Out[47]:

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

배열의 인덱싱과 슬라이싱¶

배열의 인덱싱¶

1. 배열명[위치]
2. 배열명[[위치1, 위치2, …, 위치n]]
   • 해당 차원의 여러 원소 선택
3. 배열명[행_위치, 열_위치]
4. 배열명[ [행_위치1, 행_위치2, … , 행_위치n],

        [열_위치1, 열_위치2, … , 열_위치n]]
   

   • 2차원 배열의 여러 원소를 선택
5. 배열명[조건식]
   • 해당 조건식을 만족하는 원소만 선택된 배열

In [48]:

a1 = np.array([0, 10, 20, 30, 40, 50])
a1

Out[48]:

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

In [49]:

a1[0]

Out[49]:

0

In [50]:

a1[4]

Out[50]:

40

In [51]:

a1[5] = 70
a1

Out[51]:

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

In [52]:

a1[[1,3,4]]

Out[52]:

array([10, 30, 40])

In [53]:

a2 = np.arange(10, 100, 10).reshape(3,3)
a2

Out[53]:

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

In [54]:

a2[0, 2]

Out[54]:

30

In [55]:

a2[2, 2] = 95
a2

Out[55]:

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

In [56]:

a2[1]

Out[56]:

array([40, 50, 60])

In [57]:

a2[1] = np.array([45, 55, 65])
a2

Out[57]:

array([[10, 20, 30],
       [45, 55, 65],
       [70, 80, 95]])

In [58]:

a2[1] = [47, 57, 67]
a2

Out[58]:

array([[10, 20, 30],
       [47, 57, 67],
       [70, 80, 95]])

In [59]:

a2[[0, 2], [0, 1]]

Out[59]:

array([10, 80])

In [60]:

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

Out[60]:

array([4, 5, 6])

In [61]:

a[(a % 2) == 0]

Out[61]:

array([2, 4, 6])

배열의 슬라이싱¶

1. 배열[시작_위치:끝_위치]

   • 시작_위치 ~ 끝_위치-1 범위의 슬라이싱
   • 시작_위치 생략시 0
   • 끝_위치 생략시 배열의 끝

2. 배열[행시작_위치:행끝_위치, 열시작_위치:열끝_위치]

   • 2차원의 슬라이싱

In [62]:

b1 = np.array([0, 10, 20, 30, 40, 50])
b1[1:4]

Out[62]:

array([10, 20, 30])

In [63]:

b1[:3]

Out[63]:

array([ 0, 10, 20])

In [64]:

b1[2:]

Out[64]:

array([20, 30, 40, 50])

In [65]:

b1[2:5] = np.array([25, 35, 45])
b1

Out[65]:

array([ 0, 10, 25, 35, 45, 50])

In [66]:

b1[3:6] = 60
b1

Out[66]:

array([ 0, 10, 25, 60, 60, 60])

In [67]:

b2 = np.arange(10, 100, 10).reshape(3,3)
b2

Out[67]:

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

In [68]:

b2[1:3, 1:3]

Out[68]:

array([[50, 60],
       [80, 90]])

In [69]:

b2[:3, 1:]

Out[69]:

array([[20, 30],
       [50, 60],
       [80, 90]])

In [70]:

b2[1][0:2]

Out[70]:

array([40, 50])

In [71]:

b2[0:2, 1:3] = np.array([[25, 35], [55, 65]])
b2

Out[71]:

array([[10, 25, 35],
       [40, 55, 65],
       [70, 80, 90]])

In [ ]: