불굴의관돌로그

텍스트형태의 데이터에서 원하는 html 요소에 어떻게 접근할 수 있을까?

이를 쉽게 해결할 수 있게 도와주는 라이브러리가 있다.

이는 BeautifulSoup이며, 날 것의 html을 의미있는 객체로 만들어서 사용자가 원하는 데이터를 가져올 수 있게 만들어준다.

BeautifulSoup4 설치

!pip install beautifulsoup4

BeautifulSoup 사용법

import requests
from bs4 import BeautifulSoup

url='https://kin.naver.com/search/list.nhn?query=%ED%8C%8C%EC%9D%B4%EC%8D%AC'

response=requests.get(url)

if(response.status_code==200:
	html=response.text
    soup=BeautifulSoup(html,'html.parser')
    print(soup)
    
else:
	print(response.status_code)

네이버 지식인에 파이썬을 검색한 url이다. 응답코드가 200일때 html을 받아와 soup객체로 변환한다.

네이버 지식인 크롤링 예제

네이버 지식인에 '파이썬'을 검색하면 첫 번째로 나오는 제목을 가져오려면 어떻게 해야할까?

우선, "https://kin.naver.com/search/list.nhn?query=%ED%8C%8C%EC%9D%B4%EC%8D%AC" 다음 사이트로 이동해 F12버튼을 눌러보자.

요소를 찾기 위해서는 다음과 같은 방식을 따른다.

Ctrl+Shift+C 를 누르면 마우스 커서가 움직이는 곳의 element를 찾게 도와준다. 그 후 클릭을 하면 원하는 html의 element 정보를 오른쪽 창에서 보여준다.

찾은 html에 copy selector 기능을 이용해보자.

*copy X_path를 사용해도 상관없다.

html에 오른쪽 마우스를 클릭후 copy->copy selector를 선택해 준다.

이제 css selector가 복사되었고, 이를 코드에 적용해보자.

import requests
from bs4 import BeautifulSoup

url = 'https://kin.naver.com/search/list.nhn?query=%ED%8C%8C%EC%9D%B4%EC%8D%AC'

response = requests.get(url)

if response.status_code == 200:
    html = response.text
    soup = BeautifulSoup(html, 'html.parser')
    title = soup.select_one('#s_content > div.section > ul > li:nth-child(1) > dl > dt > a')
    print(title)
else : 
    print(response.status_code)
    

<a class="_nclicks:kin.txt _searchListTitleAnchor" href="https://kin.naver.com/qna/detail.nhn?d1id=8&amp;dirId=80101&amp;docId=362502659&amp;qb=7YyM7J207I2s&amp;enc=utf8§ion=kin&amp;rank=1&amp;search_sort=0&amp;spq=0" target="_blank"><b>파이썬</b>배우기 쉬운곳 찾아요!!</a>

select_one은 하나의 html element를 찾는 함수이다. css selector를 select_one함수의 인자로 넣어준다.

여기서 바로 soup.select_one().get_text()를 한다면 텍스트만 뽑아올 수 있다.

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한 기능들이 추가되어 있다.
• 자료구조를 공부할 때 파이썬의 리스트를 단순 배열로 취급한다.

판다스의 apply() 메서드의 기본 문법은 다음과 같다.

apply() 메서드는 pandas 객체에 열 혹은 행에 대해 함수를 적용하게 해주는 메서드이다.

DataFrame.apply(func,axis=0,raw=False,result_type=None,args=(),**kwds)

*func: 이 입력변수는 pandas 객체의 열이나 행에 적용할 함수를 입력받는다.

*axis:함수를 적용할 축을 지정한다.

 -Series에 적용할 경우에는 axis를 따로 지정해주지 않는다.

 -0 or 'index' 

  example) DataFrame.apply(func,axis=0),  DataFrame.apply(func,axis='index')

  :함수를 각 열(columns)에 따라 적용한다.

 -1 or 'index'

  example) 위와 동일

  :함수를 각 행(row)에 따라 적용한다.

*agrs: func에 입력되는 위치 입력변수를 입력받는다. 즉, iterable한 자료형을 입력받는다. (list,tuple등)

*kwds: func에 입력되는 키워드 입력변수를 입력받는다. ->키워드에 입력될 입력값의 mapping을 입력받는다.

우선 데이터프레임을 간단하게 만들어보자.

import pandas as pd
import numpy as np

df=pd.DataFrame([[4,9]]*3,columns=['A','B'])
df

df.apply(np.sqrt)

위 코드처럼 단순히 apply()메서드에 func를 지정하면 각 Series로 처리가 된다. 즉 Series에서도 셀 당 처리를 해준다.

df.apply(np.sum,axis=0)

A    12
B    27
dtype: int64

axis=0으로 지정해 주었을 경우, 위 정의처럼 각 column에 따라 적용한다. 

그러므로, A 와 B column에 대하여 전체 합을 처리해준다.

df.apply(np.sum,axis=1)

0    13
1    13
2    13
dtype: int64

axis=1로 지정해 주었을 경우, 위 정의처럼 각 row에 따라 적용한다.

그러므로 index별로 전체 합을 처리해준다.

lambda 함수를 적용한 응용 apply()

다음 예를 확인해보자.

df.apply(lambda x: [1,2],axis=1)

0    [1, 2]
1    [1, 2]
2    [1, 2]
dtype: object

위 코드를 살펴보면 lambda함수를 사용해 [1,2] 리스트 형식을 axis=1이라는 조건을 통해 각 row에 적용시킨다.

그러면 위 결과와 같이 Series의 결과를 얻게 된다.

df.apply(lambda x:[1,2],axis=1,result_type='expand')

위 코드를 살펴보면 lambda함수를 사용해 [1,2]의 리스트를, axis=1이라는 조건을 통해 각 row에 적용 시키는데, 위 예제와 다른점은 result_type='expand' 조건을 추가 적용했다. 

result_type = 'expand'를 전달하면 목록과 유사한 결과가 데이터 프레임의 열로 확장된다.

그러므로 column_name은 0과 1(default)로 지정되고 각 data만 expand(확장)된것을 확인할 수 있다.

df.apply(lambda x:pd.Series([1,2],index=['foo','bar']),axis=1)

위 코드를 살펴보면 lambda함수를 통해 각 [1,2]로 되어있는 시리즈를 생성하고, index=['foo','bar']을 지정해준다. 추가로 axis=1을 지정해 줌으로써 각 row에 적용시키는데 위와 같은 결과를 얻을 수 있다.

df.apply(lambda x:[1,2],axis=1,result_type='broadcast')

위 코드를 살펴보면 lambda 함수를 통해 리스트형식인 [1,2]를, axis=1을 지정해줌으로써, 각 row에 삽입해준다.

추가로 result_type = 'broadcast'를 전달하면 함수가 목록 형이든 스칼라이든 상관없이 동일한 모양 결과를 보장하고 축을 따라 브로드 캐스트한다. 결과 열 이름은 원본이된다.

*result_type이란 앞서 조건이라고 말했지만 명확히 정의하자면 매개변수(parameter)이다.

{'expand','reduce','broadcast','None'} 종류가 있으며 axis=1 즉, row에만 적용 가능하다. 

이전 포스팅에서 판다스 자료구조인 Series에 대해 알아보았다. 이번에는 DataFrame(데이터프레임)에 대해 알아보자.

시리즈가 엑셀의 한 열과 동일한 이해구조를 본다면, 데이터프레임은 그 열을 merge한 엑셀 시트라고 볼 수 있다.

컴퓨터 공학도에게는 DB를 알기에 데이터베이스와 동일하다고도 볼 수 있다.

DataFrame의 정의:

DataFrame(데이터프레임)은 numpy의 ndArray를 기반으로 한 행과 열로 이루어진 자료구조이다.

판다스 데이터프레임 속성은 다음과 같다.

데이터프레임 생성법부터 알아보자.

생성법은 크게 3가지가 있다. list를 이용한 생성, Dictionary를 이용한 생성, Series를 이용한 생성

각각 한번 알아보자.

list를 이용한 생성법.

이 list생성도 두가지로 분류 할 수 있다. 1자원 리스트와 멀티 리스트로 볼 수 있다.

-1차원 리스트

single_list=['a','b,','c','d']
df=pd.DataFrame(single_list)
df


	0
0	a
1	b
2	c
3	d

본인도 데이터를 다루며 이런식의 데이터프레임은 잘 사용하지 않으므로 설명은 생략하겠다.

-멀티 리스트

multi_list=[['kwandoll',27],['suuuuuk',27],['heeeee',30]]
df=pd.DataFrame(multi_list)
df


0	1
0	kwandoll 27
1	suuuuuk	27
2	heeeee	30

위 리스트를 이용한 생성을 보면 칼럼들에 대한 변수명은 0 과 1이다. 만일 dimension을 늘리면 늘릴수록 칼럼명은 0,1,2,3,4~~~식으로 간다는 건데, 일반적으로 이해하는게 어렵다.

그렇기에, 카럼명을 지정해줘야 한다.

multi_list=[[['kwandoll',27],['suuuuuk',27]],[['heeeee',30]]]
df=pd.DataFrame(multi_list,columns=['name','age'])
df


name	age
0	kwandoll 27
1	suuuuuk	27
2	heeeee	30

이러한 작업을 피하기 위해, 본인은 파이썬에 꽃인 Dictionary자료구조를 제일 많이 사용한다. 실제 데이터 분석을 할경우 같은 의미를 뽑아야하는 경우가 있으며, 데이터프레임 내에 처리가 안될 경우에는 value들을 직접 뽑아서 처리하고 DataFrame에 다시 저장하는 경우가 비일비재하다. 그러므로 이번에 설명하는 Dictionary를 이용한 생성을 유심히 보길 바란다.

Dictionary를 이용한 생성

딕셔너리 자료구조로 생성할때 두가지가 있다. 단순 Dictionary로 생성하기, Dictionary로 구성된 리스트로 생성하기.

우선 단순 Dictionary로 생성하는 법을 알아보자.

-단순 Dictionary로 생성

Dictionary.keys()는 column명을 생성하고, Dictionary.values()는 data역할을 한다.

단, 각 딕셔너리의 길이는 동일해야한다. 

data={'lee':[1,2,3],'kwan':[2,3,4],'doll':[3,4,5]}
df=pd.DataFrame(data)
df


	lee	kwan	doll
0	1	2	3
1	2	3	4
2	3	4	5

그럼 만일 dictionary.values()의 길이가 다르다면 어떨까

data={'lee':[1,2,3],'kwan':[2,3],'doll':[3,4,5]}
df=pd.DataFrame(data)
df

ValueError: arrays must all be same length

다음과같은 에러가 뜬다. 즉 이말은 values에 있는 리스트의 길이는 동일해야한다는 뜻이다.

다음은 Dictionary로 구성된 리스트로 생성하는 법을 알아보자.

-Dictionary로 구성된 리스트 생성

data=[{'lee':1,'kwan':2},{'lee':3,'doll':4},{'king':5,'laa':6}]
df=pd.DataFrame(data)
df

	lee	kwan	doll	king	laa
0	1.0	2.0	NaN	NaN	NaN
1	3.0	NaN	4.0	NaN	NaN
2	NaN	NaN	NaN	5.0	6.0

data=[]에 들어있는 리스트의 순서대로 각 인덱스가 인덱스로, 즉, dict1, dict2, dict3이 각각 0,1,2가 되는것이다.

또한 Dictionary.keys()는 column명으로, dictionary.values()는 data로 저장된다. 또한, 비어있는 부분은 모두 NaN값으로 처리한다.

여기서 만약 인덱스와 칼럼명을 지정해준다면 다음과 같이 변형된다.

data=[{'lee':1,'kwan':2},{'lee':3,'doll':4},{'king':5,'laa':6}]
df_1=pd.DataFrame(data,index=['zero','first','second'],columns=['lee','kwan','doll','king','laa'])
df_1

	lee	kwan	doll	king	laa
zero	1.0	2.0	NaN	NaN	NaN
first	3.0	NaN	4.0	NaN	NaN
second	NaN	NaN	NaN	5.0	6.0

위 데이터에서 key인 'lee'는 value를 2개 갖고있다. 그러므로 이것이 데이터프레임으로 처리할때는 순서대로 저장되는 것이다.

마지막으로 Sereis를 이용한 생성을 살펴보자.

Series를 이용한 생성

앞선 포스트처럼 시리즈는 액셀의 한 열이다. 그렇다면? 병합한다는 개념을 생각해보자.

series 또한 생성할때 리스트로 생성하는 법과 딕셔너리로 생성하는 법이 있었다. 

두가지를 각각 살펴보자.

-리스트로 생성된 Series를 이용한 생성

a=pd.Series([11,22,33],['a','b','c'])
b=pd.Series([44,55,66],['d','e','f'])
c=pd.Series([77,88,99],['i','j','k'])
df=pd.DataFrame([a,b,c])
df

	a	b	c	d	e	f	i	j	k
0	11.0	22.0	33.0	NaN	NaN	NaN	NaN	NaN	NaN
1	NaN	NaN	NaN	44.0	55.0	66.0	NaN	NaN	NaN
2	NaN	NaN	NaN	NaN	NaN	NaN	77.0	88.0	99.0

어떤 형식인지 이해해보자. 각 시리즈는 이차원 리스트로 되어있으며, Data와 Column으로 구성되어있다.

즉 이것을 모두 병합하여 처리를한다면, 위 결고와 같이 각각의 Column명으로 구성된 abcdefijk와 각각의 

데이터로 구성된 11,22,33,44,55,66,77,88,99로 된다. 

만일 예를들어, a라는 칼럼이 중복되어 11,33으로 되어있다면, a칼럼의 0번째 인덱스는 11,1번째 인덱스는 33으로 되는 것이다.

-딕셔너리로 생성된 Series를 이용한 생성

example={'lee':pd.Series([85,180],['weight','height']),'park':pd.Series([52,168],['weight','height'])}
df=pd.DataFrame(example)
df


	lee	park
weight	85	52
height	180	168

위 코드를 살펴보면 'lee'라는 칼럼명에는 시리즈 첫번째 리스트에 있는 값들이 그 다음에 지정해놓은 인덱스로 각각 처리되어 저장되는 모습이다. 실제 이런 것들은 직접 코딩을 해보고 눈으로 확인을 해봐야한다.

지금까지 크게 3가지로 구성된 자료구조로 어떻게 데이터프레임을 만들지는 상황마다 다르며 각자 쓰는 방법마다 다르다. 그러므로 이 세가지를 잘 숙지하는 것도 데이터를 다루는 능력에 절반은 차지할것이라고 생각한다(개인적 생각).

판다스는 소프트웨어 라이브러리 용으로 작성된 파이썬 프로그래밍 언어 데이터 조작 및 분석을 위한 패키지라고 볼 수 있다. 특히, 수치표와 시계열을 조작하기위한 데이터 구조와 연산을 제공해준다. 

판다스의 Series

판다스의 시리즈를 이해하기에 앞서 우리가 자주 접하는 엑셀을 한번 생각해보자. 

엑셀은 칼럽이 있고, 열들이 있다. 그 구조를 이해한 상태에서 시리즈를 직관적으로 이해한다면, 시트의 열 하나를 떠올리면된다. 

시리즈의 속성은 index와 values가 있다. 이는 아래 예시를 통해 한번 확인해보자.

시리즈를 생성하는 방법은 list형식, dictionary형식이 있다. 

우선 list형식으로 생성해보자.

example1=pd.Series(["undead","Kwandoll","JJang"])
example1

0      undead
1    Kwandoll
2       JJang
dtype: object

그 다음은 dictionary형식으로 생성해보자.

example2=pd.Series({"undead":33,"Kwandoll":22,"JJang":11})
example2

undead      33
Kwandoll    22
JJang       11
dtype: int64

차이점은 무엇일까?

1. 리스트 형식과 딕셔너리 형식의 생성 기호는 다르다. 즉 리스트는 [] 딕셔너리는 {} 이다. 이는 파이썬 기본을 공부한다면 누구나 아는 얘기지만, 모를수도 있기에 적어본다.

2. 인덱스가 다르다. 즉, 리스트형식으로 생성한다면 인덱스라인에 있는 숫자는 리스트 원래 인덱스넘버가 그대로 생성된다. 반대로 딕셔너리로 생성을 한다면, key,value형태이기에 key가 인덱스 value가 value로 들어가는 것이다.

이 차이를 정확하게 집어가야지만 데이터프레임을 이해하고, 그 데이터프레임을 다룰때 정확하게 처리할 수 있다.

시리즈 인덱싱

example1['undead']
33
example2[1]
'kwandoll'

말로 설명하는 것보다 예시가 이해에 더 빠르기에, 이렇게 작성해본다. 

해석) example1이라는 Series자료구조에서 인덱스가 'undead'인 value를 출력하라. 결과) 33

해석) example2라는 Series자료구조에서 인덱스가 1인 value를 출력하라. 결과) kwandoll

과연 실무에서 전공자가 아닌 비전공자가 분석 내용을 확인하는 방법중에 가장 효과적인 방법은 무엇일까?

바로 그래프이다. 그래프를 통해 알기 어려운 insight를 한눈에 알아차릴 수 있다. 하지만, 그 과정을 만들어 잘 보여지게 하는게 analysist 의 일이다.

시작 데이터는 항상 연습용으로 사용하는 리뷰데이터를 통해 시작하겠다. 이유는 간단하다. 전처리 하기에도 가장 훌륭한 연습용 데이터이기 때문이다.

먼저 필요한 라이브러리 함수를 불러온다.

import numpy as np
import pandas as pd
from konlpy.tag import Okt
from collections import Counter
import re
from konlpy.tag import Twitter
from pykospacing import spacing
import matplotlib.pyplot as plt

twitter=Twitter()
data=pd.read_csv('c:/data/thisweek_selected_classified.csv')
stopwords = ['도', '는', '다', '의', '가', '이', '은', '한', '에', '하', '고', '을', '를', '인', '듯', '과', '와', '네', '들', '듯', '지', '임', '게','요','거','로','으로',
            '것','수','할','하는','제','에서','그','데','번','해도','죠','된','건',
             '바','구','세','랑','시','저','만']

data는 작성일전으로부터 1주일 데이터를 크롤링한 데이터이다. 한번 데이터를 확인해보자.

데이터는 10개만 확인해본다.

data=pd.read_csv('c:/data/thisweek_selected_classified.csv')
data[:10]

본인이 생각하기에 실무자가 아닌 일반 비전공자들은 이 데이터르 보면 '아 1주일데이터가 이렇구나'까지이다. 우리의 임무는 어떤 방식으로 어떻게 상대방에게 결과 즉, insight를 꺼내주면 된다.

content 칼럼의 리뷰 문장들을 한번 간단하게라도 전처리 및 토큰화를 해보자.

twitter=Twitter()
data=pd.read_csv('c:/data/thisweek_selected_classified.csv')
#불용어 단어
stopwords = ['도', '는', '다', '의', '가', '이', '은', '한', '에', '하', '고', '을', '를', '인', '듯', '과', '와', '네', '들', '듯', '지', '임', '게','요','거','로','으로',
            '것','수','할','하는','제','에서','그','데','번','해도','죠','된','건',
             '바','구','세','랑','시','저','만']

#단어의 길이가 2개 이상인 경우만 선택 및 저장
data['content']=data['content'].str.replace('[^ㄱ-ㅎㅏ-ㅣ|가-힣]','') #전처리 
data['tokenized']=data['content'].apply(twitter.morphs) #명사마나ㅏ 토큰화
data['tokenized']=data['tokenized'].apply(lambda x: [item for item in x if item not in stopwords])
#불용어 처리
x=data['tokenized']
for line in x:
    for word in line:
        if len(word)<2:
            line.remove(word)
data['tokenized']=x 

*참고) Twitter 전처리 라이브러리는 Konlpy에서 만든 것인데, KoNLPy v0.4.5 버전 이후로는 Okt 전처리 라이브러리와 통합되었다.

아직까지 Konlpy에서 만든 토큰화 라이브러리는 단어가 조금만 오타가 나도 오류를 범하기에 가장 빠르게 할 수 있는 방법은 단어 길이가 1인 경우는 지워주는 것이다. 본인 기준이다.... 

다시 데이터 10개를 확인해보면 잘 처리가 되었다. 이후 우리는 numpy에서 제공하는 단어 카운트 라이브러리를 사용할 것이다. 

우선 긍정 및 부정으로 나누어 주고, 각 부분 별 단어의 빈도 최고 10개를 확인해 보자.

negative_count=np.hstack(data[data.grade<3]['tokenized'].values)
positive_count=np.hstack(data[data.grade>2]['tokenized'].values)
negative_word_count=Counter(negative_count)
positive_word_count=Counter(positive_count)

print(negative_word_count.most_common(10))
print(positive_word_count.most_common(10))

[('영상', 9), ('너무', 7), ('화면', 7), ('업데이트', 6), ('라이브', 6), ('버전', 6), ('기능', 5), ('따로', 4), ('채널', 4), ('계속', 3)]
[('영상', 12), ('브이', 8), ('너무', 7), ('기록', 5), ('삭제', 5), ('업데이트', 4), ('라이브', 4), ('까지', 4), ('설정', 4), ('좋은데', 3)]

긍정과 부정에 최빈 단어는 '영상' 이다. 수치로도 확인할 수 있지만, 본래 취지는 그래프를 통한 insight이기에 그래프로 확인해보자.

import matplotlib.font_manager as fm
def bar_plot(dict1,dict2):

    fl = fm.FontProperties(fname='c:/Windows/Fonts/malgun.ttf').get_name()
    plt.rc('font', family=fl)
    plt.bar(dict1.keys(), dict1.values(), color='b')
    plt.bar(dict2.keys(), dict2.values(), color='r')
    plt.legend()
    plt.title('Bar Chart')
    plt.show()
    
ne_data=dict(negative_word_count.most_common(10))
po_data=dict(positive_word_count.most_common(10))

bar_plot(po_data,ne_data)

위 그래프를보면 까지, 너무, 이런 단어들은 굳이 있을 필요가 없는 단어들이다. 그러므로 다시 불용어 처리를 하며 그래프를 더 정교화 시키면 된다. 연습용 데이터가 작기에 이 단어 빈도수가 작지만 데이터를 늘린다면 더 괜찮은 insight를 도출해 낼 수 있을 것이다. 

titanic_data.iloc[0][3]

'Braund, Mr. Owen Harris'

데이터는 Titanic 데이터를 확인해보자.

titanic_data=pd.read_csv("C:/data/titanic/train.csv")
titanic_data

이런식으로 나오는 형태가 데이터프레임이다. 칼럼 즉 변수는 총 12개가 있다. 초심자라고 부담스러워 하지마라. 곧 할것이다.

실제 데이터를 다루기 시작할 때 가장 많이 사용하는 것이 특정 칼럼(변수) 혹은 특정열을 선택해서 아니면 각각의 범위를 지정해서 보는것이다. 실제 Pandas에서 제공해 주는 함수에는 정말 많은 것이 있지만, 대표적인 것만 설명하겠다. 

iloc

titanic_data.iloc[0]

위 전체 데이터와 비교해보자. 0번째 인덱스에 있는 value들을 전부 가져온다.

-특정 변수에서 필요한 인덱스 값을 갖고 와보자.

titanic_data.iloc[0][3]

'Braund, Mr. Owen Harris'

titanic_data.iloc[0]['Name']

'Braund, Mr. Owen Harris'

iloc이란 행이든 열이든 숫자로 location을 나타내서 Selecting or indexing 하는 방법이다. 그러나 변수 명을 집어넣어도 상관없다.

해석해보자. 행렬로 설명한다. iloc[행][열] 방식이다. 즉,

나는 [0]번째 전체 행에서 [3] 번째 행을 선택해 보고싶다.

나는 [0]번째 전체 행에서 ['Name']변수에 위치한 값을 선택해 보고싶다.

같은 의미이다.

정확한 표현 방식 및 정리는 다음과 같다.

titanic.iloc[1] # titanic 1번째 인덱스의 행 선택 추출
titanic.iloc[-1] # titanic 마지막 인덱스의 행 선택 추출
titanic.iloc[:,1] # titanic 1번째 인덱스의 열 선택 추출
titanic.iloc[:,-1] # titanic 마지막 인덱스의 열 선택 추출



titanic.iloc[0:5] # 0번째부터 5번째 인덱스 행 선택 추출
titanic.iloc[:,0:5] #0번째부터 5번째 열까지 선택 추출


titanic.iloc[[0,5,24],[1,4,7]] # 0,5,24 인덱스의 행과 1,4,7인덱스의 행 선택 추출

주의할점. 

-어떤 방식으로 내가 행과 열을 selection&extraction 하느냐에 따라 그 output structure은  데이터프레임이 될 수 있고 시리즈 형식이 될 수 있다.

-또한 인덱스라는 의미로 주석표기한 이유는 기본 파이썬 언어 인덱스는 0부터이다. 번째로 주석표기한다면 index+1을 해야하기에 혼동을 야기할 수 있으므로 인덱스로 표기한다.

iloc은 요즘 잘 사용하지 않는다고 한다. 하지만 코딩을 활용한 분석에서의 코딩은 내가 원하는 방식으로 이끌어가도 괜찮다고 생각한다.

Pandas 데이터 분석을 시작하려면 무조건, 필수로 import 해야되는 라이브러리. 내가 공부하는게 아니라 누군가를 알려줘야 한다고 생각할때, 과연 어떤 방식으로 쉽게 설명을 해줄까...하다가 우선 데이터프레임을 이해하기 전에 어떤식으로 코딩을 하는지를 먼저 알려주는게 나을 것 같다. 바로 시작해보자.

import pandas as pd 
import numpy as np
import matplotlib.pyplot as plt

본인은 초심자들을 위한 내용을 제공할 것이기에, 어느정도 숙련도가 있는 분석가들은 과감하게 나가 주길 바란다.

-import [main_library] as [value] 즉, padas라이브러리를 가져올건데 나는 이걸 사용하기 위해 pd로 줄여서 쓸거야 왜냐면 귀찮거든 이라는 의미다. 좀더 추가로 설명하자면 pd를 ks 로 바꿔 설정해도 상관없다.

-근데 왜 이렇게 해야하는가.. 지금 시작할 튜토리얼과 연관성이 있다.

padas.DataFrame(~~)
pd.DataFrame(~~)

호출라이브러리.호출라이브러리기능 순이다. 즉 pandas를 하면 귀찮다! 

<다시 본론으로...>

그래서 결국 pandas에서 DataFrame이란 무엇이냐... 통계분석 언어 중 하나인 R이 있다. 온전히 통계 분석을 위해 개발된 R 과는 다르게 python은 일반 프로그램언어이다. 그러므로 데이터 분석을 하기 위해서는 여러가지 라이브러리를 사용할 수 밖에 없는 것이다. 이 패키지들 중 R의 dataframe 데이터 타입을 참고하여 만든 것이 바로 pandas dataframe이다. pandas는 dataframe을 주로 다루기 위한 라이브러리이며, dataframe을 자유롭게 가공하는 것은 데이터 분석가들에게 중요하다. 

우리가 데이터를 다루려면 파이썬 자료구조인 리스트, 튜플, 딕셔너리와 같은 것을 써야하는데 자유자재로 변경 및 처리가 가능하다면, 데이터프레임이 굳이 필요 없을지도..?

우리가 데이터 분석을 하게 된다면 직접 데이터를 만들지 않는다. csv 및 excel 등에 저장되어있는 데이터를 받아오는데 요즘 웹 블로그에서는 만드는 것부터 설명을 해준다. 본인은 생략한다.

불러오자

csv_data=pd.read_csv("C:/data/파일이름.csv")
excel_data=pd.read_excel("C:/data/파일이름.xlsx")

*여담으로 경로 찾아줄 때 절대경로에 저장해있으면 파일이름만 적으면 되지만 다른 경로에 저장되어있다면 위치도 적어주자.

*파일경로 적을때 \\ or /  두가지이다. 백슬래시(\) 하나로는 인식을 못하는게 함정이다.

*불러왔으면 이제 어떤식으로 건드려봐야할지는 다음장에 설명하겠다.