초롱스쿨

텍스트 분석

: 머신러닝, 언어 이해, 통계 등 등을 활용해 모델을 수립하고, 정보를 추출해 비즈니스 인텔리전스나 예측 분석 등의 분석 작업을 주로 수행. 즉, 비정형 데이터인 텍스트를 분석하는 것

- 텍스트 분류, 감성 분석, 텍스트 요약, 텍스트 군집화와 유사도 측정이 있다.

텍스트 분석 수행 프로세스 과정

1. 모든 문서에 대해, 각 문서를 문장으로 쪼갠다 - 1차원

2. 각 문서의 모든 문장을 단어 단위로 쪼갠다. - 2차원

3. 각 단어들에 대한 전처리를 실시한다

   • 불용어 제거 (a, the, that, this)
   • 단어의 원형(3인칭, 복수형, 시제 제거) 또는 어근(stemming) 으로 변환
4. 피터 벡터화/추출 
   • 가공퇸 텍스트에서 피처 추출하고 여기서 벡터값 할당
5. ML 모델 수립 및 학습/에측/평가 
   • 피처 벡터화된 데이터 세트에 ML 모델을 적용해 학습/예측 및 평가를 수행

install.packages("rvest")
install.packages("stringr")

library(rvest)
library(stringr)

# naver 지식인에서 대학생을 검색어로 사용 
# main_url = "https://kin.naver.com/search/list.nhn?sort=none&query=대학생&period=1m&section=kin&page="
main_url = "https://kin.naver.com/search/list.nhn?sort=none&query=%EB%8C%80%ED%95%99%EC%83%9D&period=1m&section=kin&page="

kin_list = character()
title_list = character()
date_list = character()

for(page_url in 1:10){
  
    number = 1
    
    url = paste(main_url,1,sep="")
    content = read_html(url)
    
    link_node = html_nodes(content,"._nclicks\\:kin\\.txt") # from chrome develop mode
    link_node = html_nodes(content,"._searchListTitleAnchor") # from javascript function
    
    link_urls = html_attr(link_node, "href")
    title = html_text(link_node)
    title_list = append(title_list, title)
    
    date_node = html_nodes(content,".txt_inline")
    date = html_text(date_node)
    date = as.Date(gsub("\\.","-",date))
    date_list = append(date_list, date)
    # .c-heading-answer__content
    # #answer_2 > div._endContents.c-heading-answer__content
    #answer_2 > div._endContents.c-heading-answer__content > div
    #answer_3 > div._endContents.c-heading-answer__content > div
    
    for(link in link_urls){
        link = link_urls[2]
        sub_content = read_html(link)
        node1 = html_nodes(sub_content, ".cont_reply .box_collect .txt_collect")
        node1 = html_nodes(sub_content, ".c-heading-answer__content-user p")

        kin = html_text(node1)
        kin = gsub("\n|\t","",kin) 
        realkin = character()
        if(length(kin) != 0){ # 응답이 있을 때 
          for(i in 1:length(kin)){  # 12줄이니까 12번 돌아감 
            if(nchar(kin[i]) != 1){ # 빈 공백 줄 제거
              realkin = append(realkin, kin[i])
            }
          }
          realkin = paste(realkin, collapse="\n")  # realkin : 여러가지 텍스트 collapse: 행 새로 이어질때마다 연결되는 것을 적어줌 
        } else {
          realkin = ""
        }
        kin_list = append(kin_list, realkin)

        print(sprintf("Number of article is %d", number))
        number = number + 1 
    }
}

df = data.frame(date_list, title_list, kin_list)
df = df[order(df$date_list,decreasing = FALSE),]
colnames(df) = c("date","title","kin_reple")

write.csv(df, "naver_kin_대학생.csv", row.names = F)

# page_url = 2
# link <- link_urls[1]
# 위에서 node1을 선택할 때:
## - ".icon_check_adopt"로 노드를 식별하고,
## - 그 text가 "지식인채택" 또는 "질문자채택"을 갖는 node만 선택할 수 있다.
## - 또는 아직 ".icon_check_adopt"로 노드만 존재할 수도 있고,
## - 아직 전혀 답변이 없는 질문이 있을 수도 있다.
## - 각 채택 유형을 또다는 변수로 지정하고,
## - "질문자채택" > "지식인채택" > "마지막 답변" > "" 로 kin_list에 담을 수 있다.
## - 이경우 nodes를 식별하기 위한 css selector는 ".c-heading-answer__content-user"를 사용한다.


main_url = "https://tip.daum.net/search?query=파이썬&minIdx=&maxIdx=&action=0&pageNumber="

kin_list = character()
title_list = character()
date_list = character()

for(page_url in 1:10){
  
  number = 1
  
  url = paste(main_url,page_url,sep="")
  content = read_html(url)
  
  link_node = html_nodes(content,".box_collect .tit_collect a") # from chrome develop mode
  link_node = html_nodes(content,".tit_collect a") # from javascript function
  
  link_urls = html_attr(link_node, "href")
  title = html_text(link_node)
  title_list = append(title_list, title)
  
  date_node = html_nodes(content,".info_append .txt_time")
  date_node = html_nodes(content,".txt_time")
  
  date = html_text(date_node)
  date = as.Date(gsub("\\.","-",date))
  date_list = append(date_list, date)
  
  for(link in link_urls){
    link = paste("https://tip.daum.net",link,sep='')
    
    
    sub_content = read_html(link)
    node1 = html_nodes(sub_content, ".cont_reply .box_collect .txt_collect p")
    node1
    
    kin = html_text(node1)
    kin = gsub("\n|\t|\u00a0","",kin) 
    realkin = character()
    
    if(length(kin) != 0){ # 응답이 하나라도 있을 때.
      for(i in 1:length(kin)){  # 12줄이니까 12번 돌아감 
        if(nchar(kin[i]) != 0){ # 빈 공백 줄 제거
          realkin = append(realkin, kin[i])
        }
      }
      realkin = paste(realkin, collapse="\n")  # realkin : 여러가지 텍스트 collapse: 행 새로 이어질때마다 연결되는 것을 적어줌 
    } else {
      realkin = ""
    }
    kin_list = append(kin_list, realkin)
    
    print(sprintf("Number of article is %d", number))
    number = number + 1 
  }
}

df = data.frame(date_list, title_list, kin_list)
df = df[order(df$date_list,decreasing = FALSE),]
colnames(df) = c("date","title","kin_reple")

write.csv(df, "daum_tip_파이썬.csv", row.names = F)

install.packages("rvest")
install.packages("stringr")

library(rvest)
library(stringr)

## 알라딘 네이버 평점 페이지 주소 ##
main_url = "https://movie.naver.com/movie/bi/mi/pointWriteFormList.nhn?code=163788&type=after&isActualPointWriteExecute=false&isMileageSubscriptionAlready=false&isMileageSubscriptionReject=false&page="

reply_list = character()
star_list = numeric()
date_list = character()

for(page_url in 1:10){
    
    url = paste(main_url, page_url, sep="")
    content = read_html(url)
    
    node_1 = html_nodes(content, ".score_reple p")  # 댓글 내용
    node_2 = html_nodes(content, ".score_result .star_score em")  # 평점, 상단에 글 적는 평점(별) 제외하기 위해 
    node_3 = html_nodes(content, ".score_reple em:nth-child(2)")  # 댓글 작성 시간 
    
    reply = html_text(node_1)
    star = html_text(node_2)
    date = html_text(node_3)
    date = as.Date(gsub("\\.","-", date))  # . 을 -로 대체해줘 
    
    reply_list = append(reply_list, reply)  # 연결
    star_list = append(star_list, star)
    date_list = append(date_list, date)
    
}

df = data.frame(reply_list, star_list, date_list)  # 프레임으로 만들기
colnames(df) = c("reply","rank","date")

write.csv(df, "aladin_reply.csv", row.names = FALSE) # 파일 생성

## 실습: 다음영화에서 생일 영화를 크롤링하자. 


aladin <- read.csv("aladin_reply.csv")
head(aladin)


library(rvest)
library(stringr)

main_url =  "https://movie.daum.net/moviedb/grade?movieId=116523&type=netizen&page="


reply_list = character()
star_list = numeric()
date_list = character()


for(page_url in 1:5){
    
    url = paste(main_url,page_url, sep="")
    content = read_html(url)
    
    node_1 = html_nodes(content, ".desc_review")  # 댓글 내용
    node_2 = html_nodes(content, ".emph_grade")  # 평점, 상단에 글 적는 평점(별) 제외하기 위해 
    node_3 = html_nodes(content, ".info_append")  # 댓글 작성 시간 
    
    
    reply = html_text(node_1)
    reply = as.character(gsub("[\n\r]","", reply))
    reply = as.character(str_trim(reply))
    reply = as.character(gsub("? ( )","", reply))
    star = html_text(node_2)
    date = html_text(node_3)
    date = as.character(gsub("\n","", date))
    date = as.character(gsub("\t","", date))
    date = as.Date(gsub("\\.","-", date))  # . 을 -로 대체해줘 
    
    reply_list = append(reply_list, reply)  # 연결
    star_list = append(star_list, star)
    date_list = append(date_list, date)
    
}


df = data.frame(reply_list, star_list, date_list)  # 프레임으로 만들기
colnames(df) = c("reply","rank","date")

write.csv(df, "lionking_reply.csv", row.names = FALSE) # 파일 생성

aladin <- read.csv("lionking_reply.csv")
head(aladin)



install.packages("rvest")
install.packages("stringr")

library(rvest)
library(stringr)

url = "https://news.v.daum.net/v/20190414215757617"
news <- read_html(url)
node <- html_nodes(news, "#harmonyContainer img")
node
for(i in 1:2){
    imgurl = html_attr(node[i],"src")
    download.file(imgurl,destfile = paste("test",i,".jpg"),mode = "wb")
}

간단하게 판다스로 작업한 데이터 프레임을 그래프로 시각화하는 것을 알려드리겠습니다.

다음 score 파일을 작업 폴더에 넣어주세요.

dfs = []
for i in range(1,4):
    file_name = 'score/score%d.csv'%i
    dfs.append(pd.read_csv(file_name))
score_df = pd.concat(dfs)
score_df.drop_duplicates(inplace=True)
score_df.dropna(inplace=True)
score_df

# 중복 여부 확인 : DataFrame.duplicated()
# 중복이 있으면 처음과 마지막 값 중 무엇을 남길 것인가? : keep = 'first', 'last', False
# 중복값 처리(unique한 1개의 key만 남기고 나머지 중복은 제거) : DataFrame.drop_duplicates()

- pd.read_csv () : 해당 파일은 score 폴더 밑에 존재하며 파일 이름은 score1,2... 이렇게 되있기 때문에 한번에 불러오기 위해 for문을 작성하였다. 

- drop_duplicates() : 해당 파일을 보게 되면 중복 데이터가 있기 때문에 중복을 제거하고 하나만 남기게 됨

- .dropna() : 결손 데이터가 있는 행을 제거하는 것으로 inplace = True를 통해 원본 데이터프레임이 변경되게 된다.

score_df.reset_index(drop=True, inplace=False)   # 인덱스를 새로 정렬하지만, 원래 인덱스를 칼럼으로 만들지 않음

- 인덱스를 확인하면 인덱스가 불규칙적으로 된 것을 확인할 수 있다. 새로 정렬하기 위해 reset_index를 사용하였으며, drop=True를 통하여 인덱스가 변경되어 원래 인덱스를 칼럼으로 만드는 과정을 하지 않음

1. 그래프 그리기

import matplotlib.pylab as plt
score_df.plot()
plt.show()

- 그래프를 그리기 위해 matplotlib를 import 하고 .plot를 통하여 그래프를 그리고 show를 통하여 확인할 수 있다.

2. 상자그래프 그리기

score_df.boxplot('sci')

- 과학 성적에 대한 boxplot을 그릴 수있다.

3. crosstab 이용한 그래프 

pd.crosstab(titanic_df.Survived, columns=titanic_df.Pclass).plot()  # 선그래프

pd.crosstab(titanic_df.Survived, columns=titanic_df.Pclass,normalize=True).plot(kind='bar')  # 막대 그래프 

-  타이타닉 데이터의 생존률을 Pclass를 가지고 선그래프를 그려주고,kind='bar'를 인자로 넣어주면 막대그래프로 그려짐

4. figure() : 차트를 생성하는 함수

plt.figure(figsize=(15,10)) # figure => 캔버스라 생각, 숫자는 inch단위 (x,y)
score_df.hist(ax=plt.gca()) # 캔버스에 도화지를 붙인다 ax 

- 과목별 성적의 분포를 그래프로 확인 할 수 있다.

판다스는 결손데이터를 처리하는 api를 제공합니다.

여기서 결손 데이터란 칼럼에 값이 없는, null인 경우를 의미하며, 넘파이에서는 NaN으로 표시됩니다.

데이터를 분석하기 위해서는 이 결손 데이터 처리가 필요한데, 경우에 따라 결손데이터를 포함하는 행을 없앨 수도 있고, 중간값 또는 평균값으로 대체가 필요한 경우도 있습니다.

- isna() : 데이터가 NaN인지 확인하는 함수입니다. 결과는 True, False로 True인 경우 결손 데이터가 있다는 의미입니다.

titanic_df.isna().head(3)

titanic_df.isna().sum()

- 결손 데이터에 대한 sum을 하게 되면 True가 1로 계산되어 합이 나오게 됩니다. 즉 0이 아닌 값을 가지면 그 수만큼 결손 데이터가 존재한다는 의미입니다.

- fillna() : 결손 데이터를 편리하게 다른 값으로 대체할 수 있는 함수

titanic_df['Cabin'] = titanic_df['Cabin'].fillna('C000')
titanic_df.head(3)

- 'Cabin'은 결손 데이터가 많은 칼럼으로 na, 즉 결손 데이터인 경우 모두 'C000'으로 대체 된 것으로 확인 할 수 있습니다.

titanic_df['Age'] = titanic_df['Age'].fillna(titanic_df['Age'].mean())

- 'Age'의 칼럼은 결손 데이터가 있을 시 'Age' 칼럼의 평균을 대체하는 것입니다.

- apply lambda : apply 함수와 lambda가 결합해 DataFrame이나 Series의 레코드별로 데이터를 가공하는 기능 제공 

def get_square(a):
	return a**2
    
print('3의 제곱은 ', get_square(3))

lambda_square = lambda x: x**2
print('3의 제곱은 ', lambda_square(3))

- lambda x : x**2 : 반환(리턴)값은 x로 계산은 : 이후 식으로 , 식을 계산한 x로 반환하게 된다.

titanic_df['Name_len'] = titanic_df['Name'].apply(lambda x : len(x))

- 이름의 길이를 'Name_len'이라는 컬럼을 만들어서 apply안 lambda 의 이름 길이에 대한 x 값을 넣어주게 된다.

titanic_df['child_adult'] = titanic_df['Age'].apply(lambda x : 'child' if x <= 15 else 'Adult')

- lambda 식에 있어서 ifelse를 쓰는 방법은 위 식과 같다.

우리가 아는 if는 [ if 조건식 : 실행문 ] 이지만 판다스에서 반대로 [ 실행문 if 조건 else 실행문 ]의 형태를 가지고 있다.

즉 x가 15보다 같거나작으면 'child' , 아니면 'adult'가 되게 된다.

앞서 타이타닉 데이터를 가지고 실습을 하겠습니다.

1. DataFrame과 Series의 정렬 : sort_values()

- order by와 유사하며, 함수의 형태는 sort_values(by = , ascending = , inplace = )

- by 는 정렬할 칼럼, ascending 은 기본값 True로 오름차순, False 는 내림차순, inplace는 정렬을 원본 데이터프레임에 유지할 것인가를 정하며, 기본값 False는 원본 데이터프레임 유지, True는 원본 데이터프레임 변경입니다.

titanic_sorted = titanic_df.sort_values(by=['Name'])

- 타이타닉 데이터를 'Name'이라는 칼럼을 기준으로 오름차순으로 정렬하였습니다.

- 내림차순으로 하고 싶으면 ascending = False로 지정해주면 됩니다.

2. Aggregation 함수

- DataFrame에서 minn(), max(), sum(), count()와 같은 aggregation 함수를 이용할 수 있습니다.  호출할 경우 모든 칼럼이 aggregation을 적용한다.

titanic_df.count()

- 각 컬럼에 대한 count() 함수가 적용되어 총 수로 출력이 됩니다. 

- 원하는 컬럼에 대해서만 출력하고 싶으면 titanic_df[['Age','Fare']].mean() 을 통하여 사용가능합니다.

* 여기서 하나의 칼럼을 사용할 경우 ['칼럼명'] 이지만, 두개 이상의 칼럼인 경우 [['칼럼명','칼럼명']]으로 사용해야 합니다.

3. groupby() 

- 데이터 프레임에서 사용 시 입력 파라미터 by에 칼럼을 입력하면 대상 칼럼으로 groupby가 됩니다.

titanic_df.groupby(by='Pclass')

- 'Pclass'를 그룹화하여 결과가 출력되는 것을 확인할 수 있습니다.

titanic_df.groupby('Pclass')[['PassengerId','Survived']].count()

- 'Pclass'를 그룹화하여 'PassengerId','Survived' 두 칼럼만 뽑아 count() 함수를 적용하게 됩니다.

titanic_df.groupby('Pclass')['Age'].agg([max, min]))

- 여러 개의 Aggregation을 사용할 경우 .agg 함수를 사용합니다. 'Pclass'를 그룹화하여 나이 칼럼을 뽑아 해당 데이터들에 대해 최댓값과 최소값을 뽑아주게 됩니다.

인덱스(Index) 는 DataFrame, Series의 레코드를 고유하게 식별하는 객체이다.

# Index 객체 추출
indexes = titanic_df.index

- .index : RangeIndex(start=0, stop=891, step=1)으로 결과가 나오며 인덱스의 처음과 끝값을 range형태로 알려준다.

            식별성 데이터를 1차원 array로 가지고 있으며, 단일값 반환 및 슬라이싱도 가능하다.

            하지만, indexes[6] = 0 과 같이 한번 만들어진 DataFrame, Series, Index 객체는 함부로 변경할 수 없다.

series_fair = titanic_df['Fare']
print(series_fair.max())
print(series_fair.min())
print(sum(series_fair))

- 'Fare' 컬럼을 Series 형태로 뽑아서 저장하고 숫자로 된 데이터들은 max(), min(), sum() 등과 같은 연산 함수를 적용할 수 있다.

titanic_reset_df = titanic_df.reset_index(inplace=False)
print(titanic_reset_df)

- .reset_index() : 인덱스를 새로 만들어주는 함수로 0부터 시작하게 된다. 기존의 인덱스는 새로운 index라는 칼럼으로 titanic_df의 데이터 프레임에 추가된다. 또한 inplace = False를 통해 기존 데이터 프레임에 영향을 주지 않는다.

- 주로 인덱스가 연속된 int 숫자형 데이터가 아닐 경우에 사용한다.

- DataFrame 에서 [] 연산자

넘파이에서는  행의 위치, 열의 위치, 슬라이싱 범위 등 지정해 데이터를 가져올 수 있음

하지만 DataFrame 바로 뒤에 있는 [ ]의 안에 들어갈 수 있는 값은 컬럼명 문자, 또는 인덱스로 변환 가능한 표현식 = 칼럼을 지정할 수 있는 연산자

print(titanic_df['Pclass'].head(2))
print(titanic_df[0])

- 첫번째 프린트는 컬럼명 문자로 접근하여 출력이 가능하나, 두번째 프린트문에서는 숫자로 접근했고 해당 칼럼이 존재하지 않기 때문에 오류가 발생하게 된다.

- 하지만 판다스의인덱스 형태로 변환 가능한 표현식은 숫자도 가능 (예. titanic_df[0:2]) 하지만 비추천합니다.

titanic_df[titanic_df['Pclass'] == 3].head(3)

- 위와 같은 불린 인덱싱 표현도 가능하다. 'Pclass'가 3인 행만 추출하여 보여줄 수 있다.

명칭 기반 인덱싱과 위치 기반 인덱싱의 구분

- 명칭(label) 기반 인덱싱 : 칼럼의 명칭을 기반으로 위치를 지정하는 방식. '칼럼 명' 같이 명칭으로 열 위치를 지정하는 것

- 위치(position) 기반 인덱스  : 0을 출발점으로 하는 가로축, 세로축 좌표를 기반으로 행과 열 위치를 기반으로 데이터 지정. 따라서 행과 열 값으로 정수가 입력됨

data = {'name':['홍길동', '이순신', '김아무개'],'Age' :[20,40,35]}
data_df = pd.DataFrame(data,index = ['one','two','three'])

# data_df를 reset_index()로 새로운 숫자형 인덱스
data_df = data_df.reset_index() # -> 0부터 새로 인덱싱
data_df = data_df.rename(columns = {'index':'old_index'}) # index -> old_index로 변환

# 위치 기반 인덱싱으로 데이터 접근 
print(data_df.iloc[0,0])        # 홍길동
print(data_df.iloc[0,'name'])   # 위치기반이기 때문에 오류 발생

# 명칭 기반 인덱싱으로 데이터 접근
print(data_df.loc[0,'name']     # 홍길동
print(data_df.loc['one','name'] # 홍길동
print(data_df.loc[0:1,'name'])  # 0 홍길동 1 이순신

# 불린 인덱싱으로 데이터 접근
print(data_df[data_df['Age'] > 30)  # 1 이순신 40 2 김아무개 35

- .iloc : 위치 기반 인덱싱으로 인덱스(혹은 숫자)로만 접근 가능

- .loc : 명칭 기반 인덱싱으로 인덱스의 이름과 컬럼의 이름으로 접근 가능

- 불린 인덱싱은 여러 조건을 사용할 때 &(and), |(or), ~ (not) 을 사용할 수 있다.

앞서 csv 파일을 read_csv()를 통해 데이터 프레임형태로 불러왔습니다.

DataFrame은 파이썬의 리스트, 딕셔너리, 넘파이 ndarray로 만들 수 있고, 반대로 파이썬의 리스트, 딕셔너리, 넘파이 ndarray로 변경할 수도 있습니다.

1. 리스트, 딕셔너리, 넘파이 ndarray   -> DataFrame 만들기

import numby as np

col_name = ['col1']
list1 = [1,2,3]
array1 = np.array(list1)

# 리스트를 이용해 DataFrame 생성
df_list1 = pd.DataFrame(list1, columns=col_name)

# 넘파이 ndarray 이용하여 DataFrame 생성
df_array = pd.DataFrame(array1, colunms=col_name)

# 딕셔너리를 이용하여 DataFrame 생성
dict = {'col1':[1,2], 'col2':[3,4], 'col3':[5,6]}
df_dict = pd.DataFrame(dict)

- pd.DataFrame 을 통해 리스트와 넘파이 ndarray, 딕셔너리를 를 데이터 프레임 형태로 변경할 수 있습니다.

또한 1차원 형태이기 때문에 col_name 이 1개만 필요합니다. 

2. DataFrame -> 리스트, 딕셔너리, 넘파이 ndarray 만들기

# DataFrame을 ndarray로 변환
array1 = df_dict.values

# DataFrame을 리스트로 변환
list1 = df_dict.values.tolist()

# DataFrame을 딕셔너리로 변한
dict1 = df_dict.to_dict('list')

- .values : 기본 데이터형으로 사용. values를 통해서 데이터 프레임의 데이터를 가지고 올 수 있음

- .tolist() : .values로 ndarray 형태의 데이터를 가져온 것을 list 형태로 변환시키는 함수

- .to_dict() : 딕셔너리로 변경할 수 있는 함수로 인자에 'list'를 입력하면 딕셔너리 값이 리스트형으로 반환됨

3. DataFrame의 칼럼 데이터 세트 생성과 수정

titanic_df['Age_0'] = 0
titanic_df['Age_0'] = titanic_df['Age']*10

- 'Age_0'이라는 칼럼을 만든 후 0으로 채움 -> 'Age'의 값의 10을 곱한 값을 넣을 수도 있음

titanic_df.drop('Age_0',axis = 1)

- .drop() : 삭제를 하기 위한 함수로, 삭제할 칼럼/로우를 인자로 작성하고 axis = 0 : 행, 1 : 열로 삭제할 수 있음

- inplace = True : 원본 데이터 프레임에 드롭된 결과를 바로 적용하고 싶으면 True, 아니면 False (디폴트값)

앞에서 넘파이를 통해 배열을 생성하고 인덱싱, 정렬 등에 대해 공부하였다.

다음으로 데이터를 파이썬에서 처리하기 위해 사용하는 판다스에 대해 알아볼 것이다.

판다스(Pandas)는 파이썬의 리스트, 컬렉션, 넘파이 등의 내부 데이터뿐만 아니라 csv 등의 파일을 쉽게 DataFrame으로 변경해 데이터의 가공/분석을 편리하게 수행할 수 있게 만들어준다.

기본 판다스의 핵심 객체는 DataFrame으로, 여러 개의 행과 열로 이루어진 2차원 데이터를 담는 데이터 구조체이다.

데이터 프레임을 이해하기 전 Index, Series에 대해 이해해보도록 하겠습니다.

- Index : RDBMS의 PK 처럼 개별 데이터를 고유하게 식별하는 Key

            Series와 DataFrame은 모두 index를 key값으로 가지고 있음

- Series : 칼럼이 하나인 데이터 구조체 (DataFrame : 칼럼이 여러개인 데이터 구조체 -> Series를 여러개 가짐)

1. 판다스(Pandas) 사용 : 모듈 추가하기

import pandas as pd

2. 예제를 위해 Kaggle 의 Titanic 데이터를 다운 받겠습니다.

https://www.kaggle.com/c/titanic/data

 위의 사이트에 들어가서 로그인 / 회원가입 후 해당 대회을 신청 후 경연 참가 규정 준수를 해야 다운이 가능합니다.

다운 받은 데이터를 확인해보면 데이터들이 , 로 연결된 것으로 확인 할 수 있다.

, 로 데이터 분류한 것을 csv이라고 한다.

3. 데이터 불러오기

titanic_df = pd.read_csv('해당 타이타닉 파일 위치\titanic_train.csv')
titanic_df.head(3)

- pd.read_csv() 를 통해 데이터를 읽어 올 수 있다. 자동으로 ,를 분류하여 DafaFrame 형태로 들어옴

- .head() : 해당 인자의 숫자만큼 데이터를 보여줌

4. 데이터 확인

titanic_df.info()

- .info() : 데이터 프레임의 칼럼 타입, null의 개수, 데이터 분포 등 데이터에 대해 정보를 조회할 수 있다

titanic_df.describe()

- .describe() : 숫자형 칼럼에 대한 개략적인 데이터 분포도를 알 수 있다

 (count, mean, std, min, 25%, 50%, 75%, max) 값에 대한 정보를 보여준다.

5. value_counts()

value_counts = titanic_df['Pclass'].value_counts()
print(value_counts)

- .value_counts() : 지정된 칼럼의 데이터값을 건수로 반환하며, 데이터의 분포도를 확인하는데 매우 유용한 함수이다.

* 'Pclass'에 대한 Series를 뽑아서  value_counts()를 호출하면 해당 칼럼값의 유형과 건수 확인 할 수 있다.

1. sort() : 넘파이에서 지원해주는 np.sort() 와 ndarray.sort() 두 가지 방식으로 행렬을 정렬할 수 있다

org_array = np.array([3,1,9,5])
print("원본 : ", org_array)         # [ 3 1 9 5]

sort_array1 = np.sort(org_array)
print(sort_array1)                 # [ 1 3 5 9]
print(org_array)                   # [ 3 1 9 5]

sort_array2 = org_array.sort()
print(sort_array2)                 # None
print(org_array)                   # [ 1 3 5 9]

- np.sort() :  원본 배열을 유지, 정렬된 배열을 반환하여 변수에 저장할 수 있다. 

                기본 오름차순으로, axis = 0 : 행, axis = 1 : 열 기준으로 정렬하게 된다.

- .sort() : 원본 배열을 정렬한 채로 반환함

            기본 오름차순으로, 내림차순은 [::-1] 로 지정해주면 된다.

2. np.argsort() : 원본 행렬이 정렬되었을 때 기존 원본 행렬의 원소에 대한 인덱스를 필요로 할 때 사용

org_array = np.array([3,1,9,5])         # [ 3 1 9 5 ]
sort_indices = np.argsort(org_array)    # [ 1 3 5 9 ]
print(sort_indices)                     # [ 1 0 3 2 ]