SeSAC 데이터 분석 기초 - 2일차 데이터프레임 다루기, 데이터프레임 수정

# 인덱스 0, 1 행을 drop
ns_book2 = ns_book.drop([0,1])
ns_book2.head()

# 2번째 행부터 잘라내서 ns_book2에 저장
ns_book2 = ns_book[2:]
ns_book2.head()

# 0번째 인덱스부터 2번째 인덱스까지 잘라내서 ns_book2에 저장
ns_book2 = ns_book[0:2]
ns_book2.head()

# ns_df의 '출판사'가 '한빛미디어'에 해당하는지 여부, bool값을 selected_rows에 저장
selected_rows = ns_df['출판사'] == '한빛미디어'
ns_book2 = ns_book[selected_rows]
ns_book2.head()

# 대출건수 칼럼의 값이 1000 초과인값만 저장
ns_book2 = ns_book[ns_book['대출건수'] > 1000]
ns_book2.head()

# 전체에서 중복된 값을 찾아 sum
sum(ns_book.duplicated())

-> 0

# 특정칼럼. 도서명, 저자, ISBN이 중복된 값을 찾아 sum 
sum(ns_book.duplicated(subset=['도서명', '저자', 'ISBN']))

-> 22096

# keep : 중복된 대상을 어떻게 표기할 것인지에 대한 파라미터
# first : (default) 중복되는 대상이 처음 나올 때, False로 처리하고, 이후 중복 값들은 모두 True로 반환
# last : 중복되는 대상이 마지막으로 나왔을 때만, 중복을 나타내는 True를 반환하고, 전에 나왔던 중복 값들은 False로 반환
# False : 모든 중복되는 대상을 True로 반환
dup_rows = ns_book.duplicated(subset=['도서명', '저자', 'ISBN'], keep=False)
ns_book3 = ns_book[dup_rows]
ns_book3.head()

count_df = ns_book[['도서명', '저자', 'ISBN', '권', '대출건수']]

# count_df에 대해, 도서명, 저자, ISBN, 권 으로 묶는다(groupby)
group_df = count_df.groupby(by=['도서명', '저자', 'ISBN', '권'], dropna=False)

loan_count = count_df.groupby(by=['도서명', '저자', 'ISBN', '권'], dropna=False).sum()
# print(loan_count)
loan_count.head()

# 여기에는 False 혹은 True가 담겨있다.
dup_rows = ns_book.duplicated(subset=['도서명', '저자', 'ISBN', '권'])
# ~ : NOT, Inverse
# dup_rows의 True가 아닌것. 즉, 중복이 아닌것들이 unique_rows에 들어있다.
unique_rows = ~dup_rows
# ns_book3에는 중복값을 빼고 unique 값만 들어있다.
ns_book3 = ns_book[unique_rows].copy()

sum(ns_book3.duplicated(subset=['도서명', '저자', 'ISBN', '권']))

-> 0

# '도서명', '저자', 'ISBN', '권'을 하나의 인덱스로 만든다.
ns_book3.set_index(['도서명', '저자', 'ISBN', '권'], inplace=True)
ns_book3.head()

# loan_count 데이터프레임을 가지고 ns_book3 데이터프레임을 업데이트
# SQL의 inner join과 같다.
ns_book3.update(loan_count)
ns_book3.head()

# ns_book3의 인덱스를 초기화
ns_book4 = ns_book3.reset_index()
ns_book4.head()

sum(ns_book['대출건수'] > 100)

-> 2311

sum(ns_book4['대출건수'] > 100)

-> 2550

ns_book4 = ns_book4[ns_book.columns]
ns_book4.head()

ns_book4.to_csv('ns_book4.csv', index=False)

def data_cleaning(filename):
  # 파일을 데이터프레임으로 읽음
  ns_df = pd.read_csv(filename, low_memory=False)
  # NaN인 열 삭제
  ns_book = ns_df.dropna(axis=1, how='all')

  # 대출 건수를 합치기 위해 행만 추출하여 count_df 데이터프레임을 만든다.
  count_df = ns_book[['도서명', '저자', 'ISBN', '권', '대출건수']]
  # 도서명, 저자, ISBN, 권을 기준으로 대출건수를 그룹바이
  loan_count = count_df.groupby(by=['도서명', '저자', 'ISBN', '권'], dropna=False).sum()
  # 원본 데이터프레임에서 중복된 행을 제외하고 고유한 행만 추출하여 복사
  dup_rows = ns_book.duplicated(subset=['도서명','저자','ISBN','권'])
  unique_rows = ~dup_rows
  ns_book3 = ns_book[unique_rows].copy()
  # 도서명, 저자, ISBN, 권을 인덱스로 설정합
  ns_book3.set_index(['도서명','저자','ISBN','권'], inplace=True)
  # load_count에 저장된 누적 대출건수를 업데이트
  ns_book3.update(loan_count)
  
  # 인덱스 재설정
  ns_book4 = ns_book3.reset_index()
  # 원본 데이터프레임의 열 순서로 변경
  ns_book4 = ns_book4[ns_book.columns]
  
  return ns_book4

new_ns_book4 = data_cleaning('ns_202104.csv')

ns_book4.equals(new_ns_book4)

import gdown

gdown.download('https://bit.ly/3GisL6J', 'ns_book4.csv', quiet=False)

import pandas as pd

ns_book4 = pd.read_csv('ns_book4.csv', low_memory=False)
ns_book4.head()

# 칼럼명 총 13개
# int64 = 64비트 정수
ns_book4.info()

ns_book4.info(memory_usage='deep')

# is NaN?
ns_book4.isna().sum()

# 0(1번째 행)의 도서권수 칼럼을 None으로 변경
ns_book4.loc[0, '도서권수'] = None
# NaN인지 확인
ns_book4['도서권수'].isna().sum()

ns_book4.loc[0, '도서권수'] = 1
# 실수 값으로 되어있는것을 32비트 정수로 변경 
ns_book4 = ns_book4.astype({'도서권수' : 'int32', '대출건수' : 'int32'})
ns_book4.head(2)

# 숫자가 아닌 값에는 NaN이 적용되지 않는다.
ns_book4.loc[0, '부가기호'] = None
ns_book4.head(2)

# 문자를 NaN으로 표기하기 위해 numpy 사용 
import numpy as np

ns_book4.loc[0, '부가기호'] = np.nan
ns_book4.head(2)

# ns_book4의 '세트 ISBN'이 아무것도 없는 값을 찾아 set_isbn_na_rows에 저장
set_isbn_na_rows = ns_book4['세트 ISBN'].isna()
# 해당 값을 '' 공백으로 처리.
ns_book4.loc[set_isbn_na_rows, '세트 ISBN'] = ''
ns_book4['세트 ISBN'].isna().sum()

-> 0

# 아무것도 없는 값을 '없음' 으로 채운다.
ns_book4.fillna('없음').isna().sum()

# '부가기호'를 '없음' 으로 처리
ns_book4['부가기호'].fillna('없음').isna().sum()

ns_book4.fillna({'부가기호':'없음'}).isna().sum()

# np.nan을 '없음'으로 처리
ns_book4.replace(np.nan, '없음').isna().sum()

# '부가기호'가 np.nan이면 '없음' 으로 key와 value값으로 처리
ns_book4.replace({'부가기호': np.nan}, '없음').head(2)

# '부가기호'가 np.nan이면 '없음'으로, '발행년도'가 '2021'이면 '21'으로 대치
ns_book4.replace({'부가기호': {np.nan: '없음'}, '발행년도': {'2021': '21'}}).head(2)

# 발행년도가 '2021' 인 값을 '21'로 표현
# 데이터프레임의 100번부터 101번까지 슬라이싱
ns_book4.replace({'발행년도': {'2021': '21'}})[100:102]

# regex=True == regular expression = True 
# r'\d\d(\d\d)' -> 숫자 4개 중 뒤의 2자리를 그룹으로 묶음
# r'\1' -> 뒤의 2자리 그룹을 사용
ns_book4.replace({'발행년도': {r'\d\d(\d\d)': r'\1'}}, regex=True)[100:102]

# 위의 표현과 같다.
ns_book4.replace({'발행년도': {r'\d{2}(\d{2})': r'\1'}}, regex=True)[100:102]

# (.*)\s\(지은이\) -> 0개 이상의 문자와 space가 나온뒤, (지은이)가 나타난다.
# (.*)\s\(옮긴이\) -> 0개 이상의 문자와 space가 나온뒤, (옮긴이)가 나타난다.
# r'\1\2 지정한 그룹 1과, 그룹 2를 사용.
ns_book4.replace({'저자': {r'(.*)\s\(지은이\)(.*)\s\(옮긴이\)': r'\1\2'},
                  '발행년도': {r'\d{2}(\d{2})': r'\1'}}, regex=True)[100:102]

# (\d{4}) 4개의 숫자가 묶인 그룹
# .*  앞뒤로 0개 이상의 문자
# \1 첫번째 그룹을 가져와 치환
ns_book5 = ns_book4.replace({'발행년도':r'.*(\d{4}).*'}, r'\1', regex=True)
ns_book5[invalid_number].head()

# 발행년도에서, \D 숫자가 아닌것들
unkown_year = ns_book5['발행년도'].str.contains('\D', na=True)
print(unkown_year.sum())
ns_book5[unkown_year].head()

# unkown_year에 해당하는 발행년도를 '-1'로 바꿔준다.
ns_book5.loc[unkown_year, '발행년도'] = '-1'
# ns_book5의 '발행년도'를 32비트 정수로 변경 
ns_book5 = ns_book5.astype({'발행년도': 'int32'})

# gt = greater than 
# 발행년도가 4000 큰 값들 개수
ns_book5['발행년도'].gt(4000).sum()

-> 131

# 해당 년도를 단기로 저장
dangun_yy_rows = ns_book5['발행년도'].gt(4000)
# 단기에서 2333년을 빼서 서기로 저장
ns_book5.loc[dangun_yy_rows, '발행년도'] = ns_book5.loc[dangun_yy_rows, '발행년도'] - 2333

# 위의 작업 후에도 단기로 나오는 데이터를
dangun_year = ns_book5['발행년도'].gt(4000)
print(dangun_year.sum())
ns_book5[dangun_year].head(2)

# -1로 저장해 버린다.
ns_book5.loc[dangun_year, '발행년도'] = -1

# 0보다 크고 1900년대 이전의 책은 old_books
old_books = ns_book5['발행년도'].gt(0) & ns_book5['발행년도'].lt(1900)
ns_book5[old_books]

# old_books 또한 -1처리하여 버린다.
ns_book5.loc[old_books, '발행년도'] = -1

# 버린 책의 총 수량
ns_book5['발행년도'].eq(-1).sum()

-> 86

# BeautifulSoup
# HTML정보로 부터 원하는 데이터를 가져오기 쉽게, 
# 비슷한 분류의 데이터별로 나누어주는(parsing) 파이썬 라이브러리
import requests
from bs4 import BeautifulSoup

def get_book_title(isbn):
    # Yes24 도서 검색 페이지 URL
    url = 'http://www.yes24.com/Product/Search?domain=BOOK&query={}'
    # URL에 ISBN을 넣어 HTML 가져옵니다.
    r = requests.get(url.format(isbn))
    soup = BeautifulSoup(r.text, 'html.parser')   # HTML 파싱
    # 클래스 이름이 'gd_name'인 a 태그의 텍스트를 가져옵니다.
    title = soup.find('a', attrs={'class':'gd_name'}) \
            .get_text()
    return title

get_book_title(9791191266054)

-> '골목의 시간을 그리다'

# 'ns_book5' 데이터프레임의 일부 행에서 
# 도서 정보를 가져오는 함수인 get_book_info를 정의
import re

def get_book_info(row):
    title = row['도서명']
    author = row['저자']
    pub = row['출판사']
    year = row['발행년도']
    # Yes24 도서 검색 페이지 URL
    url = 'http://www.yes24.com/Product/Search?domain=BOOK&query={}'
    # URL에 ISBN을 넣어 HTML 가져옵니다.
    r = requests.get(url.format(row['ISBN']))
    soup = BeautifulSoup(r.text, 'html.parser')   # HTML 파싱
    try:
				# 타이틀이 비어있으면(isna)
        if pd.isna(title):
            # 클래스 이름이 'gd_name'인 a 태그의 텍스트를 가져옵니다.
            title = soup.find('a', attrs={'class':'gd_name'}) \
                    .get_text()
    except AttributeError:
        pass

    try:
				# 저자가 비어있으면
        if pd.isna(author):
            # 클래스 이름이 'info_auth'인 span 태그 아래 a 태그의 텍스트를 가져옵니다.
            authors = soup.find('span', attrs={'class':'info_auth'}) \
                          .find_all('a')
            author_list = [auth.get_text() for auth in authors]
            author = ','.join(author_list)
    except AttributeError:
        pass

    try:
				# 출판사가 비어있으면
        if pd.isna(pub):
            # 클래스 이름이 'info_auth'인 span 태그 아래 a 태그의 텍스트를 가져옵니다.
            pub = soup.find('span', attrs={'class':'info_pub'}) \
                      .find('a') \
                      .get_text()
    except AttributeError:
        pass

    try:
				# 발행년도가 -1(버린책)이면
        if year == -1:
            # 클래스 이름이 'info_date'인 span 태그 아래 텍스트를 가져옵니다.
            year_str = soup.find('span', attrs={'class':'info_date'}) \
                           .get_text()
            # 정규식으로 찾은 값 중에 첫 번째 것만 사용합니다.
            year = re.findall(r'\d{4}', year_str)[0]
    except AttributeError:
        pass

    return title, author, pub, year

# ns_book5 데이터프레임에서 누락된 도서 정보(도서명, 저자, 출판사, 발행년도 중 누락된)
# 가 있는 행 중에서 처음 2행을 가져온다.
updated_sample = ns_book5[na_rows].head(2).apply(get_book_info,
    axis=1, result_type ='expand')
updated_sample

# 1. 캐글에서 타이타닉 데이터를 찾아 train.csv 다운 받아 사용합니다. 
import pandas as pd

df = pd.read_csv('/content/train.csv')
df.head()

# 2. 가져온 데이터에서 이름 성별, 나이, 캐빈 칼럼만 떼어네 데이터 프레임을 새로 만듭니다. 
# * Name, Sex, Age, Cabin
df_ship = df[['Name', 'Sex', 'Age', 'Cabin']]
df_ship.head()

# 3. 새로만든 데이터 프레임에 대하여 성별에 male은 man, female은 woman으로 변경합니다. 
df_sex = df_ship.replace({'Sex' : {'male': 'man', 'female': 'woman'}})
df_sex.head()

# 4. 나이의 nan은 모두 0으로 변경합니다. 
# Age의 NaN인 값의 개수를 조회했다.
df_sex['Age'].isna().sum()

-> 177

# df_age에 df_sex를 복사해 저장
df_age = df_sex.copy()

# df_age['Age']에 df_sex['Age']값 중 NaN을 0으로 치환 후 저장
df_age['Age'] = df_sex['Age'].fillna(0)
# NaN 개수 확인
# df_age['Age'].isna().sum()
df_age.head()

# 5. 정규 표현식으로 캐빈에 앞의 영문자 즉 등급만 저장합니다. 
# df_cabin에 df_age를 복사해 저장
df_cabin = df_age.copy()
df_cabin.head()

# df_cabin에 'Cabin' 칼럼의 맨 앞문자(\w)와 .* 0줄이상의 문자열 중 첫번째 그룹을 사용.
df_cabin = df_cabin.replace({'Cabin' : {r'(\w).*': r'\1'}}, regex=True)
# df_cabin[df_cabin['Cabin'].notnull()].head()
df_cabin.head()

# 6. 모두 수정한 데이터를 train_v2.csv로 저장합니다.
df_cabin.to_csv('train_v2.csv', index=False)

import pandas as pd

ns_book6 = pd.read_csv('ns_book6.csv', low_memory=False)
ns_book6.head()

# 데이터프레임의 기술통계를 산출해서 보여준다.
ns_book6.describe()
# ns_book6.info()