통계분석시각화 : Numpy -소개

https://numpy.org/doc/stable/index.html

NumPy documentation — NumPy v1.22 Manual

 

파이썬을 통한 데이터 분석을 할때 기초 라이브러리로 사용된다.

보통 np라는 별칭으로 사용된다.

 

import numpy as np

 

numpy

선형 시퀀스(튜플, 리스트)를 배열 개체로 취급한다.

ls = [1,2,3]
arr = np.array(ls)
print(arr)


arr = np.array([1,2,3]) #바로 list 넣어서 만들 수 도 있다.
print(arr)


"""
<출력>
[1 2 3]
"""

 

shape

array의 크기를 튜플형태로 표현

ndim

array의 차원 수 표현

print("크기 : ", arr.shape)
print("차원 : ", arr.ndim)

"""
크기 :  (3,)
차원 :  1
"""

다차원배열

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

"""
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
 
""" 
 
print("크기 : ", arr.shape)
print("차원 : ", arr.ndim)


"""
크기 :  (4, 3)  #행,열
차원 :  2

"""

 

 

다양한 방법으로 생성이 가능하다.

#초기값->0 나중에 값 변경 가능 
#https://numpy.org/doc/stable/reference/generated/numpy.zeros.html?highlight=numpy%20zeros#numpy.zeros

z_arr = np.zeros(10) #배열요소 10개, 0로 생성  , (10,dtype=int)로 원하는 형식 만들기 가능
print(z_arr)
print("크기 : ", z_arr.shape)
print("차원 : ", z_arr.ndim)
print("형식 : ", z_arr.dtype)


"""
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
크기 :  (10,)
차원 :  1
원소형식 :  float64  #실수형 64bit (정수형=32bit)
"""
----------------------------------------------------------------------
z_arr = np.zeros((2,3))
print(z_arr)
print("크기 : ", z_arr.shape)
print("차원 : ", z_arr.ndim)
print("원소형식 : ", z_arr.dtype)

"""
[[0. 0. 0.]
 [0. 0. 0.]]
구조 :  (2, 3)
차원 :  2
원소형식 :  float64
"""

 

함수로 표현

def view_arr_info(arr):
  print(arr)
  print("구조 : ", arr.shape)
  print("차원 : ", arr.ndim)
  print("원소형식 : ", arr.dtype)

 

함수사용

#3차원배열,int형
z_arr = np.zeros((3,2,4), dtype=int)
view_arr_info(z_arr)


"""
[[[0 0 0 0]
  [0 0 0 0]]

 [[0 0 0 0]
  [0 0 0 0]]

 [[0 0 0 0]
  [0 0 0 0]]]
구조 :  (3, 2, 4)
차원 :  3
원소형식 :  int64
"""

o_arr = np.ones(10)  #배열의 모든 요소가 1로 구성된것
view_arr_info(o_arr)

"""
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
구조 :  (10,)
차원 :  1
원소형식 :  float64
"""

#인자로 받는 값만큼 1씩 증가하는 1차원 배열 만든다.
s_arr = np.arange(50, 100)
view_arr_info(s_arr)

"""
[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]
구조 :  (50,)
차원 :  1
원소형식 :  int64
"""

r_arr = np.random.randint(0,100,size=10,dtype=int)
view_arr_info(r_arr)
#랜덤으로 받는 것도 가능하다.

a1 = np.arange(1,100)
view_arr_info(a1)
[ 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]
 
 """
구조 :  (99,)
차원 :  1
원소형식 :  int64
"""

print(a1[4]) #배열 인덱스로 접근
a1[4] = 9
print(a1[4])

""
5
9
""

#리스트로 자르기 가능
print(a1[2:8])
print(a1[:8])
print(a1[8:])

"""
[3 4 9 6 7 8]
[1 2 3 4 9 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]
 """

 

a1=np.arange(0,100)
view_arr_info(a1)
a2=a1.reshape(5,20)
view_arr_info(a2)

"""
[ 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,)
차원 :  1
원소형식 :  int64
------------------------------------------------------------------
[[ 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]]
구조 :  (5, 20)
차원 :  2
원소형식 :  int64
"""

 

reshape

구조를 변경할 수도 있다.

a1=np.arange(100) #a1 생성
view_arr_info(a1)

"""
[ 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,)
차원 :  1
원소형식 :  int64
"""

a4=a1.reshape((5,2,5,-1)) #a4에 a1 구조변경
view_arr_info(a4)


(5,2,5,-1) : (행,열,차원,행의 정수만큼 행이 생성되어서 자동으로 구조화 => 알아서 배열)
"""
[[[[ 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]]]]
"""