불굴의관돌로그

Numpy에서는 배열에 적용되는 다양한 함수가 있다. 

다만,

단일 배열과 다중 배열에 사용되는 함수가 각각 다르므로 따로 정리해보자.

단일 배열에 적용되는 함수

우선 이차원 배열을 생성하자.

single_arr=np.random.randn(11,4)
single_arr

array([[-0.85420188,  0.42498577, -1.21781935, -2.469909  ],
       [-0.95437149,  0.84229281, -0.58423631,  0.16811405],
       [ 0.41291648, -0.60213293,  0.44054662,  0.00754592],
       [-0.49192662, -1.22210946,  1.82552474,  1.00134016],
       [-1.06566936,  0.74219896, -0.47628828, -0.5175951 ],
       [-0.0755429 ,  0.79078645,  0.95086558, -1.86214404],
       [ 1.50346299, -0.52695526, -0.28902625, -0.82038604],
       [ 0.81427752, -0.74730953,  0.64814457, -0.94949558],
       [ 0.70329552,  0.37535518, -0.43012094,  1.0470845 ],
       [-0.2881095 , -0.98918133, -1.76115028,  1.28901781],
       [ 1.37016394,  0.88699756,  0.43978861,  0.65941833]])

np.abs()

각 성분(요소)마다 절댓값 처리

np.abs(single_arr)

array([[0.85420188, 0.42498577, 1.21781935, 2.469909  ],
       [0.95437149, 0.84229281, 0.58423631, 0.16811405],
       [0.41291648, 0.60213293, 0.44054662, 0.00754592],
       [0.49192662, 1.22210946, 1.82552474, 1.00134016],
       [1.06566936, 0.74219896, 0.47628828, 0.5175951 ],
       [0.0755429 , 0.79078645, 0.95086558, 1.86214404],
       [1.50346299, 0.52695526, 0.28902625, 0.82038604],
       [0.81427752, 0.74730953, 0.64814457, 0.94949558],
       [0.70329552, 0.37535518, 0.43012094, 1.0470845 ],
       [0.2881095 , 0.98918133, 1.76115028, 1.28901781],
       [1.37016394, 0.88699756, 0.43978861, 0.65941833]])

np.sqrt()

제곱근 처리

np.sqrt(single_arr)

array([[       nan, 0.65190932,        nan,        nan],
       [       nan, 0.91776512,        nan, 0.41001713],
       [0.64258577,        nan, 0.66373686, 0.08686725],
       [       nan,        nan, 1.35111981, 1.00066986],
       [       nan, 0.8615097 ,        nan,        nan],
       [       nan, 0.88926174, 0.97512337,        nan],
       [1.22615782,        nan,        nan,        nan],
       [0.90237327,        nan, 0.80507426,        nan],
       [0.83862717, 0.61266237,        nan, 1.02327147],
       [       nan,        nan,        nan, 1.1353492 ],
       [1.17054002, 0.94180548, 0.66316559, 0.81204577]])

np.square()

제곱 처리

np.square(single_arr)

array([[7.29660856e-01, 1.80612901e-01, 1.48308397e+00, 6.10045049e+00],
       [9.10824947e-01, 7.09457185e-01, 3.41332063e-01, 2.82623330e-02],
       [1.70500017e-01, 3.62564070e-01, 1.94081323e-01, 5.69408884e-05],
       [2.41991798e-01, 1.49355153e+00, 3.33254059e+00, 1.00268211e+00],
       [1.13565117e+00, 5.50859302e-01, 2.26850526e-01, 2.67904688e-01],
       [5.70672981e-03, 6.25343204e-01, 9.04145352e-01, 3.46758044e+00],
       [2.26040097e+00, 2.77681849e-01, 8.35361732e-02, 6.73033254e-01],
       [6.63047882e-01, 5.58471536e-01, 4.20091384e-01, 9.01541857e-01],
       [4.94624593e-01, 1.40891513e-01, 1.85004022e-01, 1.09638595e+00],
       [8.30070859e-02, 9.78479713e-01, 3.10165031e+00, 1.66156692e+00],
       [1.87734923e+00, 7.86764671e-01, 1.93414018e-01, 4.34832532e-01]])

np.exp()

각 성분을 exponential의 지수로 삼은 값 계산한다.

np.exp(single_arr)

array([[0.42562275, 1.52956865, 0.29587466, 0.08459256],
       [0.38505408, 2.32168407, 0.55753148, 1.18307153],
       [1.5112188 , 0.5476423 , 1.55355619, 1.00757446],
       [0.61144723, 0.29460805, 6.20605075, 2.7219272 ],
       [0.34449719, 2.10054947, 0.62108441, 0.59595203],
       [0.92723995, 2.20512996, 2.58794877, 0.15533922],
       [4.49723603, 0.59039985, 0.74899254, 0.44026166],
       [2.25754406, 0.47363915, 1.91198997, 0.38693615],
       [2.02040002, 1.45550829, 0.65043043, 2.84933177],
       [0.7496795 , 0.37188101, 0.17184708, 3.62922023],
       [3.93599591, 2.42782929, 1.55237902, 1.93366725]])

np.log(), np.log10(), np.log2()

각 성분을 밑을 지정해 로그처리한다.

단, 밑이 자연로그, 상용로그, 2 만 가능하다.

np.log(single_arr)

array([[            nan, -8.55699603e-01,             nan,
                    nan],
       [            nan, -1.71627565e-01,             nan,
        -1.78311268e+00],
       [-8.84509941e-01,             nan, -8.19739009e-01,
        -4.88674844e+00],
       [            nan,             nan,  6.01867476e-01,
         1.33926199e-03],
       [            nan, -2.98137927e-01,             nan,
                    nan],
       [            nan, -2.34727327e-01, -5.03825721e-02,
                    nan],
       [ 4.07771109e-01,             nan,             nan,
                    nan],
       [-2.05454035e-01,             nan, -4.33641505e-01,
                    nan],
       [-3.51978101e-01, -9.79882548e-01,             nan,
         4.60096339e-02],
       [            nan,             nan,             nan,
         2.53880542e-01],
       [ 3.14930398e-01, -1.19913048e-01, -8.21461109e-01,
        -4.16397153e-01]])

np.log10(single_arr)

array([[            nan, -3.71625616e-01,             nan,
                    nan],
       [            nan, -7.45369044e-02,             nan,
        -7.74395996e-01],
       [-3.84137787e-01,             nan, -3.56008128e-01,
        -2.12228788e+00],
       [            nan,             nan,  2.61387724e-01,
         5.81634093e-04],
       [            nan, -1.29479656e-01,             nan,
                    nan],
       [            nan, -1.01940783e-01, -2.18808730e-02,
                    nan],
       [ 1.77092743e-01,             nan,             nan,
                    nan],
       [-8.92275539e-02,             nan, -1.88328113e-01,
                    nan],
       [-1.52862147e-01, -4.25557584e-01,             nan,
         1.99817301e-02],
       [            nan,             nan,             nan,
         1.10258919e-01],
       [ 1.36772534e-01, -5.20775749e-02, -3.56756027e-01,
        -1.80838986e-01]])

np.log2(single_arr)

array([[            nan, -1.23451357e+00,             nan,
                    nan],
       [            nan, -2.47606237e-01,             nan,
        -2.57248781e+00],
       [-1.27607811e+00,             nan, -1.18263340e+00,
        -7.05008774e+00],
       [            nan,             nan,  8.68311223e-01,
         1.93214663e-03],
       [            nan, -4.30122108e-01,             nan,
                    nan],
       [            nan, -3.38639951e-01, -7.26866869e-02,
                    nan],
       [ 5.88289357e-01,             nan,             nan,
                    nan],
       [-2.96407518e-01,             nan, -6.25612449e-01,
                    nan],
       [-5.07797062e-01, -1.41367169e+00,             nan,
         6.63778706e-02],
       [            nan,             nan,             nan,
         3.66272199e-01],
       [ 4.54348523e-01, -1.72997959e-01, -1.18511787e+00,
        -6.00734107e-01]])

np.sign()

각 성분(요소)의 부호 계산한다.

양수인 경우 1, 음수인 경우, -1, 0인 경우 0을 반환한다.

np.sign(single_arr)

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

np.ceil()

각 성분의 소수 첫 번째 자리에서 반올림 값 계산한다.

np.ceil(single_arr)

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

np.floor()

각 성분의 소수 첫 번째 자리에서 반내림한 값 계산한다.

np.floor(single_arr)

array([[-1.,  0., -2., -3.],
       [-1.,  0., -1.,  0.],
       [ 0., -1.,  0.,  0.],
       [-1., -2.,  1.,  1.],
       [-2.,  0., -1., -1.],
       [-1.,  0.,  0., -2.],
       [ 1., -1., -1., -1.],
       [ 0., -1.,  0., -1.],
       [ 0.,  0., -1.,  1.],
       [-1., -1., -2.,  1.],
       [ 1.,  0.,  0.,  0.]])

np.isnan()

각 성분이 결측치(NaN)인 경우 True, 아닌 경우 False를 반환한다.

np.isnan(np.log(single_arr))

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

np.isinf()

각 성분이 무한대인 경우 True를, 아닌 경우 False를 반환한다.

np.isinf(np.square(single_arr))

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

np.cos(),np.tan(),np.sin()

각 성분에 대해 삼각함수 값을 계산해준다. 

cos, cosh, sin, sinh, tan, tanh

np.sin(single_arr)

array([[-0.75404694,  0.41230781, -0.93834775, -0.62230479],
       [-0.81595055,  0.74617153, -0.55156252,  0.16732328],
       [ 0.40128239, -0.56640157,  0.42643396,  0.00754585],
       [-0.47232493, -0.93982217,  0.96773177,  0.84219432],
       [-0.87511304,  0.67591015, -0.45848373, -0.49479168],
       [-0.07547107,  0.71090659,  0.81391869, -0.95785762],
       [ 0.99773397, -0.50290398, -0.285019  , -0.73140914],
       [ 0.72722988, -0.67966771,  0.60370829, -0.81312199],
       [ 0.64673474,  0.36660301, -0.41698073,  0.86596887],
       [-0.28414016, -0.83557651, -0.98193733,  0.96056242],
       [ 0.97994075,  0.77517848,  0.4257482 ,  0.61265723]])

np.cos(single_arr)

array([[ 0.65682054,  0.9110446 ,  0.34569277, -0.78277503],
       [ 0.5781217 ,  0.66575374,  0.83413355,  0.98590208],
       [ 0.91595439,  0.82412939,  0.9045187 ,  0.99997153],
       [ 0.88142451,  0.34166399, -0.2519826 ,  0.53917412],
       [ 0.48391856,  0.73698404,  0.8887028 ,  0.86901162],
       [ 0.99714799,  0.70328644,  0.5809788 , -0.28724341],
       [ 0.06728247,  0.86434228,  0.95852187,  0.68193891],
       [ 0.68639398,  0.73352015,  0.79720531,  0.58209332],
       [ 0.762715  ,  0.93037747,  0.90891533,  0.5000979 ],
       [ 0.95878275,  0.5493741 , -0.18920647,  0.27806446],
       [ 0.19928907,  0.6317423 ,  0.90484168,  0.79034873]])

np.tan(single_arr)

array([[-1.14802582e+00,  4.52566003e-01, -2.71439794e+00,
         7.94998259e-01],
       [-1.41138197e+00,  1.12079209e+00, -6.61240061e-01,
         1.69715924e-01],
       [ 4.38103027e-01, -6.87272628e-01,  4.71448467e-01,
         7.54606189e-03],
       [-5.35865442e-01, -2.75072059e+00, -3.84047063e+00,
         1.56200807e+00],
       [-1.80838908e+00,  9.17129963e-01, -5.15902193e-01,
        -5.69372924e-01],
       [-7.56869302e-02,  1.01083505e+00,  1.40094389e+00,
         3.33465487e+00],
       [ 1.48290337e+01, -5.81834292e-01, -2.97352632e-01,
        -1.07254350e+00],
       [ 1.05949339e+00, -9.26583562e-01,  7.57280817e-01,
        -1.39689284e+00],
       [ 8.47937613e-01,  3.94036848e-01, -4.58767408e-01,
         1.73159868e+00],
       [-2.96355099e-01, -1.52096086e+00,  5.18976617e+00,
         3.45445948e+00],
       [ 4.91718257e+00,  1.22704856e+00,  4.70522307e-01,
         7.75173299e-01]])

두 개의 배열에 적용되는 함수

우선 두개의 배열을 생성하자.

single_arr

array([[-0.85420188,  0.42498577, -1.21781935, -2.469909  ],
       [-0.95437149,  0.84229281, -0.58423631,  0.16811405],
       [ 0.41291648, -0.60213293,  0.44054662,  0.00754592],
       [-0.49192662, -1.22210946,  1.82552474,  1.00134016],
       [-1.06566936,  0.74219896, -0.47628828, -0.5175951 ],
       [-0.0755429 ,  0.79078645,  0.95086558, -1.86214404],
       [ 1.50346299, -0.52695526, -0.28902625, -0.82038604],
       [ 0.81427752, -0.74730953,  0.64814457, -0.94949558],
       [ 0.70329552,  0.37535518, -0.43012094,  1.0470845 ],
       [-0.2881095 , -0.98918133, -1.76115028,  1.28901781],
       [ 1.37016394,  0.88699756,  0.43978861,  0.65941833]])
       
double_arr=np.random.rand(11,4)
double_arr

array([[0.48705458, 0.9637593 , 0.6738098 , 0.6541084 ],
       [0.61583841, 0.39743118, 0.55485998, 0.93706706],
       [0.0448264 , 0.88860695, 0.38479569, 0.45587065],
       [0.65356226, 0.73741626, 0.28991024, 0.59693486],
       [0.81154215, 0.91903639, 0.98248847, 0.08662736],
       [0.53407128, 0.55608402, 0.71851739, 0.29082239],
       [0.35009501, 0.99887153, 0.4568631 , 0.95589646],
       [0.30591951, 0.3999088 , 0.61395523, 0.38426602],
       [0.20310461, 0.53358661, 0.81670187, 0.7676948 ],
       [0.07961264, 0.57528379, 0.92982623, 0.99493861],
       [0.6184389 , 0.14453175, 0.68750759, 0.66940273]])

np.add(),np.substract(),np.multiply(),np.divide()

위 함수들은 동일한 shape일때 사칙연산을 해주는 함수들이다.

간단하게 multiply만 예로하고 넘어가겠다.

np.multiply(single_arr,double_arr)

array([[-0.41604294,  0.40958398, -0.82057861, -1.61558823],
       [-0.58773863,  0.33475342, -0.32416935,  0.15753414],
       [ 0.01850956, -0.53505951,  0.16952044,  0.00343996],
       [-0.32150467, -0.90120339,  0.52923832,  0.59773485],
       [-0.8648356 ,  0.68210786, -0.46794774, -0.0448379 ],
       [-0.04034529,  0.43974371,  0.68321346, -0.54155318],
       [ 0.52635489, -0.52636061, -0.13204543, -0.78420411],
       [ 0.24910338, -0.29885566,  0.39793175, -0.36485889],
       [ 0.14284257,  0.2002845 , -0.35128057,  0.80384132],
       [-0.02293716, -0.56905999, -1.63756373,  1.28249359],
       [ 0.84736269,  0.12819931,  0.30235801,  0.44141643]])

np.maximum(),np.minimum()

각 shape의 성분끼리 최대 최소값을 비교하여 하나의 배열로 만들어준다.

np.maximum(single_arr,double_arr)

array([[0.48705458, 0.9637593 , 0.6738098 , 0.6541084 ],
       [0.61583841, 0.84229281, 0.55485998, 0.93706706],
       [0.41291648, 0.88860695, 0.44054662, 0.45587065],
       [0.65356226, 0.73741626, 1.82552474, 1.00134016],
       [0.81154215, 0.91903639, 0.98248847, 0.08662736],
       [0.53407128, 0.79078645, 0.95086558, 0.29082239],
       [1.50346299, 0.99887153, 0.4568631 , 0.95589646],
       [0.81427752, 0.3999088 , 0.64814457, 0.38426602],
       [0.70329552, 0.53358661, 0.81670187, 1.0470845 ],
       [0.07961264, 0.57528379, 0.92982623, 1.28901781],
       [1.37016394, 0.88699756, 0.68750759, 0.66940273]])

Statistic Function

통계 함수를 통해 array의 합이나 평균등을 구할 때, axis라는 인자에 대한 값을 지정해주어 열 또는 행의 합 또는 평균등을 구할 수 있다.

single_arr

array([[-0.85420188,  0.42498577, -1.21781935, -2.469909  ],
       [-0.95437149,  0.84229281, -0.58423631,  0.16811405],
       [ 0.41291648, -0.60213293,  0.44054662,  0.00754592],
       [-0.49192662, -1.22210946,  1.82552474,  1.00134016],
       [-1.06566936,  0.74219896, -0.47628828, -0.5175951 ],
       [-0.0755429 ,  0.79078645,  0.95086558, -1.86214404],
       [ 1.50346299, -0.52695526, -0.28902625, -0.82038604],
       [ 0.81427752, -0.74730953,  0.64814457, -0.94949558],
       [ 0.70329552,  0.37535518, -0.43012094,  1.0470845 ],
       [-0.2881095 , -0.98918133, -1.76115028,  1.28901781],
       [ 1.37016394,  0.88699756,  0.43978861,  0.65941833]])

np.sum()

전체 성분의 합을 계산해준다.

np.sum(single_arr)

-1.8515573809143309

axis=0 : 행별 전체 합을 계산해준다.

np.sum(single_arr,axis=0)

array([ 1.0742947 , -0.02507179, -0.45377129, -2.447009  ])

aixs=1 : 열별 전체 합을 계산해준다.

np.sum(single_arr,axis=1)

array([-4.11694447, -0.52820094,  0.25887608,  1.11282882, -1.31735377,
       -0.19603492, -0.13290456, -0.23438302,  1.69561427, -1.74942331,
        3.35636844])

np.mean()

평균을 계산해준다.

np.mean(single_arr,axis=0)

array([ 0.09766315, -0.00227925, -0.04125194, -0.22245536])

np.std(),np.var(),np.min(),np.max()

표준편차,분산,최대 최소를 구해준다.

np.std(single_arr)

0.9683579692373014

np.min(single_arr,axis=1)

array([-2.469909  , -0.95437149, -0.60213293, -1.22210946, -1.06566936,
       -1.86214404, -0.82038604, -0.94949558, -0.43012094, -1.76115028,
        0.43978861])

np.argmin(),np.agrmax()

전체 성분의 최소값, 최대값이 위치한 인덱스를 반환.

np.argmin(single_arr)

3

np.argmax(single_arr,axis=1)

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

np.cumsum(), np.cumprod()

처음 성분부터 각 성분까지의 누적합 또는 누적곱을 계산해준다.

np.cumsum(single_arr)

array([-0.85420188, -0.42921612, -1.64703547, -4.11694447, -5.07131596,
       -4.22902315, -4.81325946, -4.64514541, -4.23222893, -4.83436187,
       -4.39381525, -4.38626933, -4.87819595, -6.10030541, -4.27478067,
       -3.27344051, -4.33910986, -3.5969109 , -4.07319918, -4.59079428,
       -4.66633718, -3.87555073, -2.92468515, -4.78682919, -3.2833662 ,
       -3.81032147, -4.09934772, -4.91973375, -4.10545623, -4.85276576,
       -4.20462119, -5.15411677, -4.45082125, -4.07546607, -4.50558701,
       -3.45850251, -3.74661201, -4.73579335, -6.49694363, -5.20792582,
       -3.83776188, -2.95076432, -2.51097571, -1.85155738])

np.cumprod(single_arr)

array([-8.54201882e-01, -3.63023641e-01,  4.42097215e-01, -1.09193989e+00,
        1.04211631e+00,  8.77767075e-01, -5.12823395e-01, -8.62128166e-02,
       -3.55986925e-02,  2.14351452e-02,  9.44318071e-03,  7.12574735e-05,
       -3.50534480e-05,  4.28391504e-05,  7.82039290e-05,  7.83087347e-05,
       -8.34512188e-05, -6.19374081e-05,  2.95000616e-05, -1.52690873e-05,
        1.15347114e-06,  9.12149347e-07,  8.67331419e-07, -1.61509603e-06,
       -2.42823712e-06,  1.27957233e-06, -3.69829992e-07,  3.03403362e-07,
        2.47054538e-07, -1.84626211e-07, -1.19664476e-07,  1.13620891e-07,
        7.99090642e-08,  2.99942814e-08, -1.29011685e-08, -1.35086135e-08,
        3.89195992e-09, -3.84985411e-09,  6.78017165e-09,  8.73976203e-09,
        1.19749068e-08,  1.06217131e-08,  4.67130840e-09,  3.08034638e-09])

np.sort()

전체 성분에 대해서 정렬해준다.

오름차순

np.sort(single_arr)

array([[-2.469909  , -1.21781935, -0.85420188,  0.42498577],
       [-0.95437149, -0.58423631,  0.16811405,  0.84229281],
       [-0.60213293,  0.00754592,  0.41291648,  0.44054662],
       [-1.22210946, -0.49192662,  1.00134016,  1.82552474],
       [-1.06566936, -0.5175951 , -0.47628828,  0.74219896],
       [-1.86214404, -0.0755429 ,  0.79078645,  0.95086558],
       [-0.82038604, -0.52695526, -0.28902625,  1.50346299],
       [-0.94949558, -0.74730953,  0.64814457,  0.81427752],
       [-0.43012094,  0.37535518,  0.70329552,  1.0470845 ],
       [-1.76115028, -0.98918133, -0.2881095 ,  1.28901781],
       [ 0.43978861,  0.65941833,  0.88699756,  1.37016394]])

내림차순

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

array([[ 0.43978861,  0.65941833,  0.88699756,  1.37016394],
       [-1.76115028, -0.98918133, -0.2881095 ,  1.28901781],
       [-0.43012094,  0.37535518,  0.70329552,  1.0470845 ],
       [-0.94949558, -0.74730953,  0.64814457,  0.81427752],
       [-0.82038604, -0.52695526, -0.28902625,  1.50346299],
       [-1.86214404, -0.0755429 ,  0.79078645,  0.95086558],
       [-1.06566936, -0.5175951 , -0.47628828,  0.74219896],
       [-1.22210946, -0.49192662,  1.00134016,  1.82552474],
       [-0.60213293,  0.00754592,  0.41291648,  0.44054662],
       [-0.95437149, -0.58423631,  0.16811405,  0.84229281],
       [-2.469909  , -1.21781935, -0.85420188,  0.42498577]])

행 방향으로 오룸차순

np.sort(single_arr,axis=0)

array([[-1.06566936, -1.22210946, -1.76115028, -2.469909  ],
       [-0.95437149, -0.98918133, -1.21781935, -1.86214404],
       [-0.85420188, -0.74730953, -0.58423631, -0.94949558],
       [-0.49192662, -0.60213293, -0.47628828, -0.82038604],
       [-0.2881095 , -0.52695526, -0.43012094, -0.5175951 ],
       [-0.0755429 ,  0.37535518, -0.28902625,  0.00754592],
       [ 0.41291648,  0.42498577,  0.43978861,  0.16811405],
       [ 0.70329552,  0.74219896,  0.44054662,  0.65941833],
       [ 0.81427752,  0.79078645,  0.64814457,  1.00134016],
       [ 1.37016394,  0.84229281,  0.95086558,  1.0470845 ],
       [ 1.50346299,  0.88699756,  1.82552474,  1.28901781]])

앞서 이용한 다차원 인덱싱을 응용하여 boolean 인덱싱을 할 수 있다.

주로 mask라고 얘기하는데, boolean 인덱싱을 통해 만들어낸 배열을 통해 원하는 행 또는 열의 값만 뽑아낼 수 있다.

즉, mask처럼 가리고 싶은 부분은 가리고 원하는 요소는 꺼낼 수 있다.

예를 살펴보자.

names=np.array(['kwan','lee','kyunh','koo','bae','yu','hyeong','ho','min','song','jin'])
names

array(['kwan', 'lee', 'kyunh', 'koo', 'bae', 'yu', 'hyeong', 'ho', 'min',
       'song', 'jin'], dtype='<U6')

names.shape
(11,)

문자열 배열을 생성하고,

ran_num=np.random.randn(11,4)
ran_num

array([[-0.59103603,  0.82348054, -0.29187746, -0.22239091],
       [-0.8100299 ,  0.84844129, -0.89056272, -0.56269183],
       [ 1.03756042, -1.27040716, -0.14321331, -1.29123492],
       [ 0.39628204, -1.18455294, -1.11007655, -0.25026466],
       [ 0.74178116, -1.39881718,  1.45385185,  1.7651273 ],
       [ 0.5388867 , -1.33991598,  0.82725191, -0.95091188],
       [ 1.77272678,  0.95240797, -0.94997094, -1.02506259],
       [-2.10105478, -0.47656731, -0.86786481, -1.54414126],
       [ 1.18391322, -0.82079135,  1.5303018 , -1.20934383],
       [-2.05976446, -2.59316339, -0.65387812,  0.52717579],
       [-0.48744984,  0.66963489,  0.69548501, -0.9389433 ]])
       
ran_num.shape

(11, 4)

숫자형 이차원 배열을 생성해준다.

np.random.randn() 함수는 기대값이 0, 표준편차가 1인 정규 분포를 따르는 난수 생성 함수이다.

np.random.rand() 함수는 0~1의 난수를 생성해주는 함수이다.

이제, names배열의 각 요소가 ran_num의 각 행과 연결된다고 가정해보자. 그렇기에 행을 맞춰 난수를 생성한 것이다.

이때, names가 'kwan'인 행의 요소들만 보고 싶을때 마스크를 사용한다.

names_kwan_mask=(names=='kwan')
names_kwan_mask

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

위는 요소가 'kwan'인 항목에 대한 mask를 생성한 것이다.

ran_num[names_kwan_mask,:]

array([[-0.59103603,  0.82348054, -0.29187746, -0.22239091]])

위 결과를 보면 'kwan'인 요소를 꺼내온다.

이를 위해 요소가 'kwan'인 것에 대한 boolean 값을 가지는 mask를 만들었고 마스크를 인덱싱에 응용하여 'ran_num'의 0행을 꺼냇다.

ran_num[names=='koo',:]

array([[ 0.39628204, -1.18455294, -1.11007655, -0.25026466]])

위는 요소가 'koo'인 행의 데이터만 꺼내온다.

ran_num[(names=='koo')|(names=='kwan'),:]

array([[-0.59103603,  0.82348054, -0.29187746, -0.22239091],
       [ 0.39628204, -1.18455294, -1.11007655, -0.25026466]])

위는 'names'의 요소가 'koo' or(|) 'kwan'인 행의 데이터만 꺼내온다.

물론 ran_num 배열 자체적으로도 마스크를 만들고, 이를 응용한 인덱싱이 가능하다. 

ran_num 배열에서 0번째 열의 값이 0보다 작은 행을 구해보자.

먼저 마스크를 만들어보자.

ran_num[:,0]<0

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

위에서 만든 마스크를 이용해 0번째 열의 값이 0보다 작은 행을 구해보자.

ran_num[ran_num[:,0]<0,2:4]

array([[-0.29187746, -0.22239091],
       [-0.89056272, -0.56269183],
       [-0.86786481, -1.54414126],
       [-0.65387812,  0.52717579],
       [ 0.69548501, -0.9389433 ]])

다른 예로 0번째 열의 값이 0보다 작은 행의 2,3번째 열 값을 구해보자.

ran_num[ran_num[:,0]<0,2:4]=0
ran_num

array([[-0.59103603,  0.82348054,  0.        ,  0.        ],
       [-0.8100299 ,  0.84844129,  0.        ,  0.        ],
       [ 1.03756042, -1.27040716, -0.14321331, -1.29123492],
       [ 0.39628204, -1.18455294, -1.11007655, -0.25026466],
       [ 0.74178116, -1.39881718,  1.45385185,  1.7651273 ],
       [ 0.5388867 , -1.33991598,  0.82725191, -0.95091188],
       [ 1.77272678,  0.95240797, -0.94997094, -1.02506259],
       [-2.10105478, -0.47656731,  0.        ,  0.        ],
       [ 1.18391322, -0.82079135,  1.5303018 , -1.20934383],
       [-2.05976446, -2.59316339,  0.        ,  0.        ],
       [-0.48744984,  0.66963489,  0.        ,  0.        ]])

ML,DL에서도 masking이라는 개념이 있고, 위 boolean masking을 다시한번 공부하며 느낀 것이지만 아직도 쓰임이 어디에 잘 쓰이는지를 깨닫지는 못했다....;;

numpy에서 사용되는 인덱싱은 기본적으로 python 인덱싱과 동일하다.

이때, python에서와 같이 1번째로 시작하는 것이 아닌 0번째로 시작하는 것에 주의하자.

np_arr1=np.arange(10)
np_arr1

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

넘파이 배열을 생성했으니 반복문을 써서 처음부터 끝까지 인덱스를 호출해보자.

for index in range(len(np_arr1)):
    print(np_arr1[index], np_arr1)
    
0 [0 1 2 3 4 5 6 7 8 9]
1 [0 1 2 3 4 5 6 7 8 9]
2 [0 1 2 3 4 5 6 7 8 9]
3 [0 1 2 3 4 5 6 7 8 9]
4 [0 1 2 3 4 5 6 7 8 9]
5 [0 1 2 3 4 5 6 7 8 9]
6 [0 1 2 3 4 5 6 7 8 9]
7 [0 1 2 3 4 5 6 7 8 9]
8 [0 1 2 3 4 5 6 7 8 9]
9 [0 1 2 3 4 5 6 7 8 9]

직접 인덱스를 슬라이싱해보자.

np_arr1[3:5]

array([3, 4])

지정 인덱스부터 ':' 끝날 인덱스 라고 생각하는게 ':' 와 관련해서는 이해하기 좋다.

np_arr1[:]

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

단순히 ':' 만 적는다면 전체를 출력해준다.

여기서 주의할점은 이는 1차원 배열에서 사용되는 법이다. 

2차원 배열일때를 살펴보자.

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

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

np_arr2[0,1]
2

np_arr2[2,:]
array([ 9, 10, 11, 12])

np_arr2[2,2]
11

다음과 같이 2차원 배열에서 인덱싱을 하기 위해서는 2개의 인자를 입력해야 한다.

기본적으로 numpy에서 연산을 할때 크기가 서로 동일한 배열(Array)끼리 연산이 진행된다.

다음 예를 살펴보자.

우선 두개의 배열을 생성하자.

np_arr1=np.array([[1,2,3],[3,4,5]])
print(np_arr1)
print(np_arr1.shape)
np_arr2=np.array([[10,11,12],[12,13,14]])
print(np_arr2)
print(np_arr2.shape)

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

[[10 11 12]
 [12 13 14]]

(2, 3)

덧셈

np_arr1+np_arr2

array([[11, 13, 15],
       [15, 17, 19]])

뺄셈

np_arr1-np_arr2

array([[-9, -9, -9],
       [-9, -9, -9]])

곱셈

np_arr1*np_arr2

array([[10, 22, 36],
       [36, 52, 70]])

나눗셈

np_arr1/np_arr2

array([[0.1       , 0.18181818, 0.25      ],
       [0.25      , 0.30769231, 0.35714286]])

브로드캐스트(BroadCast)

위에서는 배열(Array)가 같은 크기를 가져야 서로 연산이 가능하다고 했다.

하지만 넘파이에서는 브로드캐스트라는 기능을 제공해준다.

브로드캐스트란 서로 크기가 다른 array가 연산이 가능하게끔 하는 것이다.

print(np_arr1)
print(np_arr1.shape)

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

np_arr3=np.array([10,11,12])
print(np_arr3)
print(np_arr3.shape)

[10 11 12]
(3,)

#덧셈 broadcast
np_arr1+np_arr3

array([[11, 13, 15],
       [13, 15, 17]])

#뺄셈 broadcast
np_arr1-np_arr3

array([[-9, -9, -9],
       [-7, -7, -7]])

#곱셈 boradcast
np_arr1*np_arr3

array([[10, 22, 36],
       [30, 44, 60]])
       
#나눗셈 broadcast
np_arr1/np_arr3

array([[0.1       , 0.18181818, 0.25      ],
       [0.3       , 0.36363636, 0.41666667]])

위와 같이 서로 shape가 다른 np_arr1,np_arr3의 연산이 가능하다.

위 결과를 살펴보면 np_arr3이 [10,11,12]에서 [[10,11,12],[10,11,12]]로 확장되어 계산됨을 확인할 수 있다.

또한 배열(Array)에 스칼라 연산도 가능하다.

np_arr1*10

array([[10, 20, 30],
       [30, 40, 50]])
       
np_arr1**10

array([[      1,    1024,   59049],
       [  59049, 1048576, 9765625]], dtype=int32)

Numpy에서 array를 정의할 때 사용되는 함수들이다. 

np.zeros()

np.zeros()함수는 인자로 받는 크기만큼 모든 요소가 0인 배열(Array)을 만든다.

np.zeros(10)

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

10을 인자로 받아 10개의 요소 0인 배열 생성

np.zeros((3,5))

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

(3,5)를 인자로 받아 3 by 5인 이차원 배열을 요소 0으로 만든다.

np.ones()

np.ones()함수는 인자로 받는 크기만큼, 모든 요소가 1인 배열(Array)을 만든다.

np.ones(9)

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

9를 인자로 받아 9개의 요소 1인 배열 생성

np.ones((3,5))

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

(3,5)를 인자로 받아 3 by 5인 이차원 배열을 요소 1로 만든다.

np.arange(10)

np.arange() 함수는 인자로 받는 값 만큼 1씩 증가하는 1차원 배열(Array)을 만든다. 

np.arange(10)

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

하나의 인자만 입력하면 0부터 입력한 인자까지 값만큼 받는다.

np.arange(3,10)

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

두개의 인자를 입력하면 첫 인자(3)부터 마지막 인자(10)까지의 배열을 생성한다.

머신러닝과 딥러닝에서 위 함수는 어떻게 쓰일까?

앞선 np.ones()와 np.zeros()는 레이블을 지정해줄 수 있다. 0혹은 1로

또한, 인덱스를 추가할경우를 생각해보면 반복문을 통해 데이터에 인덱스를 부여하는 것은 비효율적이다.

차라리 np.arange(data_len)을 통해 한번에 인덱스를 배열에 추가한다음 데이터프레임으로 옮겨주는게 더 효과적일 것이다.

Numpy란

Numpy는 C언어를 기반으로 구현된 파이썬 라이브러리로써, 고성능 수치계산을 위해 제작되었다.

Numerical Python의 줄임말이기도 한 Numpy는 벡터 및 행렬 연산에 있어 매우 편리한 기능을 제공해준다.

Numpy는 기본적으로 배열(Array)로 데이터를 관리하며 이에 대해 연산을 수행한다. 

코딩을 통해 살펴보자.

#numpy 모듈 불러오기
import numpy
#단축어로 불러오기
import numpy as np

위는 기본적인 내용이므로 생략.

#Array 정의 및 사용

data_1=[1,2,3,4,5]
data_2=[1,2,3,4,4.5,6,7]
print(data_1,data_2)

[1, 2, 3, 4, 5] [1, 2, 3, 4, 4.5, 6, 7]

단순히 배열을 생성한다.

#numpy를 이용한 array 정의
#단순 리스트 numpy array로 사용
np_arr1=np.array(data_1)
print(np_arr1)
#array의 형태(크기)를 확인하는 메서드.
print(np_arr1.shape)

[1 2 3 4 5]
(5,)

넘파이에서의 형태출력은 보통 이차원 배열로 출력해준다. 그렇기에 (5,)으로 출력된다.

#직접 numpy array 선언
np_arr2=np.array([1,2,3,4,5])
print(np_arr2)
#array의 형태(크기)를 확인하는 메서드.
print(np_arr2.shape)
#array의 자료형 확인 메서드.(dtype: datatype 약자)
print(np_arr2.dtype)

[1 2 3 4 5]
(5,)
int32

dtype를 통해 integer임을 확인할 수 있다.

np_arr3=np.array(data_2)
print(np_arr3)
print(np_arr3.dtype)

[1.  2.  3.  4.  4.5 6.  7. ]
float64

dtype을 통해 float을 확인할 수 있다.

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

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

이차원 배열을 정의한 후, 형태까지 확인해본 결과이다. 

numpy shape

numpy에서는 해당 array의 크기를 알 수 있다.

shape 을 확인함으로써 몇개의 데이터가 있는지, 몇 차원으로 존재하는지 등을 확인할 수 있다.

위에서 arr1.shape의 결과는 (5,) 으로써, 1차원의 데이터이며 총 5라는 크기를 갖고 있음을 알 수 있다.

arr4.shape의 결과는 (4,3) 으로써, 2차원의 데이터이며 4 * 3 크기를 갖고 있는 array 이다.

numpy 자료형

arr1이나 arr2는 int64라는 자료형을 갖는 것에 반해 arr3는 float64라는 자료형을 갖는다.

이는 arr3내부 데이터를 살펴보면 3.5라는 실수형 데이터를 갖기 때문임을 알 수 있다.

numpy에서 사용되는 자료형은 아래와 같다. (자료형 뒤에 붙는 숫자는 몇 비트 크기인지를 의미한다.)

• 부호가 있는 정수 int(8, 16, 32, 64)
• 부호가 없는 정수 uint(8 ,16, 32, 54)
• 실수 float(16, 32, 64, 128)
• 복소수 complex(64, 128, 256)
• 불리언 bool
• 문자열 string_
• 파이썬 오프젝트 object
• 유니코드 unicode_

배열(Array)의 특징

-같은 자료형을 가진 변수를 하나로 나타낸 것이다.

-연속된 메모리 공간으로 이루어져있다.

-정적 표현이다.

-인덱스를 이용하여 표현한다.

-지역성을 갖고 있다.

배열(Array)의 장점

-인덱스를 통한 검색이 용이하다.

-연속적이므로 메모리 관리가 편하다.

배열(Array)의 단점

-한 데이터를 삭제하더라도 배열은 연속해야 하므로 공간이 남는다. 즉 메모리 낭비를 한다.

-정적이므로 배열의 크기를 컴파일 이전에 정의해주어야 한다.

-컴파일 이후 배열의 크기를 변동 할 수 없다.

리스트(List)의 특징

-순서가 있는 데이터의 집합이다.

-불연속적으로 메모리 공간을 차지한다.

-동적표현이다.

-인덱스가 없다.

-포인터를 통한 접근을 한다.

리스트의 장점

-포인터를 통하여 다음 데이터의 위치를 가리키고 있어 Insert, Delete에 용이하다.

-동적이므로 크기가 정해져 있지 않다.

-메모리의 재사용이 편리하다.

-불연속적이므로 메모리 관리의 편리하다.

리스트의 단점

-검색 성능이 좋지 않다.

-포인터를 통해 다음 데이터를 가르키므로 추가적인 메모리 공간이 발생한다.

흔히 이는 C언어에서 많이 정의하는 내용이다. 하지만 파이썬은 List를 배열이라고 부른다.

이것은 단순한 용어의 혼동에 불과하다. 보통, 컴퓨터 공학에서 리스트는 위의 섹션에서 말한 리스트를 의미한다. 하지만 파이썬에서는 리스트라는 용어를 다르게 사용한다.

파이썬을 공부하면서 알아야 할 점 중 하나는 다음과 같다: 파이썬에서 리스트가 어떻게 작동하는지 내부를 들여다 보면, 파이썬의 리스트는 배열처럼 구현이 되어있다는 것이다 (여기서 처럼이라는 표현을 쓴 이유는 정확하게 말하자면 Dynamic Array이기 때문이다). 구체적으로 말하자면, 파이썬 리스트의 아이템들은 메모리 상의 연속적인 위치에 배치되며, 인덱스를 사용하여 접근이 가능하다.

내부를 들여다 보면, 파이썬의 리스트는 좀 더 많은 기능을 담고있다. 예를 들어, 리스트에 아이템을 추가하고 제거하는 append와 pop과 같은 메서드를 가지고 있다. 이런 메소드를 사용하여, 우리는 파이썬의 리스트를 스택처럼 활용할 수 있다.

기본적으로 자료구조를 공부할 때, pop이나 append와 같은 부가적인 메소드들의 사용은 지양해야한다. 이것들은 high-level 프로그래밍 언어의 기능일 뿐이며, 다른 언어에서는 지원하지 않는 경우도 있기 때문이다. 특정 언어와 관계없이 자료구조를 익히기 위해, 파이썬에서는 리스트를 단순 배열로만 생각하는 것이 좋다 (자료구조 공부할 때!).

정리해보자면:

• 파이썬의 리스트의 근본은 배열이지만, high-level한 기능들이 추가되어 있다.
• 자료구조를 공부할 때 파이썬의 리스트를 단순 배열로 취급한다.