만년필잉크의 데이터 분석 지식 저장소

리눅스 서버에 분석 환경 구축

분석을 하기 위해선 분석을 할 수 있는 환경을 만드는 것이 가장 중요하다. 아무리 수많은 분석 기법들을 알고 있더라도, 스스로 분석 환경을 구축하지 못한다면 아무것도 진행할 수 없기 때문이다.

 이전 포스트까지는 일반적으로 사용자가 사용하는 컴퓨터(Local)에 분석 환경을 구축하는 것에 대해 알아보았다. 그러나, 대용량 데이터를 다루는 현장에서는 Local PC로 데이터 분석을 진행하는 것엔 한계가 있기 때문에 분석용 서버에서 분석을 진행하게 된다.

 그러나, 대부분의 서버는 보안을 위해 오프라인으로 구축되어 있으며, 우리에게 익숙한 OS인 Windows가 아닌 Ububtu, CentOS와 같은 Linux로 설치되어 있으며, 쓸모없는 자원 낭비를 막기 위해 CLI레벨로 구성되어 있어, 실행 시 그냥 검은 화면만 나온다(우리에게 익숙한 윈도우 화면은 GUI레벨이다).

 일반적으로 서버의 환경 설정은 도커(Docker)를 이용하여 구축하지만, 단순히 파이썬(Python) 기반의 분석 환경을 구축하고자 한다면, 앞서 학습했던 아나콘다 가상 환경(Virtual Environment)만 사용해도 충분하다.

 이번 포스트에서는 오프라인 우분투(Ubuntu) 서버에 딥러닝 분석 환경을 구축하는 과정을 학습해보도록 하겠다.

1. 준비물과 진행 과정

 오프라인 서버 분석 환경 구축과 연습에는 인터넷이 되는 Local PC 하나만 있으면 충분하다. 분석 서버를 단순하게 설명해보면, "성능이 엄청나게 좋지만 인터넷이 안 되는 리눅스 OS가 설치된 컴퓨터"라고 할 수 있다.

 앞으로 우리가 진행할 과정을 간단하게 요약해보면 다음과 같다.

1. 인터넷이 되는 윈도우 컴퓨터에 분석 서버와 동일한 리눅스 배포 버전 가상 머신 설치
   (이번 포스트에서는 Ubuntu 18.04를 대상으로 하겠다.)
2. 가상 머신에 아나콘다를 설치
3. 가상 환경 생성 후, 필요한 패키지 모두 설치 및 이를 압축하여 외부로 내보내기
4. 사용하고자 하는 텐서플로우(파이토치) 버전에 맞는 Cuda, Cudnn 다운로드
5. 압축된 가상환경, 아나콘다 설치 파일, Cuda, Cudnn을 인터넷이 안되는 리눅스 서버에 이동시키기
   (가상 머신을 새로 만들고, 인터넷 선을 뽑은 후 진행하면, 오프라인 우분투 서버가 된다.)
6. 이동된 파일 모두 설치

 꽤 복잡해 보이지만, 익숙하지 않아서 그렇지, 앞서 다뤄봤던 윈도우 환경에서 분석 환경 설정하는 방법과 동일하다.

2. 가상 머신(우분투) 설치하기 - wsl2

 가상 머신을 설치하는 방법을 두 가지 소개해보자면, 다음과 같다.

1. Virtual Machine 프로그램을 사용하여, 가상 머신 만들기
2. wsl2를 사용하여, 가상 머신 만들기

 Virtual Machine 프로그램을 사용하면, 내 컴퓨터에 작은 컴퓨터를 만드는 것처럼 진행할 수 있지만, 과정이 꽤 복잡하고, 자원을 분리해서 사용하며, 가상 머신 종료 등의 과정이 꽤 번거롭기 때문에, 이번 포스트에서는 마이크로 소프트의 wsl2를 사용해서 가상 머신을 만들어보도록 하겠다.

2.1. wsl2(Windows Subsystem for Linux 2)

• wsl2는 Linux용 Windows 하위 시스템의 약자로, Virtual Machine보다 쉽게 가상 머신을 만들 수 있다.
• 자원도 따로 나눌 필요가 없으며, 머신 종료 등의 번거로운 과정이 매우 간단한다.
• 윈도우에서 도커(Docker)나 리눅스 개발을 할 수 있다.

2.2. wsl2 설치 및 주의 사항

• wsl2 설치는 마이크로 소프트 공식 홈페이지에서 아주 쉽게 설명해주고 있으므로, 기본적으로 해당 웹사이트를 참고하기 바란다.
• wsl2는 다음과 같은 주의 사항을 반드시 따라야만 사용할 수 있다.

1. 윈도우10 업데이트가 최신 버전일 것: 윈도우 업데이트 확인은 "시작 버튼의 설정 > 업데이트 및 보안"을 통해 확인할 수 있다. "업데이트 확인"을 해본 후, 윈도우 업데이트를 실시하고, 만약 wsl2가 정상적으로 설치되지 않는다면, 컴퓨터를 재부팅하여 업데이트를 마무리해주길 바란다.
2. CPU가 너무 구형이 아닐 것: Hyper-V를 구동시켜야만, wsl2와 같은 가상 머신을 사용할 수 있다. 2010년대 이전 CPU는 Hyper-V를 지원하지 않는 경우가 꽤 많으므로, 주의하길 바란다.
3. 가상화 설정: "작업 관리자 > 성능"으로 들어가서 CPU의 가상화가 "사용"으로 되어 있는지 확인한다. 만약 사용이 안되어 있는 경우, BIOS에 들어가서 가상화를 설정해주어야 한다(메인보드 제조사마다 방식이 다르므로, 자신의 메인보드에 맞는 방법을 찾도록 하자).

• 설명에서 헷갈릴 수 있는 부분은 "PowerShell의 관리자 권한 실행"이라 생각되는데, 시작 옆의 검색 기능을 이용하면 쉽게 할 수 있다.

• 이번 학습에서 Linux는 Ubuntu 18.04를 사용할 것이지만, 자신이 다루고자 하는 서버의 리눅스 환경이 다른 경우, 자신에게 맞는 것을 설치하면 된다(명령어는 크게 다르지 않으며, 명령어가 다르더라도 과정은 동일하다)
• 윈도우 터미널(Windows Terminal)을 마이크로소프트 스토어(Microsoft store)에서 설치하면, 보다 쉽게 wsl2의 기능을 사용할 수 있지만, 이번 포스트에서는 서버 환경과 동일한 상황에서 보기 위해 설치한 Ubuntu에서 진행해보겠다.

2.3. wsl2 설치 완료 후, 우분투 구동

• 우분투 설치 후, 설치된 파일을 실행해주자
• 실행 후, ID와 Password는 자신이 원하는 것으로 아무거나 입력해주면 된다.
• 그 후, 아래와 같은 화면으로 이동해주자.

3. 아나콘다 설치하기

• 설치된 가상 환경에 어떤 파일이 있는지 확인해보자.

ll

• ll: 현 디렉토리에 있는 파일들을 모두 보여주며, 해당 파일의 권한 등을 색으로 표현해준다.
  (만약, 위와 같은 화면이 나오지 않는다면, cd를 입력하고 enter를 쳐서, 기본 디렉토리로 이동해주자)

3.1. Download 디렉토리 생성

• Download 디렉토리를 생성하여, 앞으로 다운로드할 파일들이 저장될 공간을 분리해주자.
  (필수는 아니지만 디렉토리 정리가 잘될수록 관리가 쉬워지므로, 가능하면 꼭 해주도록 하자.)

mkdir Download
ll

• mkdir 디렉토리_이름: "디렉토리_이름"을 현 디렉토리에 생성한다.

3.2. 아나콘다 설치 파일을 Download 디렉토리에 설치하자

• 아나콘다를 설치하는 방법은 이전에 다뤘던 "python 파이썬과 아나콘다" 포스트와 거의 유사하다.
• 해당 포스트를 참고하여 아래 화면으로 이동해보자.
  (아나콘다 버전에 따라 UI가 조금씩 달라질 수 있지만, 기본적인 방법은 같다)

• Ubuntu는 Linux의 버전 중 하나이므로, Linux installer를 누르면 된다.
• Tensorflow를 사용할 것이므로 64Bit를 다운로드 받아야한다.
• "마우스 오른쪽 클릭 > 위 빨간 박스를 클릭"하여, 다운로드 받을 파일의 링크 주소를 복사하자.

cd Download
wget https://repo.anaconda.com/archive/Anaconda3-2020.11-Linux-x86_64.sh
ll

• 리눅스 화면에서 복사는, 복사하고 싶은 구간 드래그이며, 붙여 넣기는 커서에 마우스 오른쪽 클릭을 하면 된다.

• wget 링크_주소: 인터넷에서 "링크_주소"에 해당하는 파일을 다운로드한다.

3.3. 아나콘다 설치 파일 권한 부여 및 실행

• 설치된 아나콘다 설치 파일의 색을 보면, 흰색으로 되어 있는 것을 볼 수 있다.
• 해당 파일을 실행하기 위해 권한을 부여해보도록 하자.

chmod 755 Anaconda3-2020.11-Linux-x86_64.sh
ll

• 권한이 부여되어 파일의 색이 녹색으로 바뀐 것을 볼 수 있다.
• 해당 파일을 실행해보자.

./Anaconda3-2020.11-Linux-x86_64.sh

• Enter를 눌러, 쭉 진행해보자.

• 뭔가 엄청나게 많은 글이 뜨는데, 아나콘다 설치에 대한 약관이므로, 계속 엔터를 눌러 약관을 끝까지 내려주자.

• yes를 입력하여 설치를 진행해주자.

• Enter를 눌러서 아래 경로에 아나콘다를 설치해주자

• yes를 입력해서, conda init 명령어로 Anaconda를 초기화 해주자.

3.4. 아나콘다 PATH 설정

• 위 과정까지 진행했다면, linux를 종료했다가 다시 키거나, bashrc를 실행하여 PATH를 설정해줘야 한다.

source ~/.bashrc

• 위 코드를 진행하면, 맨 왼쪽의 녹색 이름 옆에 (base)라는 글이 붙은 것을 볼 수 있다.
• 이는, 아나콘다 쉘이 실행된 것으로, 성공적으로 아나콘다가 설치 및 실행된 것을 볼 수 있다.
• 초기 화면으로 빠져나와, 설치된 아나콘다를 확인해보자.

cd
ll

• 위 사진을 보면, 성공적으로 anaconda3가 설치된 것을 볼 수 있다.

 지금까지 윈도우에 리눅스 기반 가상머신을 설치하고, 해당 가상머신에 아나콘다를 설치해보았다. 위 과정은 아나콘다 설치 파일을 다운로드하는 과정까지만 인터넷이 필요하며, 이후의 과정에서는 오프라인으로 진행해도 된다.

 즉, 위 과정은 이후 분석 서버에 환경을 구축할 때도 다시 한번 진행되는 내용이다.

 다음 포스트에서는 아나콘다 가상 환경을 만들고, 이를 압축하여, 외부로 내보내는 방법에 대해 알아보도록 하겠다.

 DataFrame을 가지고 노려면, 기본적으로 Index와 Column 그리고 내가 원하는 값을 가지고 오는 법을 알아야 한다. 이전 포스트에서 Index를 가지고 노는 법에 대해 알아보았으니, 이번 포스트에서는 Column을 가지고 노는 방법에 대해 알아보도록 하겠다.

데이터 프레임과 칼럼(Column)

 이전 포스트에서 알아보았던, Index는 내가 원하는 Row(행, 레코드, 튜플)를 가지고 놀 수 있는 방법이었고, 이번에 학습할 Column은 열(변수, 속성, 필드)을 가지고 놀 수 있는 방법이다.

 DataFrame은 각 Column마다 담겨 있는 데이터의 양은 같으나, 담을 수 있는 데이터가 다르므로, 칼럼을 잘 가지고 놀 수 있어야만, DataFrame을 조작하기 쉬워진다.

1. 데이터 프레임의 기본 칼럼

• 이전 "Pandas-데이터프레임 만들기"에서는 칼럼의 이름을 다 지정해줬었지만, 만약 데이터 프레임의 칼럼을 지정해주지 않는다면 어떻게 될까?

# Import Module
import pandas as pd
import numpy as np

# 기본 데이터 만들기
>>> np.random.seed(1234)
>>> matrix = np.random.randint(10, 100, size = (5,4))
>>> matrix
array([[57, 93, 48, 63],
       [86, 34, 25, 59],
       [33, 36, 40, 53],
       [40, 36, 68, 79],
       [90, 83, 57, 60]])

• numpy의 array를 이용해서 단순한 행렬을 만들어보았다.
• np.random.seed(): seed를 정해서 고정된 난수가 출력되도록 한다. 자신이 원하는 아무 숫자를 안에 넣고 실행 시, 그 seed에 대해 출력되는 난수는 동일한 값만 나오게 된다.
• np.random.randint(low, high, size, dtype): low에서 high까지 자신이 지정한 size(shape)로 랜덤한 값이 출력된다.

>>> DF = pd.DataFrame(matrix)
>>> DF

• 칼럼을 지정하지 않고 DataFrame을 만들면 Index와 마찬가지로 0부터 시작하는 값이 매겨진다.

1.1. RangeIndex

• 이렇게 0부터 시작하는 index가 매겨지는 것을 RangeIndex라고 하는데, Python의 기본 함수인 range랑 그 기능이 거의 비슷하다.

# RangeIndex 생성
>>> pd.RangeIndex(10)
RangeIndex(start=0, stop=10, step=1)

# RangeIndex의 값을 list로 바꿔주자.
>>> list(pd.RangeIndex(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# range와 비교
>>> range(10)
range(0, 10)

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• RangeIndex 역시 range처럼 특정 간격을 가지고 Data를 생성할 수 있으며, 객체의 값을 활성화해주지 않으면, 그 내용물이 튀어나오지 않는다.

# 시작, 끝, 간격을 조정해보자.
>>> pd.RangeIndex(start=10, stop = 30, step=2)
RangeIndex(start=10, stop=30, step=2)

>>> list(pd.RangeIndex(start=10, stop = 30, step=2))
[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

# 위 기능은 range와 같다.
>>> range(10, 30, 2)
range(10, 30, 2)

>>> list(range(10, 30, 2))
[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

• index는 많은 양의 Data를 담는 DataFrame 특성 상, 그 숫자가 매우 커질 수 있기 때문에 range와 마찬가지로 이를 바로 출력하지 않고, 호출 시 출력한다.
• RangeIndex는 크게 신경 쓸 것은 아니지만, DataFrame을 조작하다가 칼럼의 이름을 지정할 수 없는 경우가 있다. 이럴 때는 RangeIndex가 출력되므로, 이를 조작할 수는 있어야 한다.

2. Column의 이름 바꾸기

• DataFrame의 Column이름을 바꾸는 방법은 크게 두 가지가 있다.

1. 한 번에 다 바꾸기
2. 내가 원하는 Column의 이름만 바꾸기

2.1. Column의 이름 한 번에 다 바꾸기

>>> DF.columns = ["C1", "C2", "C3", "C4"]
>>> DF

>>> DF.columns
Index(['C1', 'C2', 'C3', 'C4'], dtype='object')

>>> type(DF.columns)
pandas.core.indexes.base.Index

• DataFrame.columns: DataFrame의 Column을 조작하는 가장 기본적인 방법으로 DataFrame의 Column을 pandas index라는 type으로 가지고 온다. array와 유사하므로, array라고 생각해도 큰 문제는 없다.

2.2. 특정 Column의 이름만 바꾸기

• 칼럼 C1은 math로 C3는 English로 바꿔보자.

>>> DF.rename(columns={"C1":"math", "C3":"English"}, inplace = True)
>>> DF

• DataFrame.rename(columns={"old":"new"}, inplace=False): DataFrame의 old 컬럼을 new 컬럼으로 이름을 바꾼다.
• 이번에는 C2를 math로 바꿔보자.

>>> DF.rename(columns={"C2":"math"}, inplace = True)
>>> DF

• DataFrame의 컬럼 역시 Index처럼 이름이 중복된다.
• 뒤에서 다시 다루겠지만, Index처럼 같은 이름의 컬럼 출력 시, 동일한 컬럼이 생성된다.

>>> DF.math

3. Column이름들을 꾸며주기

• DataFrame의 컬럼의 이름은 위에서 봤듯이 중복될 수도 있고, DataFrame.columns라는 함수를 통해, array를 다루듯 조작할 수도 있다.
• 또한, Column의 이름들에 특정한 패턴으로 한 번에 조작을 해줄 수도 있다.
• 해당 예시를 보기 전에 조작이 쉽도록, 변수들의 이름을 전부 바꿔주었다.

DF.columns = ["mid math", "mid English", "fin math", "fin English"]

3.1. 컬럼명의 특정 문자 바꿔주기

>>> DF.columns = DF.columns.str.replace(" ", "_")
>>> DF

• DataFrame.columns.str.replace(pat, repl): 판다스의 str모듈은 문자열 데이터를 다루는데 특화된 함수의 모음으로, 보통 칼럼 각각에 적용하지만, 칼럼의 이름에도 적용 가능하다.
• 컬럼을 다룰 때, 공백이 있는 경우 조작이 조금 불편해지므로, 가능한 공백은 언더바("_")로 치환하도록 하자.
• str 모듈은 굉장히 유용한 함수들을 모아놓은 모듈이므로, 추후 자세히 다루도록 하겠다.

3.2. 모든 컬럼명 앞에 공통 문자 붙이기

>>> DF.add_prefix("A__")

3.3. 모든 컬럼명 뒤에 공통 문자 붙이기

>>> DF.add_suffix("_Dummy")

• 컬럼명의 앞이나 뒤에 공통된 문자를 붙여주는 기능은 데이터 전처리 시, 더미 변수를 만들거나, One-Hot Vector 등을 만들 때, 쉽게 쓸 수 있다.
• 지금처럼 모든 변수들에게 특정 문자를 붙이는 것보다는, 특정 컬럼들만 선택하여, 공통 문자를 바꾸는 것이 더 효과적이다. 이는 추후 컬럼 조회를 학습하면서 공부하도록 하겠다.

 지금까지 컬럼명을 가지고 노는 방법에 대해 학습해 보았다. 다음 포스트에서는 컬럼명을 가지고 놀 수 있는 다른 방법에 대해 학습해보도록 하겠다.

 이전 포스트에서 DataFrame의 생김새와 부위별 이름에 대해 알아보았다. DataFrame의 가장 큰 특징은 index가 존재한다는 것이고, 이 index를 얼마나 잘 가지고 노느냐에 따라 DataFrame을 얼마나 효율적으로 사용할 수 있는지가 나뉘게 된다.

데이터 프레임과 인덱스

 Pandas에 대해 흔히들 가지고 있는 오해가 Pandas는 순차적으로 데이터를 조회하기 때문에, 데이터 전처리 속도가 매우 느리다는 것이다.

 이 말은 반은 맞고, 반은 틀리다고 할 수 있는데, DataFrame에서 특정 데이터를 단순하게 조회하면, 순서대로 하나하나 조회하기 때문에 속도가 매우 느려지고, 도리어 이 특징을 이용해서, 데이터 전처리 속도를 줄일 수도 있다.

 그러나, 인덱스를 사용하여 조회를 하게 된다면, 순차적 조회가 아닌 한 번에 index에 해당하는 값을 가지고 오기 때문에 조회 속도가 엄청 빨라진다.

 그러므로, Pandas를 사용해야 하는 데이터 분석가라면 반드시 이 인덱스를 잘 가지고 놀 수 있어야 한다.

1. DataFrame 생성 시, 원하는 Index 부여하기

• index는 DataFrame을 생성하면서 부여할 수도 있고, DataFrame을 생성한 후에도 바꿔줄 수 있다.
• 다음과 같은 데이터 셋을 만들어보자.

import pandas as pd

name_list = ["박명수", "유재석", "노홍철", "길", "정준하", "정형돈", "하하"]
math_list = [65, 95, 70, 80, 100, 85, 60]
english_list = [75, 80, 85, 90, 65, 75, 100]
class_list = [1, 2, 1, 2, 2, 2, 1]
index_list = list(range(10, 24, 2))

exam = pd.DataFrame({"name":name_list, "math":math_list, "english":english_list,
                     "class":class_list}, index=index_list)
exam

• range(start, end, by): start부터 end까지 값을 by 간격으로 만들 준비를 한다.
  (list 함수 같은 것으로 가동해주지 않으면, 대기 상태를 유지한다)
• 생성된 데이터 프레임을 보듯, 데이터 프레임 생성 시, index 파라미터에 넣어준 list를 index로 부여한다.

2. 내가 원하는 칼럼을 index로 부여하기

• 이미 index가 정해졌다 할지라도, index는 내가 원하는 칼럼을 index로 만들어줄 수 있다.

exam.set_index("name", inplace=True)
exam

• DataFrame.set_index(column, drop=True, append=False, inplace=False): set_index()는 말 그대로, 내가 원하는 칼럼을 index로 설정해주는 함수다.
• drop 파라미터는 기존 칼럼을 index로 넣을 때, 기존 칼럼을 말 그대로 버려버릴지를 묻는 것이다.
• append 파라미터는 기존 인덱스에 내가 원하는 칼럼까지 추가해서 인덱스를 만들지를 묻는 것이다.
• inplace 파라미터는 원본 데이터에 덮어씌울지를 물어보는 것이다. 여기서는 inplace = True를 하였으므로, index가 바뀐 것을 바로 원본에 적용하였다.
• 중복되는 값이라 할지라도 index로 만들 수 있다.

exam.set_index("class", inplace=True)
exam

• 데이터 프레임의 인덱스에 대해 "중복이 돼서는 안 되는 유니크한 값이어야 한다."라 오해를 하는 경우가 종종 있는데, 위에서 보시다시피 중복이 가능하다. 이는, 데이터 프레임의 인덱스의 특징이며, 이 특징을 잘 이용하는 것이 중요하다.
• 데이터 프레임의 인덱스는 중복 가능하므로, 조회 시, 해당 인덱스에 해당하는 값을 모두 가지고 온다.

exam.loc[2]

• DataFrame.loc[index]: index에 해당하는 행을 조회하는 방법으로 추후 자세히 다루도록 하겠다.

3. 인덱스 초기화

• 무한도전 멤버들의 이름을 인덱스로 했었다가 class로 인덱스를 설정하니, 무한도전 멤버들의 이름이 사라져 버렸다.
• 이는 DataFrame.set_index()는 기본적으로 기존 index를 없애는 것을 전재로 하기 때문이다.
• 이러한 일을 막기 위해선 set_index()를 하기 전에 인덱스를 초기화해줘야 한다.

exam.reset_index(drop = False, inplace = True)
exam

• DataFrame.reset_index(drop=False, inplace=False): reset_index는 인덱스를 말 그대로 초기화시켜버린다.
• drop 파라미터는 기존의 index를 버릴지 말지를 결정하는 파라미터다
• 무한도전 멤버들의 이름이 index인 상태에서 reset_index()하고 set_index()를 하였다면, 이번처럼 기존 인덱스가 날아가버리는 일을 막을 수 있다.

4. 새로운 list를 인덱스로 부여하고 인덱스를 조작해보자

• 처음에 만들었던, name_list를 index로 부여하여, 무한도전 멤버의 이름이 index인 상태로 돌아가 보자.

exam.index = name_list
exam

• DataFrame.index: DataFrame의 index를 조작할 수 있다.
• 이전에는 index의 이름이 name으로 나왔으나, index는 본래 이름이 따로 없기 때문에 index의 이름이 없는 상태로 출력된 것을 볼 수 있다.

4.1. 인덱스 이름 부여

exam.index.name = "name"
exam

• DataFrame.index는 뒤에 다른 함수들을 붙여 추가적인 기능들을 실행할 수 있다.
• 이번에는 DataFrame.index.name으로 하여 index의 이름을 부여해보았다.

4.2. 인덱스 데이터 추출

>>> exam.index
Index(['박명수', '유재석', '노홍철', '길', '정준하', '정형돈', '하하'], dtype='object', name='name')

• list를 index에 넣었듯, array로 index를 뽑아낼 수도 있다.
• 이러한 index 조작은 데이터 프레임을 다룰 때, 상당히 쓸모 있는 기술이므로 꼭 숙지하도록 하자.

5. 멀티 인덱스(Multi index)와 인덱스를 기준으로 정렬

• 멀티 인덱스는 말 그대로 index를 한 번에 여러 개 사용하는 방법이다.
• 무한도전 멤버의 이름을 칼럼으로 되돌리고, class, name으로 멀티 인덱싱을 해보자.

exam.reset_index(drop=False, inplace=True)
exam.set_index(["class", "name"], inplace = True)
exam

• 멀티 인덱스는 set_index(column)에서 칼럼을 여러 개 넣어서 실시할 수 있다.
• 멀티 인덱스를 하고 나니, class 2의 길, 정준하, 정형돈의 class가 하나로 붙어 깔끔하게 나온 것을 볼 수 있다.
• 그러나, 썩 깔끔해 보이지 않으므로 인덱스를 기준으로 정렬시켜보자.

5.1. 인덱스 기준 정렬

exam.sort_index(inplace=True)
exam

• DataFrame.sort_index(ascending=True, inplace=False): 말 그대로 index순으로 정렬(sort)한다.
• ascending 파라미터는 오름차순, 내림차순을 의미하며, 기본적으로 오름차순 정렬이 실행된다.

5.2. 멀티 인덱스의 실제 모습

• 멀티 인덱스를 실행하게 되면, 데이터의 형태를 보다 쉽게 파악할 수 있다는 장점이 있다. 때문에 멀티 인덱스는 group_by를 하여 두 집단 이상의 기술 통계량을 볼 때, 멀티 인덱스로 출력되게 된다.
• 멀티 인덱스를 하면, class는 하나의 index로 뭉친 것처럼 보이는데, 눈에만 저렇게 보이지 실제로는 따로 떨어져 있다.

>>> exam.index
MultiIndex([(1, '노홍철'),
            (1, '박명수'),
            (1,  '하하'),
            (2,   '길'),
            (2, '유재석'),
            (2, '정준하'),
            (2, '정형돈')],
           names=['class', 'name'])

• exam의 index를 보면, 튜플로 묶여 있는 것을 볼 수 있다.

5.3. 멀티 인덱스 해제

exam.reset_index(drop=False)

• 멀티 인덱스 해제는 reset_index()를 하여 쉽게 할 수 있다.

 지금까지 판다스에서 인덱스를 가지고 노는 법에 대해 학습해보았다. 판다스에서 인덱스를 얼마나 잘 활용하느냐에 따라 판다스의 속도는 크게 변하므로, 인덱스를 잘 활용하길 바란다.

 이전 포스트에서 데이터 프레임을 만들어보았으니, 이번에는 데이터 프레임의 부위별 이름을 알아보자.

데이터 프레임의 구조와 용어 정리

• 위 표는 우리가 지금까지 봐온 데이터 프레임이다. 데이터 프레임의 생김새는 우리가 자주 봐왔던 표(Table)처럼 생겼다.
• Data를 사용하는 분야에서 기본적으로 사용하는 관계형 데이터베이스(Relational Database, RDM)의 테이블(Table)도 데이터 프레임과 동일하게 생겼다.
• RDB를 여기저기서 많이 사용하다 보니, 그 용어를 데이터 프레임에도 사용하는 경우가 많기 때문에, RDB에서 사용하는 용어도 함께 정리하도록 하겠다.

1. 칼럼(Column)

• 칼럼(Column)은 단어 그대로 열을 의미하며, 행과 열을 가진 데이터에서 열은 모두 칼럼이라고 불린다.
• 변수(Variable), 속성(Attribute), 필드(Field)라고도 불린다.
• 데이터에서 객체(대상)가 가지고 있는 특징이 들어간다.
• 예를 들어, 이름, 성별, 나이와 같은 대상 집단이 가지고 있는 특징이다.
• 차수(Degree): RDB에서는 칼럼의 수를 가리킨다.
  예) 위 테이블의 Degree는 11이다.
• 도메인(Domain): RDB에서 한 칼럼에서 가질 수 있는 값의 집합
  예) 성별의 도메인은 "남", "여" 둘 뿐이며, 그 외의 값은 들어갈 수 없다.

2. 로우(Row)

• 말 그대로 행을 가리키며, 데이터 하나하나를 의미한다. 그러다 보니, 모양이 데이터 프레임과 조금 다르더라도, 데이터 하나하나를 지칭할 때, 단순하게 Row라고 부르기도 한다.
• 튜플(Tuple), 레코드(Record)라고도 불린다.
• 데이터의 대상이 되는 객체 하나하나를 의미한다.
• 예를 들어, 위 데이터 프레임에서 index가 417번인 사람은, 고객번호(PassengerId)가 1309번이고, 이름이 Peter, Master. Michael J이며, 성별이 male인 사람이다.
• 카디널리티(Cardinality): 행의 총 개수이다.

3. 인덱스(Index)

• 데이터 프레임만의 특징으로, index는 중복될 수도 있고, 동일한 index에 해당하는 row의 값이 다를 수도 있다.
• index를 어떻게 조작하느냐에 따라, 데이터 프레임에서의 데이터 조회 속도 차이가 엄청 커진다.
• RDB의 key와 유사해 보이지만, RDB의 key는 고유 개체를 식별할 수 있는 유니크한 값임에 반해, 데이터 프레임의 index는 중복이 가능하고, index가 동일하나, row에 있는 값은 다를 수 있으므로, key와 굉장히 다르다.

 지금까지 데이터 프레임의 행, 열의 다른 용어와 그것이 의미하는 바에 대해 간단히 다뤄봤다. 위 단어 외에도 인스턴스(Instance), 엔티티(Entity)와 같은 다양한 단어가 있으나, 데이터 프레임이던 테이블이던 기본적으로 행과 열이 중심이기 때문에 위 용어만 알면, 데이터에 대한 기본적인 의사소통은 할 수 있을 것이다.

 다음 포스트에서는 index를 가지고 노는 방법에 대해 학습해보도록 하겠다.

 이전 포스트에서 판다스(Pandas)가 무엇인지 간단한 소개와 판다스의 대표적인 데이터 타입인 데이터 프레임(DataFrame)과 시리즈(Series)를 살펴보았다.

 이번 포스트는 판다스의 상징인 데이터 프레임을 만드는 방법에 대해 알아보도록 하겠다.

데이터 프레임 만들기

1. 판다스 가져오기

• 판다스를 사용하기 앞서 먼저 판다스를 설치하고 판다스를 사용하겠다고 선언해보자.
• Python 모듈 설치는 크게 Anaconda를 사용하여 일반적으로 사용하는 Pandas를 포함한 각종 라이브러리를 한 번에 다운로드하는 방법이 있고, pip를 이용해서 다운로드하는 방법이 있다.
• 해당 방법을 서술하기엔 그 내용이 꽤 길고 헷갈리기 쉽기 때문에 Pandas를 비롯한 각종 라이브러리를 설치하는 방법이 적힌 이전 포스트로 가는 참조를 걸어놓겠다.
• 참고 1 - 라이브러리 설치 방법: "Python 필요한 모듈들을 설치해보자"
• 참고 2 - Anaconda 설치 방법: "Python 파이썬과 아나콘다"
• 참고 3 - 오프라인 환경에서 라이브러리 설치 방법: "Python 오프라인 환경에서 파이썬 패키지를 설치해보자"
• 위 방법대로 Pandas를 정상적으로 설치하였다는 전제하에 Pandas에 대해 학습해보도록 하겠다.

# Import module
import pandas as pd

• Python에서 #은 주석을 만드는 특수 문자로 코드(Syntax) 앞에 입력 시, 해당 행의 명령어들을 주석 처리한다.
• import pandas as pd는 문자 그대로 "import(수입하다) pandas as(처럼) pd"로, pandas를 가지고 오는데 pd라는 문자로 가지고 온다는 의미이다.
• Python은 특정 라이브러리 내 함수를 사용하려면 "라이브러리.함수()" 이런 식으로 코드를 짜게 되는데, pandas는 제법 긴 단어이므로 pd라는 간결한 단어로 라이브러리를 의미하겠다는 소리다.
• 일반적으로 pandas는 pd라 사용하니 pd로 쓰도록 하자.

2. 데이터 프레임 함수 설명

• pandas에서 제공하는 DataFrame API에서 DataFrame이 가지고 있는 파라미터(Parameter)는 다음과 같다.
• pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
• data: list나 numpy에서 제공하는 array, dictionary 등을 받는다. 간단하게 생각해서 행렬이나 벡터를 Data로 사용할 수 있다고 생각하면 된다.
• index: 이전 포스트에서 말했듯, pandas의 데이터 프레임이나 시리즈의 특징은 index를 갖는다는 것이다. 그리고 사용자가 원하는 index를 부여할 수 있다. 지정하지 않은 경우, 자동으로 range(0, len(data))에 해당하는 index가 생성된다.
• columns: 열, 즉 변수의 이름이다.
• dtype: DataFrame 안에 들어갈 데이터의 type을 결정한다. DataFrame의 장점은 변수 별로 다른 dtype이 들어갈 수 있는 것이므로, 특수한 경우가 아닌 이상 지정 안 한다.
• copy: DataFrame의 특징 중 하나인, Data의 종속성에 대한 부분인데, 이는 나중에 다루도록 하겠다. 크게 신경 쓰지 않아도 된다.

3. 행렬(2-d array)을 사용해서 데이터 프레임 만들기

• 2-d array는 2차원 배열을 의미하며, 우리에게 친숙한 행렬이 2-d array다.
• 머신러닝 라이브러리인 sklearn에서 제공하는 붓꽃 데이터를 이용해서 행렬을 보도록 하자.

import numpy as np
from sklearn.datasets import load_iris

• numpy는 선형 대수학에 특화된 라이브러리로 다른 포스팅에서 자세히 다룰 테니 일단 넘어가자(당장 쓰지 않더라도 Pandas를 쓸 때는 꼭 numpy도 import 해놓는 습관을 들여놓자. 나중에 아주 많이 쓰게 될 것이다.)
• from sklearn.datasets import load_iris는 sklearn의 dataset이라는 모듈에서 load_iris라는 함수만 가져오겠다는 뜻이다. 특정 라이브러리에서 한, 두 개의 함수만 필요한 경우에 사용하는 방법이다.

>>> iris = load_iris()
>>> iris
{'data': array([[5.1, 3.5, 1.4, 0.2],
        [4.9, 3. , 1.4, 0.2],
        [4.7, 3.2, 1.3, 0.2],
        [4.6, 3.1, 1.5, 0.2],
        [5. , 3.6, 1.4, 0.2],
        [5.4, 3.9, 1.7, 0.4],
        
...

lustering system finds 3 classes in the data.\n   - Many, many more ...',
 'feature_names': ['sepal length (cm)',
  'sepal width (cm)',
  'petal length (cm)',
  'petal width (cm)'],
 'filename': 'C:\\Users\\gooop\\anaconda3\\lib\\site-packages\\sklearn\\datasets\\data\\iris.csv'}

• 해당 블로그에서 >>> 는 코드 실행을 의미하며, 앞에 >>>가 없는 것은 출력된 결과를 의미한다. 한 셀 안에 >>>가 없는 경우, 출력된 결과가 없기 때문에 >>>를 쓰지 않은 것이다.
• load_iris()를 실행 시, dictionary가 출력된다. dictionary는 여러 종류의 데이터를 key:value로 담을 수 있는 사전이다.
• dictionary를 key로 조회 시, 원하는 value만 볼 수 있다.

# iris data에 있는 key를 보자
>>> iris.keys()
dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename'])

• iris 데이터가 가지고 있는 key를 보면, data, target, frame 등 여러 key가 존재하는 것을 알 수 있다.
• 여기서 "data"는 iris data를 의미한다.
• "feature_names"는 변수의 이름이다.

>>> iris["data"]
array([[5.1, 3.5, 1.4, 0.2],
       [4.9, 3. , 1.4, 0.2],
       [4.7, 3.2, 1.3, 0.2],
       [4.6, 3.1, 1.5, 0.2],
       [5. , 3.6, 1.4, 0.2],
       
...

       [6.7, 3. , 5.2, 2.3],
       [6.3, 2.5, 5. , 1.9],
       [6.5, 3. , 5.2, 2. ],
       [6.2, 3.4, 5.4, 2.3],
       [5.9, 3. , 5.1, 1.8]])

• 데이터가 매우 크므로 중간을 생략하였다. 위 데이터 같이 행과 열로 2개의 차원(dimension)이 존재하는 데이터를 2차원 배열 2-d array라고 한다.

>>> iris["feature_names"]
['sepal length (cm)',
 'sepal width (cm)',
 'petal length (cm)',
 'petal width (cm)']

• 칼럼 이름은 list로 출력되었다.
• 위 두 데이터를 사용해서 데이터 프레임을 생성해보자.

>>> iris_DF = pd.DataFrame(data=iris["data"], columns=iris["feature_names"])

• DataFrame은 주피터 노트북 기준 한 번에 60개의 행이 조회되며, 아래에 있는 150 rows x 4 columns는 150개의 행과 4개의 열을 가진 데이터라는 것을 의미한다.

>>> iris_DF.values
array([[5.1, 3.5, 1.4, 0.2],
       [4.9, 3. , 1.4, 0.2],
       [4.7, 3.2, 1.3, 0.2],
       [4.6, 3.1, 1.5, 0.2],
       [5. , 3.6, 1.4, 0.2],
       
...

       [6.7, 3. , 5.2, 2.3],
       [6.3, 2.5, 5. , 1.9],
       [6.5, 3. , 5.2, 2. ],
       [6.2, 3.4, 5.4, 2.3],
       [5.9, 3. , 5.1, 1.8]])

• DataFrame.values 함수를 사용하면, DataFrame을 2-d array로 돌릴 수 있다. 꽤 중요한 기능이니 꼭 숙지하도록 하자.

4. list를 사용해서 데이터 프레임 만들기

• 이번엔 list를 이용해서 데이터 프레임을 만들어보자.
• list는 Python에서 대표적인 Data를 담는 그릇이다.

>>> name_list = ["박명수", "유재석", "노홍철", "길", "정준하", "정형돈", "하하"]
>>> math_list = [65, 95, 70, 80, 100, 85, 60]
>>> english_list = [75, 80, 85, 90, 65, 75, 100]
>>> exam = pd.DataFrame({"name":name_list, "math":math_list, "english":english_list})
>>> exam

• 데이터 프레임은 위 결과처럼 각 변수(열) 별로 다른 dtype이 들어갈 수 있다.

5. Dictionary를 사용해서 데이터 프레임 만들기

• Dictionary는 모든 형태의 데이터를 Key:value의 형태로 담을 수 있는 데이터 타입이다.
• Dictionary의 형태는 조금만 편집해서 바로 Json으로 사용할 수 있을 정도로 Json과 굉장히 유사하다.
• Dictionary의 value들이 모두 list 또는 array이고, 그 길이가 동일하다면, DataFrame으로 만들 수 있다.
  (길이가 다르다면, 오류가 뜬다)

>>> Raw_dict = {
>>>     "name":["박명수", "유재석", "노홍철", "길", "정준하", "정형돈", "하하"],
>>>             "math":[65, 95, 70, 80, 100, 85, 60],
>>>             "english":[75, 80, 85, 90, 65, 75, 100],
>>>             "class":[1, 2, 1, 2, 2, 2, 1]
>>> }

>>> Raw_dict

{'name': ['박명수', '유재석', '노홍철', '길', '정준하', '정형돈', '하하'],
 'math': [65, 95, 70, 80, 100, 85, 60],
 'english': [75, 80, 85, 90, 65, 75, 100],
 'class': [1, 2, 1, 2, 2, 2, 1]}

DF = pd.DataFrame(Raw_dict)
DF

• Dictionary는 key와 value로 이루어져 있으므로, 별도의 컬럼 이름을 지정해주지 않아도 DataFrame으로 쉽게 전환이 가능하다.
• 반대로 DataFrame을 Dictionary로 변환하는 것 역시 굉장히 간단하다.

>>> DF.to_dict()
{'name': {0: '박명수', 1: '유재석', 2: '노홍철', 3: '길', 4: '정준하', 5: '정형돈', 6: '하하'},
 'math': {0: 65, 1: 95, 2: 70, 3: 80, 4: 100, 5: 85, 6: 60},
 'english': {0: 75, 1: 80, 2: 85, 3: 90, 4: 65, 5: 75, 6: 100},
 'class': {0: 1, 1: 2, 2: 1, 3: 2, 4: 2, 5: 2, 6: 1}}

• DataFrame.to_dict(): 해당 함수를 사용하면 DataFrame을 dictionary로 바로 전환할 수 있다.

 지금까지 DataFrame을 만드는 방법에 대해 알아보았다. 다음 포스트에서는 데이터 프레임의 부위별 이름에 대해 알아보도록 하겠다.

판다스(Pandas) 소개

 파이썬을 처음 사용하는 데이터 분석가가 제일 먼저 공부해야 할 라이브러리를 한 가지 꼽으라면, 많은 사람들이 판다스(Pandas)를 선택할 것이다.

 판다스는 R과 마찬가지로 데이터 프레임(DataFrame)을 사용해서, 데이터를 시각화, 분석을 할 수 있는데, R의 데이터 프레임이 그렇듯 매우 직관적이고, 데이터를 가지고 놀기 좋은 R의 기능을 대부분 사용할 수 있기 때문에 데이터 분석가에게 있어 필수 라이브러리라고 할 수 있다.

 사족으로 판다스라고 하면, 동물인 판다가 먼저 떠오를 텐데, 판다스는 동물에서 따온 이름이 아닌, 계량 경제학에서 사용하는 "패널 데이터(Panner Data)"에서 따온 이름이다.

 사회 과학에서 자주 다뤄지는 패널 데이터를 간략히 설명하자면, 횡단 데이터인 한 시점에서의 데이터 셋이 종단 데이터로 규칙적인 기간을 간격으로 여러 개 존재하는 데이터를 말한다. 즉, 종단 + 횡단의 성격을 갖는 데이터가 패널 데이터다. 이는 판다스가 한 시점에서 뿐만이 아닌 시계열 데이터에도 강한 면모를 가진다는 뜻이기도 하다.

 판다스는 대용량 데이터를 다룰 때나, 서비스를 위해 0.5초, 1초 내의 빠른 연산이 필요한 상황에선 취약한 모습을 보이기 때문에 만능이라고 할 수는 없으나, 판다스는 데이터의 흐름이나 데이터의 특징 파악이 매우 쉬우므로, 먼저 판다스로 코드를 짜고, 속도가 매우 빠른 Numpy로 코드를 수정하면, 이를 쉽게 해결할 수 있다.

1. 판다스의 데이터 타입

• 판다스는 크게 2개의 고유 데이터 타입을 가지고 있다.
• 하나는 데이터 프레임(DataFrame)이고, 다른 하나는 시리즈(Series)이다.
• 어떻게 생겼는지만 간략히 봐보자.

import pandas as pd
from sklearn.datasets import load_iris

# 붓꽃(iris) 데이터를 가져와보자.
iris_dict = load_iris()

DF = pd.DataFrame(iris_dict["data"], columns=iris_dict["feature_names"])
DF

• 위 표가 데이터 프레임이다.
• 데이터 프레임은 마치 액셀처럼 이쁘게 표로 나눠져 있는 형태다.
• 엑셀과 차이라면, 데이터 프레임은 모든 데이터를 한 번에 보여주지 않는다는 것이다.
• 데이터 프레임은 한 번에 최대 60개 행까지 보여준다.

>>> DF[:60]

>>> DF["sepal length (cm)"]
0      5.1
1      4.9
2      4.7
3      4.6
4      5.0
      ... 
145    6.7
146    6.3
147    6.5
148    6.2
149    5.9
Name: sepal length (cm), Length: 150, dtype: float64

• 시리즈는 array와 굉장히 비슷하며, 데이터 프레임은 길이가 동일한 시리즈가 열의 숫자만큼 붙어있다고 생각해도 좋다.
• array와의 차이점은 array의 index는 무조건 0부터 시작하지만, 시리즈는 그렇지 않다는 것이다. 또한 데이터 프레임이나 시리즈는 멀티 인덱스라 하여, 2개의 칼럼을 인덱스로 사용할 수 있다.

 다음 포스트에서는 본격적으로 데이터 프레임을 다뤄보도록 하겠다.

 지금까지 문자열(string) type을 생성하고 이스케이프 문자, 포맷팅에 대해 학습해보았다. 지금까지 학습한 내용은 문자열을 생성하는 것에 관련 있는 것이지, 문자열을 다루는 내용과는 거리가 멀다고 할 수 있다.

 이번 포스트에서는 문자열을 직접 가지고 노는 문자열 전처리 코드에 대해 학습을 해보겠다.

문자열 전처리

1. 문자열 연산

 문자열 연산은 우리가 일반적으로 아는 더하기, 빼기, 곱하기와 같은 기능으로, 앞서 학습했던 List에서의 더하기, 곱하기처럼 문자A + 문자B는 문자A문자B가 되며, 문자 A * 3은 문자A문자A문자A가 된다.

# 1. 문자열을 더해보자
>>> A = "Python"
>>> B = "is"
>>> C = "easy"
>>> D = "and"
>>> E = "useful"
>>> F = A + " " + B + " " + C + " " + D + " " + E
>>> print(F)
Python is easy and useful


# 2. 문자열을 곱해보자
>>> A * 2
'PythonPython'


# 3. 문자열을 더하고 곱해보자
>>> G = A + " "
>>> print(G * 3)
Python Python Python 

• 문자열 더하기는 꽤 유용하게 사용할 수 있는 기능으로, 포맷팅과 동일하게 사용할 수도 있다.

# 문자열 더하기를 포맷팅처럼 사용해보자
>>> AB = A + " " + B + " "
>>> print(AB + C)
>>> print(AB + E)
Python is easy
Python is useful

위와 같은 산술 연산 기호를 사용하는 것은 아니지만 문자열 빼기도 가능하다

# 생성된 문자열 F에서 and를 제거해보자
>>> print(F)
Python is easy and useful

>>> F.replace("and ", "")
'Python is easy useful'


# 문자열 F에서 and를 or로 바꿔보자
>>> F.replace("and", "or")
'Python is easy or useful'

• 문자열 빼기가 문자열 F에서 문자열 D를 제거하는 것이라면, replace 함수를 응용해서 사용할 수 있다.
• replace(): 문자열.replace(대상 문자, 바꿀 문자) 함수를 사용하면, 대상 문자를 내가 원하는 다른 문자로 바꿀 수 있다.

2. 문자열 인덱싱(슬라이싱)

 문자열 인덱싱은 문자에서 내가 원하는 구간의 문자만 선택하는 방법이다.

# 위에서 생성했던 문자열 F를 가지고 indexing을 해보자
>>> print(F)
'Python is easy and useful'


# 1. 먼저 문자 전체의 길이를 확인해보자
>>> len(F)
25


# 2. 문자열 F에서 첫 문자부터 5번째 문자까지 가지고 와보자
>>> F[0:5]
'Pytho'

# 2.1. 문자열 F를 뒤에서 6번째부터 뒤 모든 문자를 가지고 와보자
>>> F[-6:len(F)]
'useful'

>>> F[-6:]
'useful'

• len(x): len 함수는 들어간 문자의 길이를 반환한다. x에 list나 DataFrame 등이 들어가는 경우, list는 원소의 수, DataFrame은 Row의 수를 반환한다.
• 인덱싱에서 [n1:n2] n1에 아무것도 넣지 않는 경우 처음부터인 0을 의미한다. n2에 아무것도 넣지 않는 경우 마지막 위치를 의미한다.
• 인덱싱한 값을 다른 변수에 담으면, 슬라이싱(부분만 가져오기)이 된다.

# 슬라이싱 기능을 활용하면 원하는 위치만 제거 혹은 다른 문자 끼워넣기가 가능하다.
>>> print(F)
'Python is easy and useful'

# 1. "easy and "를 제거해보자
>>> F[:10] + F[-6:]
'Python is useful'

# 2. useful을 useless로 바꿔보자
>>> F[:10] + F[-6:-3] + "less"
'Python is useless'

 위 인덱싱에선 내가 찾고자 하는 문자의 위치를 직접 확인해야 했으나, 문자 위치를 반환하는 함수인 find(), index() 함수를 사용하면, 위치를 수월하게 찾을 수 있다.

# 문자열 F에서 and의 위치를 찾아보자
>>> print(F)
'Python is easy and useful'

>>> F.find("and")   
15
>>> F[15:]
'and useful'    # 단어의 시작 위치가 출력된다.

# index() 함수는 find() 함수와 동일한 기능을 한다.
>>> target_start = F.index("and")
>>> print(target_start)
15

# len() 함수를 섞어서 사용하면 이 문제를 해결할 수 있다.
>>> F[target_start:target_start+len("and")]     # 문자 끝 위치 = 문자 시작 위치 + 문자 길이
'and'

• 문자열.find(탐색 문자), 문자열.index(탐색 문자) 함수를 사용하면, 해당 문자가 처음 등장한 문자의 위치를 알 수 있다.
• len() 함수와 섞어서 사용한다면 문자의 끝 위치도 알 수 있다.
• 그러나 만약, 해당하는 문자가 여러개라면 가장 왼쪽에서 등장한 문자의 위치만 반환한다는 단점이 있다(이는 추후 학습할 정규표현식 함수를 사용하면 수월하게 해결할 수 있다).
• index() 함수와 find() 함수의 차이는 대상 단어가 없을 때로, find() 함수 사용 시 대상 단어가 없으면 -1이 반환되고, index() 함수는 에러가 발생한다.

3. list와 str

 str type과 list type을 오가게 하는 함수가 있으며, 이를 단순히 말하면 아래와 같다.

• "구분자".join(대상 문자열): 합치기
• "대상 문자열".split("구분자"): 쪼개기

>>> target = "Python is fun and useful"

# 1. 문자열을 list로 쪼개보자
>>> target_list = target.split(" ")
>>> print(target_list)
['Python', 'is', 'fun', 'and', 'useful']

# 2. list를 문자열로 합쳐보자
# _(Under bar)로 합쳐보자
>>> target_str = "_".join(target_list)
>>> print(target_str)
Python_is_fun_and_useful

# 3. 생성된 단어를 한 글자 단위로 잘라보자
# join() 함수를 문자열을 대상으로 사용하면, 문자열에서 단어 하나하나 사이에 특정 단어가 들어간다.
>>> put_separator = "|".join(target_str)
>>> print(put_separator.split("|"))
['P', 'y', 't', 'h', 'o', 'n', '_', 'i', 's', '_', 'f', 'u', 'n', '_', 'a', 'n', 'd', '_', 'u', 's', 'e', 'f', 'u', 'l']

• join() 함수를 문자열을 대상으로 사용 시, 문자열의 단어 하나하나 사이에 join 단어가 들어간다.
• |는 거의 사용하지 않는 특수 문자 중 하나로 일반적으로 Rawdata에 존재하지 않는다.
• join() 함수와 split() 함수를 섞어서 사용하면 한 단어 단위로 자를 수 있다.

4. 공백 제거하기

# Target
>>> target = " Python is easy and useful "

# 1. 앞의 공백을 제거하자
>>> target.lstrip()
'Python is easy and useful '

# 2. 뒤의 공백을 제거하자
>>> target.rstrip()
' Python is easy and useful'

# 3. 양쪽 공백을 제거하자
>>> target.strip()
'Python is easy and useful'

# 4. 모든 공백을 제거하자
>>> target.replace(" ", "")
'Pythoniseasyanduseful'

• 문자열.lstrip(): 왼쪽 공백 제거
• 문자열.rstrip(): 오른쪽 공백 제거
• 문자열.strip(): 양쪽 공백 제거
• 문자열.replace(" ", ""): 모든 공백 제거

5. 대소문자 바꾸기

# Target
>>> target = "Python is easy and useful"

# 1. 소문자를 대문자로 바꿔보자
>>> upper_T = target.upper()
>>> print(upper_T)
PYTHON IS EASY AND USEFUL

# 2. 대문자를 소문자로 바꿔보자
>>> upper_T.lower()
'Python is easy and useful'

• 문자열.upper(): 소문자를 대문자로 만든다
• 문자열.lower(): 대문자를 소문자로 만든다

6. 문자열 개수 세기

# target
>>> target = "Python is fun and useful"

# 1. 문자열 전체 길이를 확인해보자
>>> len(target)
25

# 2. 문자열 안에 특정 문자가 몇 개 있는지 확인해보자
>>> target.count(" ")
4

>>> target.count("Python")
1

 지금까지 문자열을 다루는 기본적인 함수에 대해 알아보았다. 위 함수들을 보면, 내가 원하는 단어를 탐색하고 조작하는 부분이 실전에서 필요한 것에 비해 부족하다는 것이 느껴지는데, 이를 보다 체계적으로 할 수 있는 방법이 바로 정규표현식이다.

 다음 포스트에서는 파이썬 정규표현식에 대해 학습해보도록 하겠다.

  예를 들어 당신이 어떠한 반복되는 문자열을 만드려고, 하고 그 중 일부분만 바꿔야 한다면 어떻게 하겠는가?

# 예를 들어 뽀로로, 크롱의 인사와 짱구, 짱아의 인사 문자열을 생성하려면 어떻게 해야할까?
>>> str0 = "뽀로로: \"크롱 반가워!\"\n크롱:\"오! 뽀로로 좋은 아침이야!\""
>>> str1 = "짱구: \"짱아 반가워!\"\n짱아:\"오! 짱구 좋은 아침이야!\""
>>> print(str0)
>>> print("\n")
>>> print(str1)
뽀로로: "크롱 반가워!"
크롱:"오! 뽀로로 좋은 아침이야!"

짱구: "짱아 반가워!"
짱아:"오! 짱구 좋은 아침이야!"

 위 예시처럼 일일이 그 문자열을 만들어 새로 지정해 줄 것인가? 이는 매우 비 경제적인 방법인데, 이번 포스트에선 문자열의 일부를 손쉽게 바꿀 수 있는 방법인 문자열 포맷팅에 대해 학습해보겠다.

문자열 포맷팅(String Formatting)

 지난 포스트인 이스케이프 문자 예제에서 뽀로로, 크롱과 같은 문자열 내 특정 문자가 반복되어 출력되는데, 이 부분만 자동으로 바꿀 수 있다면, 보다 적은 코드만 써도 되지 않을까? 라는 생각이 들지 않는가?

 문자열 포맷팅은 코드를 더 경제적으로 쓸 수 있는 방법 중 하나로, 출력되는 문자열에서 일부분만 쉽게 바꿀 수 있는 방법 중 하나다.

 문자열 포맷팅은 크게 3가지 방법이 있다.

1. % formating
2. {} formating
3. f-string

1. % formating

# 1. % formating
>>> print("%s: %s, 반가워!" %("뽀로로", "크롱"))
>>> print("%s: %s, 좋은 아침이야!" %("크롱", "뽀로로"))
뽀로로: 크롱, 반가워!
크롱: 뽀로로, 좋은 아침이야!

• 위 예시를 보면, %s라는 문자와 %()라는 처음 보는 문자가 들어간 것을 볼 수 있다.
• %s %d % ("str", 2) 이 기본적인 방식이다. 여기서 %s, %d와 같은 문자를 문자열 포맷 코드라고 한다.
• 문자열 포맷 코드는 다음과 같다.

• 참고로 %s의 경우 문자형이나, 숫자, 소수 모두 문자형으로 변형이 가능하므로, %s를 넣는 경우, 모든 형태의 값을 넣을 수 있다.
• 이 밖에도 8진수(%o), 16진수(%x)가 더 있긴 하지만, %s, %d, %f만 사용할 수 있어도 충분하다.
• 참고로 %를 문자로 그냥 출력하고 싶다면 %%를 입력해야한다.

# 위 코드를 좀 더 쉽게 써보자
>>> name1 = "뽀로로"
>>> name2 = "크롱"
>>> print("%s: %s, 반가워! \n%s: %s, 좋은 아침이야!" %(name1, name2, name2, name1))
뽀로로: 크롱, 반가워! 
크롱: 뽀로로, 좋은 아침이야!

>>> name3 = "짱구"
>>> name4 = "짱아"
>>> print("%s: %s, 반가워! \n%s: %s, 좋은 아침이야!" %(name3, name4, name4, name3))
짱구: 짱아, 반가워! 
짱아: 짱구, 좋은 아침이야!

• 위 코드 같이 반복 출력하고자 하는 Data("뽀로로", "크롱")를 변수(name1, name2)에 담아서 사용하면 보다 쉽게 쓸 수 있다.
• 그러나 위 방법의 경우, 문자를 넣어주고 싶은 위치랑 %()안의 변수 위치가 동일해야하므로, Data가 문자열에서 들어갈 위치를 헷깔릴 수 있다는 단점이 있다.

2. {} formating

# {} formating을 써보자
print("{name1}: {name2}, 반가워!\n{name2}: 오! {name1} 좋은 아침이야!".format(name1="뽀로로", name2="크롱"))
뽀로로: 크롱, 반가워!
크롱: 오! 뽀로로 좋은 아침이야!

• {} format은 문자열 내에 원하는 변수를 지정하여 사용할 수 있다.
• % formating과 달리 변수의 위치를 구체적으로 알 수 있다.
• 이를 def 코드를 사용해서 함수로 만든다면, 보다 효율적으로 사용할 수 있다.

# def 코드를 사용해서 만들어보자
>>> def hello(name1, name2):
>>>     print("{name1}: {name2}, 반가워!\n{name2}: 오! {name1} 좋은 아침이야!".format(name1=name1, name2=name2))
    
>>> hello("짱구", "짱아")

짱구: 짱아, 반가워!
짱아: 오! 짱구 좋은 아침이야!

• 그러나, 이 방법은 .format(변수이름=변수)를 넣어줘야하기 때문에 코드가 길어진다는 단점이 있다.

3. f-string

% formating과 {} formating을 비교해보면, 각각 코드를 만드는 데에 있어 장점과 단점이 나뉘는 것을 알 수 있다.

• % formating은 문자열 포맷팅 밖에서 지정한 변수를 가져갈 수 있다.
• {}.formating은 문자열 내 포맷팅 된 변수들의 위치를 알 수 있다.
• 위 장점을 적절히 섞는다면 보다 코드를 수월하게 짤 수 있지 않을까? > f-string을 통해 이를 해결할 수 있다.

# f-string 포맷팅을 사용해보자
>>> name1 = "뽀로로"
>>> name2 = "크롱"
>>> print(f"{name1}: {name2}, 반가워!\n{name2}: 오! {name1} 좋은 아침이야!")
뽀로로: 크롱, 반가워!
크롱: 오! 뽀로로 좋은 아침이야!

• f-string은 위 % formating이나 {} formating보다 코드가 단순하다.
• 문자열 밖에서 문자열에 들어갈 가변적인 변수를 지정하고, 문자열 앞에 f를 붙이면 된다.
• 문자열 내에선 {} formating과 같은 방식으로 문자열을 적으면 된다.
• 위 코드를 def 코드를 이용해서 함수로 만들어보자.

# 함수화 해보자
>>> def hello(name1, name2):
>>>     print(f"{name1}: {name2}, 반가워!\n{name2}: 오! {name1} 좋은 아침이야!")
    
>>> hello("짱구", "짱아")


짱구: 짱아, 반가워!
짱아: 오! 짱구 좋은 아침이야!

• 위의 {} formating을 사용해서 만든 함수보다 코드가 단순하다는 것을 알 수 있다.

 지금까지 문자열의 일부만 바꾸는 방법인 문자열 포맷팅에 대해 알아보았다. 이 중 f-string이 가장 코드가 단순하고, 직관적이므로, 가능하면 f-string을 쓰길 바란다.

 다음 포스트에서는 문자열을 가지고 노는 방법인 문자열 전처리에 대해 학습해보겠다.

 지난 포스트에서는 Python의 기본적인 자료형에 대해 공부해보았다. "Python-기초: 1.0. 자료형(1) - scalar"에서 Data type으로 int, float, None, Boolean은 나왔으나, 정작 문자열은 나오지 않았다.

 이번 포스트에서는 data type 중 문자열 Type인 string에 대해 심도 깊게 다뤄보도록 하겠다. 

문자열(String)

• Python에서 문자열은 ''(Quotation)나 ""(Double Quotation) 안에 문자를 넣어서 만든다.
• Python의 기본 인코딩은 utf-8이므로, R과 달리 한글에 대한 텍스트 마이닝이 깔끔하게 잘 수행된다.
• 문자열 데이터를 처리하여, 그 안에 숨어 있는 정보를 찾아내는 전반적인 과정을 텍스트 마이닝(Text Mining)이라 한다.

※ 텍스트마이닝(Text Mining)

• 현장에서 접하는 대다수의 데이터는 숫자로 이루어진 연속형 데이터보다 Log Data 같은 문자, 사진 같은 이미지, 동영상, 음악과 같은 비정형 데이터가 대부분이다.
• 대부분의 전처리(Data Handling)는 이러한 비정형 데이터를 분석에 용이한 숫자 데이터로 변환해주는 과정이다.
• 문자형 Data를 연속형 데이터로 변환하는 경우, 크게 2가지 방법이 있다.
  1. 범주화: 문자에 해당하는 숫자를 배정 - 리소스를 덜 먹음
  2. 벡터화: One-Hot Vector, Word2Vec 등의 방법 사용 - 일반적으로 기계학습에서 사용

문자열 Data를 만들어보자

# 문자열 Data를 만들어보자.
# 1. "" or ''를 사용해서 만든다.
>>> str1 = "Python is very useful"
>>> print(str1)
Python is very useful

>>> str2 = 'Python is a lot of fun'
>>> print(str2)
Python is a lot of fun

>>> str3 = """Python is easy and fun"""
>>> print(str3)
Python is easy and fun

>>> str4 = '''So let's do Python'''
>>> print(str4)
So let's do Python

• 문자열 Data는 ""나 ''를 사용해서 만들며, "나 ' 기호를 3번 연속 사용해서 만들 수도 있다.
• 보통 """나 '''로 만드는 경우는 긴 문장이나 주석을 넣을 때 사용한다.

# 문자열 안에 문자열 생성 기호인 ''나 ""를 넣고 싶은 경우엔 어떻게 할까?
>>> print("Let's do our best today")
Let's do our best today

>>> print('Pororo said "Hello" to Crong')
Pororo said "Hello" to Crong

>>> Frozen = """
    Anna:
    "Elsa?  Do you want to build a snowman?
    "Come on let's go and play.
    I never see you anymore. Come out the door.
    It's like you've gone away.
    We used to be best buddies
    And now we're not. I wish you would tell me why.
    Do you want to build a snowman?
    It doesn't have to be a snowman."

    Elsa:
    "Go away, Anna."

    Anna:
    "...Okay bye."
    """
    
>>> print(Frozen)

Anna:
"Elsa?  Do you want to build a snowman?
"Come on let's go and play.
I never see you anymore. Come out the door.
It's like you've gone away.
We used to be best buddies
And now we're not. I wish you would tell me why.
Do you want to build a snowman?
It doesn't have to be a snowman."

Elsa:
"Go away, Anna."

Anna:
"...Okay bye."

• 짧은 문장 안에 '나 "가 들어가야한다면 그에 상응하는 문자로 묶어주면 된다.
• 그러나 이 두 가지가 모두 들어가야한다면, """ 문장 """으로 묶어주면 된다.
• 또는 escape 문자인 ＼을 사용하면 된다.

이스케이프 문자(Escape Sequence)

파이썬을 포함한 각종 언어에서는 잘 사용하지 않는 특수 문자나 특수문자 + 문자 조합에 특정 기능을 넣어 놓는다. 그러나, 가끔 이 이스케이프 문자가 실제 문자 Data 대상인 경우도 있기 때문에 이스케이프 문자가 아님을 알려주는 방법을 숙지할 필요가 있다.

• 위 표에서 많이 사용되는 것은 탭, 라인피드, 이스케이프 문자 앞에 \ 사용하기이므로, 나머지 이스케이프 문자에 대해선 크게 신경 쓰지 말자.
• 키보드에서 \는 존재하지 않는데, ￦ 키가 동일한 기능을 한다.

# 이스케이프 문자를 사용해보자
>>> str5 = "뽀로로: \"크롱 반가워!\"\n크롱:\"오! 뽀로로 좋은 아침이야!\""
>>> print(str5)
뽀로로: "크롱 반가워!"
크롱:"오! 뽀로로 좋은 아침이야!"

# 이스케이프 문자를 그대로 출력시켜보자
>>> str5 = "뽀로로: \"크롱 반가워!\"\\n크롱:\"오! 뽀로로 좋은 아침이야!\""
뽀로로: "크롱 반가워!"\n크롱:"오! 뽀로로 좋은 아침이야!"

• 위 예제에서 역 슬래시 사용 후 "나 ' 같은 특정 기능이 들어간 특수 문자를 넣으면 그대로 출력되는 것을 알 수 있다.
• 이스케이프 문자에서 \n나 \t는 Data를 line 단위로 가져오기, tap 단위로 구분 지어 가져오기(구분자)를 하는 경우에 문자 안에 해당 문자가 들어 있어, Row를 잘못 인식할 수도 있다(실제 Row의 수보다 더 많은 Row를 생성).
• 텍스트 데이터를 다룰 때, 이스케이프 문자나 ' or "로 인해 의도치 않은 결과가 출력 될 수 있다.

 이번 포스트에서는 가볍게 문자열을 만드는 방법과 이스케이프 문자에 대해 알아보았다. 이스케이프 문자는 반드시 숙지하길 바라며, 최소한 \n이 내려쓰기, \t는 탭이라는 것은 꼭! 외워놓기 바란다.

 Data를 가지고 오는 방법 중 txt data를 line별로 가지고 오거나, 탭을 구분자로 가져오는 경우가 많은데, 대상 Data 안에 해당 이스케이프 문자가 들어 있다면(예를 들어 URL Log Data), 데이터를 잘못 불러오는 문제가 발생할 수 있다.

 다음 포스트에선 자동으로 문자열의 일부를 바꾸는 방법인 포맷팅(Formating)에 대해 학습해보겠다. 

 자, 드디어 마지막 기초 자료형인 DataFrame이다. DataFrame은 pandas의 대표적인 Type이며, R을 공부해 본 사람이라면, 상당히 친숙하게 느껴지는 단어일 것이다.

 pandas의 DataFrame은 R의 Dataframe을 Python에서도 사용해보기 위해 만들어졌으며, R에서 할 수 있는 대부분의 기능을 판다스에서도 구현할 수 있다.

 이번 포스트에서는 데이터 분석가들의 필수 Type인 DataFrame이 어떻게 생겼는지와 아주 대략적인 대표 기능만 살펴보고 바로 넘어가도록 하자.

 먼저 DataFrame을 만들어보자.

• DataFrame을 만드는 방법은 크게 2가지가 있다.
  1.  길이가 동일한 list들을 컬럼 하나하나에 배정하는 방법
  2. M*N 행렬 형태의 Data(Array, Tupple)를 DataFrame에 넣는 방법

# pandas 모듈을 가지고 오자
>>> import pandas as pd
>>> import numpy as np


# 1. 길이가 동일한 list들을 DataFrame에 넣어보자
# DataFrame에 들어갈 길이가 같은 list들을 만들자
>>> name = ["민철", "기훈", "재성", "현택", "윤기"]
>>> math = [40, 60, 80, 75, 65]
>>> english = [75, 80, 65, 80, 70]
>>> science = [85, 70, 75, 80, 60]

# list들을 이용해서 DataFrame을 만드는 경우는 다음과 같다
>>> DF = pd.DataFrame({"name":name, "math":math, "english":english, "science":science})
>>> DF

name	math	english	science
0	민철	40	75	85
1	기훈	60	80	70
2	재성	80	65	75
3	현택	75	80	80
4	윤기	65	70	60



# 2. array를 이용해서 DataFrame을 만들어보자.
# 10, 100 사이의 임의의 값으로 만들어진 행렬을 생성하자
>>> row_number = 50
>>> score_mat = np.random.randint(10, 100, size=(row_number, 4))

# ID를 만들어보자
>>> ID_list = []
>>> for i in range(row_number):
    
	    ID = "A" + str(i)
    	ID_list.append(ID)
    
# shape을 맞춰서 ID_array와 score_mat을 병합시켜보자
>>> ID_array = np.array(ID_list)
>>> ID_array = ID_array.reshape((50, 1))

>>> data_array = np.hstack((ID_array, score_mat))

# array를 DataFrame을 만들어보자
>>> DF2 = pd.DataFrame(data_array, columns=["ID", "math", "English", "science", "Korean"])
# 생성한 DataFrame의 상위 10개만 출력해보자
>>> DF2.head(10)


ID	math	English	science	Korean
0	A0	35	38	62	51
1	A1	52	29	40	93
2	A2	28	16	99	71
3	A3	93	42	61	48
4	A4	23	60	39	48
5	A5	93	96	16	55
6	A6	13	69	88	90
7	A7	31	18	80	30
8	A8	59	12	66	93
9	A9	54	70	57	38

• DataFrame을 처음 보면 마치 엑셀에서 우리가 일반적으로 만들던 표랑 굉장히 유사하다는 것을 알 수 있다.
• DataFrame에는 각 열(Column)별로 동일한 데이터 타입을 넣을 수 있다.
• pd.DataFrame() 함수를 통해 DataFrame을 만들 수 있다.
• np.random.randint(시작 값, 끝 값, 형태) 함수는 시작 값, 끝 값 사이에서 랜덤한 값이 담긴 array를 생성한다.
• np.hstack((array1, array2)) 함수는 두 array를 열을 기준으로 병합한다.
• DataFrame.head(숫자) 함수는 내가 숫자만큼 DataFrame을 출력한다.

DataFrame의 컬럼별 dtype을 확인해보자

# DataFrame의 data type을 확인해보자
>>> DF2.dtypes
ID         object
math       object
English    object
science    object
Korean     object
dtype: object


# math, English, science, Korean 컬럼을 정수 type으로 바꿔보자
>>> DF2["math"] = DF2["math"].astype("int64")
>>> DF2["English"] = DF2["English"].astype("int64")
>>> DF2["science"] = DF2["science"].astype("int64")
>>> DF2["Korean"] = DF2["Korean"].astype("int64")
>>> DF2.dtypes
ID         object
math        int64
English     int64
science     int64
Korean      int64
dtype: object

• DataFrame.dtypes 함수를 통해 DataFrame의 각 컬럼들의 Type을 확인할 수 있다.
• DataFrame["컬럼"].astype("바꿀 dtype") 함수를 통해 DataFrame의 해당 컬럼 dtype을 바꿀 수 있다.

DataFrame을 Slicing 해보자.

# 10번 row부터 20번 row까지 출력해보자
>>> DF2[10:20]
	ID	math	English	science	Korean
10	A10	78	24	99	79
11	A11	41	87	83	10
12	A12	61	71	31	78
13	A13	74	80	32	99
14	A14	20	19	95	38
15	A15	24	67	22	24
16	A16	39	53	41	82
17	A17	34	57	52	67
18	A18	34	60	27	73
19	A19	27	35	91	81




# 수학 80점 이상인 Row만 출력해보자
>>> DF2[DF2["math"] >= 80]
	ID	math	English	science	Korean
2	A2	90	70	70	72
4	A4	90	27	64	42
8	A8	99	21	71	92
9	A9	89	61	11	30
28	A28	81	29	27	86
32	A32	84	19	89	31
44	A44	97	73	36	78
45	A45	80	95	54	12
48	A48	86	19	99	83

• pandas의 dataFrame은 Numpy의 array와 동일한 방법으로 Slicing 할 수 있으며, 내가 원하는 조건에 대한 Row도 쉽게 가져올 수 있다.

 이번 포스트에서는 DataFrame에 대해 아주 간략하게 훑어만 봤는데, 설명을 보다 보면 설명이 지나치게 부족하지 않는가? 하는 생각이 들 것이다. 

 pandas의 DataFrame 역시 Numpy의 array와 마찬가지로 그 영역이 매우 크기 때문에 따로 카테고리를 만들어서 세세하게 설명하고자 한다.

 이번 포스트에서는 맛보기로 DataFrame이 어떻게 생겼는지만 인식하는 수준에서 끝내고, 추후 Python-pandas 카테고리의 포스트에서 pandas의 각 기능들을 세세하게 따져보도록 하겠다.