우아 한의원 | 조재성 원장의 한의학, 의학통계, 프로그래밍

기준열의 문자형데티어 범주확인 –> 빈 딕셔너리{ }생성-> 중복없는 기준열 변수 생성 –>  for문 안에서, 마스크로 중복없는 기준열의 각 성분에 따른 특정열만 뽑고, 가상으로만들어진 nx1의 총합 계산후 변수에 담기 –>  각 성분을 딕셔너리[ 열이름]으로 인덱싱하여 딕셔너리의 키값으로 생성  =  우항에 키값에 대한 총합 변수 대입으로 밸류값 생성 –> 생성된 { 키값1:밸류값1 , 키값2:밸류값2 }의 밸류값이 1개로 구성된 1xn 1차원 딕션너리를 1차원인 Series에 담기

=> 기준열의 일부성분들을 가진 행들을 골라내어 그 행들의 특정열 분포 확인하기
헤더확인-> 범주 확인후 중복없는 기준열 변수(total category)생성 -> 일부성분만 index로 열 인덱싱한 일부성분기준열 변수 생성(bad category) -> 전체기준열에 isin( 일부성분기준열)을 통해, 마스크생성한 것을 새로운 열로 추가( df[ 새로운 마스크 열 ]) -> 행인덱스에 마스크==True를 통해 행들을 골라낸 후, 열인덱스에 특정열만 골라내어, 가사의 nx1의 Series획득한 상태에서 .value_counts()를 입혀 Series[ 특정열값 - 행 수 ]의 변수(bad_to_grade) 생성 -> Series를 오름차순 정렬 -> good category를 원하면 마스크 ==False로 구함

상관관계 분석하기 :
기준열. corr( 특정열 )

파일쓰기 : to_csv()

파일 읽기(csv)

이전 numpy의 파일 읽는 방법을 복습해보자.
data = np.loadtxt("data/movielens-1m/ratings.dat", delimiter = "::", dtype = np.int64)
np.savetxt("mean_rating_by_user.csv", mean_rating_by_user_array, fmt='%.3f', delimiter=',')

pandas에서 파일을 읽는 방법은, pd.read_csv()함수를 사용하여 –> DataFrame으로 자동으로 가져온다.
인자에는 간단하게  “파일경로”와  구분자를 sep = “,” 를 지정해준다.
파일 경로는 홈화면에서 파일을 따라간 뒤, 주소창에 있는 것을 복사해오면 간단하다.
이 때, dtype오류가 나서 마지막 인자 dtype = ‘unicode’를 붙혀줬더니 정상적으로 가져와졌다.

data = pd.read_csv("data/lending-club-loan-data/loan.csv", sep="," ,  dtype='unicode')

데이터를 가져오는데 시간이 걸려서 난 오류라고한다. 무시하고 dtype안붙혀줘도 된다.
data = pd.read_csv("data/lending-club-loan-data/loan.csv", sep=",")

- 자료는 lengding-club에서 제공해주는 대출정보다.

DataFrame 분석해보기

1. **** csv – > dataFrame으로 가져왔으면 처음으로 해야할 일은, shape와 몇 행의 데이터를 살펴보는 것이다.
   먼저 shape를 보자.  data.shape
   
   shape를 보니, 행이 88만개 / 열이 74개 이다.
2. 이제 열을 구체적으로  보기 위해서,  data.columns를 확인한다. 너무 많으므로, 우리에게 유의미한 것만 가져와 써야한다.
   
   
• loan_amnt: 대출자의 대출 총액
• loan_status: 대출의 현재 상태*
• grade: LC assigned loan grade**
• int_rate: 대출 이자율
• term: 대출 상품의 기간 (36-month vs. 60-month)
  
  
3. 필요한 열만 떼어네서, 새로운 DataFrame 변수에 넣어보자. 여러 칼럼을 인덱싱할 때, 리스트의 형태로 넣어줘야한다.
   “loan_amnt”, “loan_status”, “grade”, “int_rate”, “term” 열만 가져온다.
   
4. shape를 파악했으면 이제 앞, 뒤 5개행만 볼 수 있는 df2.head()함수 df2.tail()함수로 확인한다.
   
5. 데이터를 보고, loan_amnt , int_rate에는 숫자정보 / loan_status, grade, term에는 문자열 정보가 있는 것을 확인한다.
   (shape->필요한 열만 뽑아내기–> head/tail –> 각 열의 데이터타입 눈으로 확인)
6. 문자열 정보를 가진 열(칼럼)에 대해서 데이터가 범주형인지 아닌지  .unique() 함수로 확인해야한다.
   
   (파일읽기–> shape-> columns확인–> 필요한 열만 뽑아내기–> head/tail –> 각 열의 데이터타입 눈확인 –> 문자열 데이터 범주확인)
7. 결측값(NaN)을 포함한 행들 제거시키기 위해서 .dropna(how=”any”)함수를 이용한다.
   만일 NaN가 존재하여 shape로 살펴봤는데, 행의 개수가 줄어들었으면, 뽑은 것으로 새로운 df를 만들어야할 것이다.
   
   (파일읽기–> shape-> columns확인–> 필요한 열만 뽑아내기–> head/tail –> 각 열의 데이터타입 눈확인 –> 문자열 데이터 범주확인 –> 결측값(NaN) 제거 후 shape확인)

즉, 어떤 csv파일을 받아서 DataFrame으로 받았을 때, 기본적인 분석은
파일읽기–> shape/head-> .columns확인–> 필요한 열만 뽑아낸 df 만들기–> head/tail –> 각 열의 데이터타입 눈확인 –> 문자열 데이터 범주확인 –> 결측값(NaN) 제거 후 shape확인
의 과정을 거쳐야한다.

데이터분석 1 – 대출기간(term)에 따른 대출총액(loan_amnt) 파악하기
[ 기준열: 범주형 문자열데이터 – 각 성분에 따른 특정열의 총합 각각 구해서 담기 ] : 각 성분에 따른 것은 for문에 들어갈 것임

해당자료에는 term에 문자열정보로서, 36개월 대출과 60개월 대출 2가지 범주가 존재한다.
여기서 term열의 2가지 데이터를 기준으로 –>  전체  대출 총액(loan_amnt)을 확인해보자.

1. 각 기간에 따른 대출총액의 합을 for문을 돌면서 하나씩 저장해줄 빈 딕션너리를 생성한다.(term_to_loan_amnt_dic)
2. term 열에 대해 중복없는기준열을 변수로 만든다. 36개월과 60개월이 나올 것이다. (uniq_terms)
   
3. 중복없는 기준열인(uniq_terms)가 for문안에서 하나씩(term)로 대입되면서 for반복문을 만든다. 이 때, term은 전체기준열 안에 있는 특정성분을 의미한다.
4. term열 중 특정성분으로 작용할 term으로 df[“term”]열에 대한 마스크를 만들고,
   그것을 df2.loc[]의 행 인덱스에 집어넣는다.(DataFrame에서 행과 렬을 동시에 인덱싱하는 loc만 가능),
   여기까지는 조건에 맞는 행들만 골라내진 상태이므로, 기준에 따라 불러오고 싶은 열을 인덱스로 준다. 즉, “loan_amnt” 열만 넣어준다.
   각, 특정term을 만족시키는 행(36또는 60개월)이 여러(n)개 있고 -> 불러온 “loan_amnt” 1개의 열이므로
   nx1의 dataFrame을 이룰것이다. (Series형태다. 1차원 nx1)
   예를 들어,
                   (term-열인덱싱x 생략됨)     “loan_amnt”
                 01행 –(  36 months )             3만원
                 32행 –(  36 months )             76만원
                 51행 –(  36 months )             21만원
   
   for문에 마스크로 행index에 집어넣어 원하는 행들을 뽑아내면 –> n행
   열index에 집어넣은 우리가 필요한 열이 1개면, n x 1 (Series형태)  / 2개면 n x 2 DataFrame형태
    
   이러한 n x 1  DataFrame을 .sum()함수로 모든 성분을 더하면 –> 36months에 대한 “loan_amnt”의 총액이 계산된다.
   그 값을 loan_amnt_sum 변수에 넣어준다. for문을 돌면, 36개월에 대한 대출총액 / 60개월에 대한 대출총액 2개가 담길것이다.
   
5. 이제 for문을 돌면서, 각 unique한 term마다, 대출총액을 모두 더한 loan_amnt_sum을
   1번에 만든 빈 딕셔너리(term _to_loan_amnt_dict)에 담을 것인데,
   각 조건성분인 term을 딕셔너리의 [열이름]형태로 열 인덱싱하여 새로운 열(키값)을 생성하면서 & 동시에 윗줄에서 계산된 모든 대출총액을 더한 값들을 대입하여 키값으로 만든다. 예를 들면, 36개월에 대한 대출금액 총합을 –> 딕셔너리의 키값에 대한 벨류값으로  넣을 것이다.
   
   (딕셔너리에다가 열인덱싱을 통해서 키값이 생성되고 = 우항이 밸류값이 된다)
   ( 10강 : 딕셔너리 { 키값 : [밸류1, 밸류2,] , 키값2 : [밸류3, 밸류4] } –>  DataFrame.columns : 키값, 키값2 , 행 갯수 : 리스트성분 수)
   for문을 돌면서 들어오는 term열의 특정성분(36 or 60)으로 하는 열인덱싱의 열이 –> { 키값 : }
   들어간 term마다 대출총액 – > {  : 밸류값} 이 될 것이다.
   
   
   

***9강 numpy의 데이터분석에서는  빈 리스트[]를 생성하고, for문을 돌면서, 거기다가 1차원임에도 불구하고,
리스트안에 다시[ 성분1, 성분2]의 리스트를 만들고 –> 리스트안에 [  [리스, 트] ]를 만들것을 np.array로 넣기만 하였더니
M x N으로 바로 사용할 수 있었다.

• for문을 돌면서 하나씩 받기 위해서  빈 딕셔너리를 만들고,  거기다가  { 키값 : 밸류 } 형태로 채웠던 것을,
  편하게 데이터를 관리하기 위해 1차원 딕셔너리( 1행(밸류 성분수) x n열(키값들)) –> Series에 담아준다.
  *** 딕셔너리 키값 수 = 열 수 , value리스트 수 = 행 수 였는데 지금 value값이 하나밖이므로, 행도 1개다.
  *** 행 1개 인 것이 바로, 1xn 의 1차원 Series다. 그래서 키값 = 열 수 가 아니라 1차원형태의 행 index가 된다.
  *** 즉, 다시 정리하자면,  딕셔너리 中{키값 : 밸류값}의 밸류가 1개 뿐인 것은 1차원 Series로 바꿀수 있으며, 키값=>index가 된다.
         만약 딕션너리가 키값 : [밸류1, 밸류2 .. ] 등 여러개가 되면, 키값=> 열 / 리스트성분의 수 => 행수인 DataFrame이 된다.
          my) Series는 인덱스를 인자로 주는 장점이 있다. 즉, 열은 없다. 시리즈로 전환되는 밸류1개의 딕셔너리에서 키값= 행index
  

=> 파일 읽고 기본적인 분석하기 :
파일읽기(.read_csv)–> shape/head-> .columns확인–> 필요한 열만 뽑아낸 df 만들기–> head/tail –> 각 열의 데이터타입 눈확인 –> 문자열 데이터 범주확인 –> 결측값(NaN) 제거 후 shape확인
=> 기준열에 특정성분 따른(term-2가지 문자열)  특정열의 합(loan_amnt 총합) 파악하기 :
기준열의 문자형데티어 범주확인 –> 빈 딕셔너리{ }생성-> 중복없는 기준열 변수 생성 –>  for문 안에서, 마스크로 중복없는 기준열의 각 성분에 따른 특정열만 뽑고, 가상으로만들어진 nx1의 총합 계산후 변수에 담기 –>  각 성분을 딕셔너리[ 열이름]으로 인덱싱하여 딕셔너리의 키값으로 생성  =  우항에 키값에 대한 총합 변수 대입으로 밸류값 생성 –> 생성된 { 키값1:밸류값1 , 키값2:밸류값2 }의 밸류값이 1개로 구성된 1xn 1차원 딕션너리를 1차원인 Series에 담기

데이터분석 2 – 대출상태(loan_status)중 불량상태에 해당하는 사람들의 대출등급(grade) 파악하기
[ 기준이 범주형 문자열데이터-> 일부성분만 떼내서 분류 –>  일부성분만 가진 행들에 대해 특정열 분포확인]  : 각 특정성분x-> for문 x

1. 분석에 앞서 기본적으로, 들고 있는 DataFrame의 head() 확인
   
2. 문자형데이터로 구성된 기준열의 범주 확인 –> 의미상 불량상태 / 우량상태를 확인할 수 있다.
   
3. 기준열을 중복없는 기준열 변수 생성 (total_status_category)
   
4. 기준열의 범주(2)를 바탕으로 –> 중복없는기준열(1차원 array)에 index를 사용한 인덱싱으로 특성성분들(불량상태) 만들기
   (1) 불량상태 (bad_status_category)  : bad_status_category = total_status_category[ [1,3,4,5,6,8 ] ]
   
5. 기준열.isin( 특정성분들)을 이용해서, 불량상태에 따른 기준열의 마스크를 만들어 df2에다가 새로운 열로 추가한다.
   df2[“bad_loan_status”] 열이 추가되었으면, head()로 새로운열을 확인한다.
   df2["bad_loan_status"] = df2["loan_status"].isin(bad_status_category)
   
   
   기준열 중에, bad_status_category라는 특정성분들을 가지고 있으면, 새로운열에는 True라고 표시가 된다.
6. 이제 bad_loan_status 열에 True(불량상태의 loan_status)를 가진 행들에 대해  grade의 분포를 살펴보기 위해,
   for문안에서 중복없는 기준열의 특정성분으로 마스크를 비교하는 것이 아니라,  for문 없이
   (1)불량상태를 기준으로 만든 열 마스크(bad_loan_status)==True를 행 index에 집어넣어, 행들을 골라내고
   (2) 그 행들에 대한 “grade”열만 가져온다. –>  골라낸 행들 x “grade”열 의   nx1 형태의 DataFrame이 가상으로 생긴다.
   
   
nx1의 dataFrame을 이룰것이다. (Series형태다. 1차원 nx1)
예를 들어,
                    (행인덱싱의 True)     “grade”
              01행 –(  True )                 B
              32행 –(  True  )                C
              51행 –(  True  )                 A

(3) 그렇게 뽑아낸 df에 value_counts() 함수를 사용하여, grade열의 각 성분들에 대한 행의 갯수가 Series의 형태로 얻어진다.
    그것을 새로운 변수 bad_loan_status_to_grades 에 담는다.



7. Series의 index(열은 없다)를 보기좋게 하기 위해, sort_index()함수로 오름차순으로 정렬해준다.
   
   
   
8. 대출상태가 우량상태인 경우를 뽑으려면, 불량상태와 정반대로만 하면된다. 즉, 마스크 == False로 뽑아내서 담아주면된다.

=> 기준열의 일부성분들을 가진 행들을 골라내어 그 행들의 특정열 분포 확인하기
헤더확인-> 범주 확인후 중복없는 기준열 변수(total category)생성 -> 일부성분만 index로 열 인덱싱한 일부성분기준열 변수 생성(bad category) -> 전체기준열에 isin( 일부성분기준열)을 통해, 마스크생성한 것을 새로운 열로 추가( df[ 새로운 마스크 열 ]) -> 행인덱스에 마스크==True를 통해 행들을 골라낸 후, 열인덱스에 특정열만 골라내어, 가사의 nx1의 Series획득한 상태에서 .value_counts()를 입혀 Series[ 특정열값 - 행 수 ]의 변수(bad_to_grade) 생성 -> Series를 오름차순 정렬 -> good category를 원하면 마스크 ==False로 구함

데이터분석 3 – 대출총액(loan_status)과 대출이자율(int_rate) 간의 상관관계 분석 [ 숫자-숫자 데이터]

분석하기 앞서, 정리된 데이터의 head()를 살펴본다.

1. 기준열인 df2[“loan_amnt”]과 .corr ( 비교열  df2[“int_rate”]  )함수를 통해 상관계수를 뽑아낸다.
   
   *** 문자형정보를 가진 열을 비교하면 먹통이 된다.
   
   

상관관계 분석하기 :
기준열. corr( 특정열 )

파일 쓰기

파일 읽기는 : data = pd.read_csv("data/lending-club-loan-data/loan.csv", sep="," ) 였다.

bad_loan_status_to_grades 에 정리된 자료를 .to_csv()를 호출하면서
첫번째 인자에는 파일명,
두번째 인자는 구분자를 입력해준다.

bad_loan_status_to_grades.to_csv(“bad_loan_status.csv”, sep="," )

파일쓰기 : to_csv()

2018/02/25 - [빅데이터 관련 프로그래밍/Python] - 15. Matplotlib 사용하기 –라인 플롯, 바 플롯, 히스토그램, 산점도

먼저 아래 데이터를 복붙하여 사용할 것이다. 리스트[]를 여러개 묶어놓은 2차원리스트 즉, array 데이터이다.
이 데이터를 DataFrame에 넣고, 칼럼과 인덱스를 주자. (Series 는 index만 인자로 줄 수 있었다)

data = [[1.4, np.nan],
           [7.1, -4.5],
        [np.nan, np.nan],
        [0.75, -1.3]]
df = pd.DataFrame(data, columns=["one", "two"], index=["a", "b", "c", "d"])

DataFrame의 데이터 분석용 통계함수 사용( sum, mean, min)

• 이 때, sum()함수에 axis=0을 줘서 행 방향 = 열의 합을 구할 수 있다. 마찬가지로 axis=1을 인자로 주면, 열 방향 = 행의 합을 구할 수 있다.
  
  이 때, sum()함수의 계산과정에서 NaN은 무시하고 계산하는 것을 알 수 있다.
• 비슷하게, 특정 열에 대한 합과 특정 행의 합도 구할 수 있다. 인덱싱을 사용하면 된다.
  
• 비슷하게, 합 뿐만 아니라 평균( .mean()함수 ), 분산( .var()함수 )를 사용하면 된다.(인덱싱 없이하면 각 열에 대한 통계량이 나온다)
  
  
• 만약, 각 행의 평균을 구하려면, sum()처럼 인자에 axis=1을 넣으면 되는데, NaN을 감안해서 무시안하고 평균도 NaN으로 처리하고 싶다면,
  또다른 인자로서 skipna = False를 대입하면 된다.  df.mean(axis=1, skipna=False)
  
• 그외 통계함수 정리
  

• 다시 df의 데이터를 보면서, “one”이라는 열의 NaN에는 열의 나머지성분의 평균값으로, “two”라는 열의 NaN에는 열의 나머지성분 중 최소값으로 대체해보자.  각 평균값과 최소값을 구한 뒤  - >  각 열에 .fillna( value = )를 대입해주면 된다.
  (1) 먼저 “one”열에서 평균값을 미리 계산해서 one_mean 에  담아둔다.( 통계함수들은 NaN을 배제하고 계산되기 때문에 바로 할 수 있다)
     one_mean = df["one"].mean()
  (2) “two”열에서 최소값을 .min() 를 이용해서 찾아서 two_min에 담아둔다.
     two_min = df["two"].min()
  (3) 각 열을 인덱싱한 것에 .fillna( value = )에다가 각각 넣은 뒤, 그 값을 다시 각 열에 대입한다.
      df["one"] = df["one"].fillna( value = one_mean )
       df["two"] = df["two"].fillna( value = two_min)
  

DataFrame의 유용한 특수 통계함수 – 상관관계와 공분산

먼저 데이터는 아래와 같은 것을 복붙해서 사용하자. numpy의 rand함수를 이용해서 6x4 이차원 array를 만들고 대입한다.

df2 = pd.DataFrame(np.random.randn(6, 4),
                   columns=["A", "B", "C", "D"],
                   index=pd.date_range("20160701", periods=6))

• 상관계수를 구하려면, df2[“특정열”]  .corr ( df2[ “비교하고싶은 열” ] ) 의 방식으로 .corr()함수를 사용한다.
  앞 변수에는 기준 열을 적고, 인자에 비교하고 싶은 열을 인덱싱해서 넣어주면 된다.
  df2["A"].corr( df2["B"])
  이 때, 계산은 피어슨 상관계수 공식에 의해 계산된다.
  (cf. 피어슨 상관계수(Pearson correlation coefficient) 는 두 변수간의 관련성을 구하기 위해 보편적으로 이용된다 )
  ( 링크 : https://ko.wikipedia.org/wiki/%EC%83%81%EA%B4%80%EB%B6%84%EC%84%9D)
  
  
  
• 공분산을 구하려면, 상관계수와 비슷한데, .cov()함수를 사용하면 된다.
  df2["B"].cov( df2["C"])
  
• 만약, 특정 열을 인덱싱안하고, df2.corr() 이나, df2.cov()를 사용하면 모든 열 간의 상관관계와 공분산을 계산해준다.
  

DataFrame 정렬함수

• pandas의 DataFrame에서는 인덱스 기준 정렬과 값 기준 정렬을 지원한다.
  정렬 하기에 앞서, 기존의 인덱스와 칼럼의 순서를 섞어주기 위해 reindex()함수를 사용한다.
  dates = df2.index
  random_dates = np.random.permutation(dates)
  df2 = df2.reindex(index=random_dates, columns=["D", "B", "C", "A"])
  (1) datatime타입의 인덱스를 dates 변수에 넣고 –> np.random.permutation( ) 함수를 이용해서 섞어준 것을 random_dates에 넣는다.
      이 함수는 인자에 있는 리스트를 랜덤하게 섞어주는 역할을 한다
  (2) df2.reindex() 를 이용해서 기존 dataFrame에 인덱스와 칼럼을 섞어준다.
    - index는 datetime타입이라서 변수에 따로 빼내어 함수를 이용해서 섞고 난뒤 대입 / columns은 그냥 자체적으로 섞어서 대입해준다.
  

index 기준 정렬

• 인덱스가 오름차순이 되도록 해보자. df2.sort_index(axis=0)함수를 이용하는데, 인자로, axis = 0을 넣어서
  인덱스를 기준으로 0 = 열 = 행 방향(↓)으로 정렬해준다.
  
• 칼럼(열)이 오름차순으로 정렬하고 싶다면, 마찬가지로 sort_index()함수를 사용하는데, axis = 1을 넣어서
  칼럼을 기준으로 1= 행 = 열방향(→)으로 정렬해준다.
  
• 이제 내림차순으로 정렬하고 싶다면, index와 columns를 정렬하는 것과 똑같이 sort_index( axis = )에다가 , 추가로 인자를 ascending = False 를 주면,
  내림차순으로 정렬이 된다.
  먼저, 행 index를 내림차순으로 해보자. df2.sort_index(axis=0, ascending = False)
  
  다음으로 열 columns를 내림차순으로 해보자. df2.sort_index(axis=1, ascending = False)
  
  < 열 방향 = 행 = axis = 1> < 행 방향 = 열 = axis = 0>
  
  

값 기준 정렬 ( 거의 특정열에 대한 값들의 정렬임)

값 기준 정렬을 사용하는 것은  먼저 <특정 열>에 대해서  --> 그 값들이 오름차순으로 정렬되도록 –> 각 행들을 정렬해버리는 것이다.

• 예를 들어,  <D열>기준으로 값들이 오름차순 되도록 행들을 정렬하는 코드는 df2.sort_values(by="D")이다.
  즉, sort_values( )함수의 인자에 by="열(칼럼) 이름”을 넣어주는 것이다. 
  sort_values( by = “ 칼럼명 ”)
  

df2 의 E열과 F열을 추가해보자.
df2["E"] = np.random.randint(0,6, size = 6)
df2["F"] = ["alpha", "beta", "gamma", "gamma", "alpha", "gamma"]
( np.random.randint()는 정수를 랜덤하게 생성하는데, 인자의 0,6 은 0과 6사이(1,2,3,4,5)의 수 중 랜덤정수, 만약 최대값이 명시 되지 않으면 0<->최소값 사이 정수 / size는 리스트의 성분개수인 열  or  (행,렬) 을 의미한다)

• 2개의 열에 대해서 오름차순하도록 할 수 있다. 즉,  첫번째 열을 기준으로 오름차순 하는데, 만약 값이 같다면 두번째 열을 기준으로 오름차순 되도록 할 수 있다. 방식은 sort_values( by = “칼럼명”)과 비슷한데, by = 에다가 리스트 형식으로 우선순위 대로 열들을 대입해준다.
  df2.sort_values(by=["E", "F"]) 는  E열을 기준으로 값들을 오름차순이 되도록 행을 정렬하는데, 만약 같다면, F열이 오름차순이 된다.
  (1개 열의 값기준 오름차순 정렬은 대괄호가 없이 그냥 by="칼럼명")
  

그외 유용한 함수들

• 특정열인덱싱 . unique() : 특정열을 중복없는 열로 만들어준다.
  특정열인덱싱 . value_counts() : 특정열의 각 성분값들이 포함된 행의 개수를 알려준다.
  특정열인덱싱 . isin(  [ “ 특정값 " ]  ) : 특정값이 포함되어있는지 boolean 마스크를 생성해준다.
                                               이 때,  “특정값1”, “특정값2” 로 OR(또는) 연산이 가능하다.
  
• .isin( [ “”] )함수를 이용해 만든 마스크를  행을 선택(인덱싱)할 때 쓰는, df2.loc()함수의 행index에 집어넣으면,  해당 행을 뽑아낼 수 있다.
  df2.loc[ df2["F"].isin(["alpha", "beta"]) , :]
  위 코드는 특정열 “F”열에, alpha 혹은 beta를 포함하는 행들을 뽑아낸다.
  

사용자 정의 함수를 행or열에 적용하기 [  lambda  ->  apply() ]

새로운 DataFrame을 정의해서 사용하자. numpy의 randn함수로 2차원 array를 정의하고, 각 인덱스와 칼럼값을 직접 입력한다.

df3 = pd.DataFrame(np.random.randn(4, 3), columns=["b", "d", "e"],
                   index=["Seoul", "Incheon", "Busan", "Daegu"])

1. 먼저, python에서 사용하는, 함수를 만들어주는 [ lambda 인자(, 인자2) : 표현식 ]으로  func라는 함수를 정의해보자.
   func함수는 사용자 정의 함수로서, 최대값- 최소값을 계산해서 반환해준다.
   func = lambda x: x.max() - x.min()
2. 다음으로 행 또는 열에 대해서, apply()함수를 사용하여, 정의한 함수를 인자로 주고,  다음  axis을 인자로 주어 행 또는 열을 선택하면,
   정의한 함수가 해당 행 또는 열에 대해 계산을 해준다.
   df3.apply( func, axis = 0)  :  func함수를 axis=0인 행 방향(열)으로 시행해서, 각 열의 최대값 – 열의 최소값을 계산해 줄 것이다.
   
   마찬가지로 axis = 1을 주면, 각 행들에 대해서 최대값 –최소값의 계산을 해줄 것이다.
   

• dataFrame은 인덱스와 컬럼인자를 주지 않으면, index와 columns는 0부터 시작한다.
  여기서는 numpy의 랜덤함수인 np.random.rand( 행,렬)로 랜덤 array를 만들어서 대입해보자.
  
  이 때, index에 대해서는 pd.date_range( “ yyyymmdd”, periods = 6) 함수를 사용해보자.
  pandas에서 제공하는 Datetime64라는 데이터형으로 구성된 인덱스( DatatimeIndex)를 생성할 때 사용되는 함수다.
  뒤에 periods =6 은 입력날 날자로부터 6일에 대한 index를 생성한다. 즉, 6개 행을 만든다.
  

결측값, 이상치(NaN) 조작하기

pandas를 이용해서 dataset를 가져올 때, NaN과 같이 범주에서 벋어난 값이 존재 할 수 있다. 이러한 값을 결측값(missing value), 이상치(out lier)라고 한다. 이 결측값, 이상치를 제거하거나 새로운 값으로 대입하는 방법을 알아보자.

• 먼저, 새로운 열F를 만들고, 값을 입력하는 과정에서  하나의 성분으로 np.nan을 이용해보자. 성분에 NaN을 대입하는 numpy의 함수다
  
• 이제 우리는 NaN이라 표기된 값만 골라내고,해당 행을 제거해야한다.
  (행제거는 밑에어 df.drop()으로 따로 배운다. 여기서는 NaN을 포함하는 행을 제거하는 방법을 배운다.)
  이럴 때, df.dropna( how = “any” ) 함수를 이용해야한다. 각 행들 중 NaN을 포함하는 행들을 제거한 df를 가져올 수 있다.
  이 때,  any는 행의 성분에 NaN이 하나라도 있으면 그 행을 제거 라는 뜻이다. 
  만약, how의 인자에 “all”이 있다면, 행의 성분이 모두 NaN일 때 제거한다는 뜻이다. 지금은 모두 NaN인 행이 없으니 그대로나올 것이다
  
• 이제 NaN이 포함된 행을 제거하는 것이 아니라, NaN에 다른 값을 대입해보자.
  이럴 땐, df.dropna(how=" ")가 아닌 df.fillna(value=5.0)함수를 사용해야한다.
  NaN 성분들에 일괄적으로 value값을 대입한다.
  
• NaN이 포함되어 있는 데이터에 대한 boolean마스크를 생성할 수 있다. NaN인 성분만 True를 뽑아내주는 df.isnull()함수를 사용해준다.
  
  *****이제 이러한 마스크를 이용해서 loc함수의 행index자리에 넣어 NaN을 포함한 행만 뽑아낼 수 있다.*****

기존에 강의에서는 np.array로 생성한 array에 대해
[ 전체기준열-> 열안의 특성성분과 조건문을 통해 마스크생성 (for문을 이용할 경우, 중복없는기준열생성) -> 행index자리에 넣기 ]
에 넣기 의 과정으로 뽑아냈다면,

• 여기 NaN를 뽑아내기위해서, 전체기준열을 뽑기전에 df.isnull()함수를 먼저 사용해야하므로 전체 데이터에 대한 마스크를 먼저 생성한다
  [  is.null()로 전체마스크 –>  전체 마스크 중 df[ “ 전체기준열” ]으로 직접제시 –> loc함수의 행index자리에 넣기 ]
  df.loc[    df.isnull()["F"] ,    :]
  

• 행을 삭제하기에 앞서, 행의 index에 접근을 먼저해야한다. 왜냐면, 앞에서 행의 index에다가 datetime데이터형을 집어넣었고, 그것에 접근하려면 datetime타입으로 접근해야하기 때문이다.
   pd.to_datetime("20160701")함수를 이용해서, (index로 줬던 것으로) 날자명을—> datatime데이터형으로 변환할 수 있다.
  
  이전에 index명에 pd.date_range()함수를 통하여 datetime데이터형으로 집어넣었기 때문에,
  이에 index에 접근할려면 마찬가지로 datetime데이터형을 인자로 넣어야한다. 그래서 한번의 변환과정을 거치면서 작업을 해줘야하는 것이다.
  
    pd.date_range( “날자”, periods = 행수) 생성 – > index –> pd.to_datetime(“날자”) 접근
     “20160701”                  >        2016-07-01     >    “20160701” to 2016-07-01
  
  
• “yyyymmdd”날자명을 pd.to_datetime()로 index로 변환한 것을 df.drop()함수의 인자로 넣어서 해당행을 삭제한다.
  ( 열을 삭제할 때는 del df[“칼럼명(열명)”] 이었다. 행 삭제는 df.drop( 해당인덱스)이다. )
  df.drop( pd.to_datetime("20160701") ) 를 입력하면 2016-07-01 인덱스를 가진 행이 사라진 것을 확인할 수 있다.
  
  
  
• 마찬가지로 2개이상의 특정행을 삭제하고 싶다면, df.drop()의 인자로 [리스트]형태로 넣어서 삭제해주면 된다.
  df.drop( [ pd.to_datetime("20160702"), pd.to_datetime("20160704")] )
  
• df.drop()함수로, 열을 삭제할 수 도 있다. drop()함수의 인자는 기본적으로 행의 인덱스를 가져야 하는데, 이를 상쇄하면서
  들어간 인자가 “컬럼명”이라는 것을 명시해주기 위해 새로운 인자 axis=1이 들어간다.
  df.drop("F", axis=1)
  
  8강 numpy 함수중 arr.sum()의 인자로 쓰였다. sum() = arr 성분전체 합/axis=0은 각각 열들의 합/ axis=1은 각각 행들의 합,[열->방향]
  8강 정렬함수 np.sort()의 인자로는 쓰였따. sort( arr, axis=0 ) 각 열을 오름차순으로 정리 / axis=1은 각 행을 오름차순으로 정렬[열->방향]
  12강 DataFrame의 행삭제 df.drop()의 인자로 쓰여, axis=1은 행 대신 열을 삭제하도록 해준다.[열->방향에서 해당 열삭제]

• df.drop()함수를 이용해서 2개이상의 열을 삭제할 때도, 열명은 리스트의 형태로 작성한 뒤  콤마, axis=1를 넣어주면 된다.
  df.drop( [ "B","F"], axis=1)
  

DataFrame을 생성해보자.

• Series도 있지만, 주로 사용할 데이터는 DataFrame이다. 필요한 패키지들을 import해놓고, 아래와 같이
  python 딕셔너리를 만들고, DataFrame을 만드는데, 인자로 columns를 주어 키값=칼럼=열 의 순서를 정해주고, 딕셔너리에 없는 새로운 열도 추가해주자. 그리고 index를 인자로주어 리스트의성분=행=인덱스의 이름도 정해주자.
  data = {"name" : [ "Kilho", "Kilho","Kilho", "Charles","Charles" ],
             "year" : [2014, 2015, 2016, 2015, 2016],
             "points" : [1.5, 1.7, 3.6, 2.4, 2.9]}
  df = pd.DataFrame( data, columns = ["year", "names", "points", "penalty"],
                                     index = ["one", "two", "threes", "four", "five"]  )
  

DataFrame의 열을 선택(인덱싱)하고 조작하기

• 하나의 열을 가져오는 방법은 2가지이다. 편한것을 선택하면 된다.  대표적인 열 선택 코드는  DataFrame변수[ “ 칼럼명” ] 이다.
  이 때, DataFrame에서 하나의열을 가져온 결과는 Series의 모양을 하고 있다는 것을 기억하자.
  ( series를 생성할 때,  index명도 함께 줄 수 있다는 점을 뒤에 사용할 것이다)
  df[“컬럼이름”] or df.컬럼이름 으로 하나의 컬럼(열)을 series의 형태로 가져올 수 있다.
  
• 2개 이상의 열을 가져오는 방법은, df[[ “칼럼이름1”, “칼럼이름2”]]의 방법으로 가져온다. 이 때는, series가 아닌 dataFrame형태로 가져온다.
  대괄호가 2개라는 것을 명심하자. 대괄호 1개에다가 [리스트]형식으로 가져온다고 생각해도 된다.
  
• 선택된 열의 모든 성분에, 일괄적으로 값을 대입할 수 있다. 성분이 비어있던 “penalty”에다가 0.5를 대입해보자.
  
• 일관적인 값이 아니라, 선택된 열에다가  행에 따라  각각 어떤 값을 대입하고 싶다면, python의 리스트 형태로 만들어서 대입하면 된다.
  numpy의 1차원 array도 대입할 수 있다.
  
• 새로운 열을 생성과 동시에 대입할 수도 있다. zeros라는 열을 새로 만들고, 여기다가 numpy의 np.arange(5)로 대입해보자. 새로운 열(칼럼)이 추가되면서, 값이 대입되는 것을 확인할 수 있다.
  cf) np.arange(n)은  0부터 총 n개, 즉, n-1까지 1차원 배열을 생성한다는 뜻이다.
  
• DataFrame의 하나의 열을 선택했을 때 Series로 제공된다는 점에서 착안하여, 새로운 열을 입력할 때도, 리스트가 아닌 series를 대입해줄 수 도 있다.
  series를 정의한 다음, 그 series 변수를 df[ “ 칼럼이름” ]  = series를 대입해보자.
  series를 만들어서 대입하는 이유는, series를 정의할 때, 리스트형식으로 values를 넣고, 뒤 인자에 index를 정해줄 수 있고, 기존의 행index와 동일한 이름으로 주면, 맞춰서 끼워들어가는 특징을 이용할 수 있다. 5개의 index이름 중에 3개만 골라서 , 거기 끼워맞춰 들어가게 해보자.
  
  열에 값을 대입할 때, python의 리스트나 numpy의 array를 대입했던 것과 달리, Series를 대입할 때의 핵심적인 차이다.
  ***근데,, 원래 기존값이 있는 상태에서, 값이 없는 행에 끼워넣었더니,, 기존값들이 NaN이 되어버린다. 끼워넣기보다는 초기화..!
• 새로운 열을 추가할 때, 기존dataFrame 열의값을 연산한 것도 대입할 수 있다.(그냥 대입하면 그대로 옮겨온 것과 같다)
  새로운 열 “net_points”를 만들면서 동시에 연산한 값을 대입해보자
  
  비슷하게 조건문을 통해 True 혹은 False가 대입되도록 할 수도 있다.
  
• 기존의 열을 삭제하는 방법은, del 키워드와 함께 일반적인 열 선택코드를 입력하면 된다.
  예를 들어 del df[“high_points”]
  
• 현재 존재하는 컬럼들을 확인하려면 df.columns로 트래킹 하면된다.
  
• 데이터프레임의 index와 columns에 이름을 정해주자.
  

DataFrame의 행을 선택하고 조작하기

• 경고 ) pandas에서는 행을 선택하는 인덱싱 방법이 무수히 많다는 것이 문제이다. 그리고 버젼이 올라가면서 행을 인덱싱하는 방법도 달라지고 있다.
• 먼저 열을 인덱싱하는 것과 유사한 행 인덱싱 방법 2가지를 살펴보자.
  df[ 0 : 3 ]은 index 0부터 총 3개 행을 가져온다. numpy의 array와 비슷하다.
  df[ “two” : “four” ]는 index명이 “two”인것부터 마지막 “four”까지 사이의 모든 행을 가져온다.
  
  마치 열을 선택하는 코드와 너무나도 유사하기 때문에, 비추는 방법들이다.
• .loc[] 와 .iloc[]의 함수를 사용해서 행을 인덱싱하는 방법을 추천한다.
  df.loc [ “ index 명” ] 을 통해 가져온 값은, 열을 인덱싱 했을 때와 마찬가지로 Series의 형태로 가져온다.
  행의 범위인덱싱도 마찬가지다
  
• 행을 인덱싱하는 .loc[]함수의 재밌는 점은, 행을 인덱싱하면서 동시에 열도 인덱싱할 수 있따.
  인덱스 인자로서 “칼럼명”을 추가해주면 된다. ex> df.loc[ “two”:”four” , “points”]
  
  이를 응용하면, 행인덱스 자리에 전체를 의미하는 콜론(:)을 넣고, 가져올 칼럼명을 입력하면, 열을 인덱싱하는 것과 같아진다.
  즉,  .loc[ : , “칼럼명” ] 으로 열을 선택하는 인덱싱하는 코드인  df [ “칼럼명” ]과 같다.
  
  마찬가지로, 2개이상의 열을 선택하는 방법에서 2개의 대괄호로, 리스트형식처럼 칼럼명을 나열해서 가져왔던 것과 유사하게, .loc함수에서도 할 수 있다.
  
  . loc[]함수를 이용해서  행과 열에 동시에 범위 인덱싱도 할 수 있다.
  my) loc[ ] 함수를 이용한 인덱싱은, 행을 우선순위로하여서 무조건 입력되어야하며, 뒤에 인자를 추가해서 칼럼명 자유롭게 인덱싱할 수 있는 것이구나.
  
• 새로운 행을 추가하는 방법도 열과 마찬가지로 인덱싱할 때처럼, 일반적인 행을 선택하는 방식에 대입해주는 식이다.
  대신 열(칼럼)에 값을 대입해주기 위해서는, 전체 열을 인덱싱한 콜론을 넣은 뒤, 우항에서 리스트의 형식으로 대입해주는 것이다
  (칼럼의 갯수에 맞게 리스트 성분을 대입한다면, 굳이 열에 대한 전체인덱싱은 없어도 가능하더라)
  
  *** .loc[ , ]만 기억하면 모든 인덱싱이 가능하다.
• .iloc 함수는 numpy 의 array 인덱싱 방식으로 가져올 때 쓰는 것이다. 즉, 칼럼명이 아니라 index숫자로서 가져올 때 쓴다.
  예를 들어, df.iloc[3]은 4번째 행을 가져온다. array인덱싱과 유사하다.
  
  마찬가지로 행과 열의 범위인덱싱을 할 수 있다.
  df.iloc[ 3:5, 0:2 ] 는 4번째 행부터 5번째 행까지,  1번째열 부터 2번째 열까지를 가져온다.
  
  간격을 띄엄띄엄 으로 행과 열을 가지고 오고 싶다면,  리스트형식으로 해당 index를 준다.
  예를 들어, df.iloc[ [0, 1, 3] , [1, 2] ]  1번째 2번째 4번째 행 / 2번째, 3번째 열을 가져오게 된다.
  
  특정 값 하나만 가져오고 싶다면 범위인덱스가 아닌 해당 인덱스를 적어주면 된다.
  df.iloc[1, 2] 는 2행 3열의 값만 가져온다.
  
• 즉, iloc를 이용하면 마치 numpy의 array를 인덱싱 하는 것처럼 index번호로 인덱싱 할 수 있다.

Boolean 인덱싱하기

• 기존 DataFrame에서,  “year”칼럼 중 2014보다 큰 값만 인덱싱하고 싶다고 가정해보자.
  df["year"] > 2014 를 입력하면, Series형태로 마스크가 얻어진다.
  
     (마스크는  전체데이터중 기준이 되는 열 과 그 가운데 특정성분을 비교한 조건문이었다.
     for문으로 선택된 행을 뽑아내고 싶을 땐, 중복없는 전체기준열을 따로 담아서, 조건문에 하나씩 들어가도록 사용했었다)
• 이러한 마스크를 인덱스 자리에 넣은 .loc함수를 이용하면 원하는 행을 선택할 수 있다. (열은 전체를 선택한다.)
  df.loc[ df["year"] > 2014 , : ]
  
• 이번에는 names 칼럼중에, 이름이 Kilho인 행을 뽑아내고, 칼럼은 names와 같이 points도 뽑아내보자.
  df.loc[ df["names"] == "Kilho", ["names","points"]]
  
  ( 이렇게 전체기준열(칼럼) 에서 원하는 행을 뽑아냈으면, 전체기준열(칼럼)도 같이 가져오는게 일반적인 분석방법이다)
• 만약 사용할 조건이 여러개라면, & 앤드 연산자를 이용해서, 여러개의 마스크 행 인덱스에 넣어주면 된다.
  df.loc [ ( df["points"] > 2 ) & (df["points"] < 3 ) , : ] 는  [ points칼럼의 값이 2보다 크고 3보다 작은 행들 , 의 모든 컬럼정보를 ] 가져온다.
  
• 이제 조건에 맞게 마스크를 사용해서 인덱싱 한 행의  특정칼럼에 특정값을 입력할 수 있다
  df.loc [ df["points"] > 3, "penalty"] = 0 를 통해  points칼럼이 3보다 큰 행들을 뽑아내서 , penalty칼럼에 0을 대입한다.