파이썬(Python) 고급연산
2020. 12. 31. 14:42
In [1]:
#초기화
import pandas as pd
from pandas import Series, DataFrame
import numpy as np
In [2]:
%matplotlib inline
연산¶
산술연산¶
- 2013~2014년도 nc 선수기록을 DataFrame으로 로딩 한다. 이때 인덱스는 '선수명으로 지정 한다.
- 2014년도와 2015년도의 홈수 수 합계를 구한다. --> 색인 기반으로 연산 NaN에 대해 처리가 필요.
In [3]:
# 데이터를 읽을 파일 목록 만들기
경로목록 = [
'data/NC Dinos 2013.xlsx',
'data/NC Dinos 2014.xlsx',
'data/NC Dinos 2015.xlsx'
]
In [4]:
# 지정된 경로로부터 데이터를 읽어서 DataFrame에 넣고 이를 리스트로 만든다.
# 이때 선수명을 색인으로 사용 한다.
frame_list = []
for 경로 in 경로목록:
frame = pd.read_excel(경로)
frame = frame.set_index('선수명')
frame_list.append(frame)
In [5]:
# 풀기 - 리스트의 항목을 차례로 각각의 변수에 대입
nc13, nc14, nc15 = frame_list
In [6]:
# DataFrame의 산술연산은 색인을 기반으로 된다.
# DataFrame의 산술연산이 되려면 모양(타입)이 일치해야 한다.
# 14년도와 15년도의 홈런 합계 (두 DataFrame은 색인이 일치하지 않기 때문에 NaN 이 발생 한다. )
nc14['홈런'] + nc15['홈런']
Out[6]:
In [7]:
# 연산결과가 NaN이 나오는 이유
# +연산시 중간단계의 데이터 모양
# nc14 nc15
#강구성 0 NaN --> NAN
#강민국 0 0 --> 0
#권희동 NaN 7 --> NaN
### 권희동은 우리가 원하는 결과가 아니다.
# 원칙 : 색인끼리 연산, 없는 색인은 자동으로 채워진다.(NaN), NaN과 연산은 무조건 NaN이다.
In [8]:
# NaN 처리를 위해서 add 함수를 사용 한다.
# add 함수 사용, 인자 사용 가능 --> + 연산을 수행, 옵션을 수행할수 없기 때문에 add 함수를 사용한다.
nc14['홈런'].add(nc15['홈런'], fill_value=0)
Out[8]:
In [9]:
# add 연산시 중간단계의 데이터 모양
# nc14 nc15
#강구성 0 0 --> 0
#강민국 0 0 --> 0
#권희동 0 7 --> 7
연습¶
- 2013시즌 부터 2015 시즌 까지의 각 선수의 안타, 홈런 합계 산출.
In [10]:
열선택 = ['안타', '홈런']
In [11]:
# 13년도와 14년도와 15년도의 안타와 홈런의 합계를 구한다.
안타홈런합계 = nc13[열선택].add(nc14[열선택], fill_value=0)
안타홈런합계 = 안타홈런합계[열선택].add(nc15[열선택], fill_value=0)
안타홈런합계
Out[11]:
브로드캐스팅을 이용한 연산¶
In [12]:
# 2차원의 DataFrame과 1차원의 Series의 연산
# 브로드캐스팅의 개념을 이용해 연산을 한다.
# frame에서 조정의 값을 이용해 연산.
frame = DataFrame([[10,90], [80,20]])
frame.index = ['가', '나']
frame.columns = list('AB')
frame
Out[12]:
In [13]:
# 사전을 이용해 시리즈 생성
조정 = Series({'A':5, 'B':3})
조정
Out[13]:
In [14]:
# A칼럼에서 5를 빼고, B에서 3을 뺀다. (교재 490 12-4 그림과 같이 동작.)
# pandas 기준으로 동작할때는 색인을 붙여 준다.
# pandas 에서는 직접 해주는 것은 없다.
frame + 조정
Out[14]:
In [15]:
# 브로드캐스팅은 기본적으로 0축(위에서 아래로) 방향으로 일어난다.
# Series는 DataFrame의 열과 색인을 맞춰 연산이 수행된다.
# --> 시리즈의 데이터는 행으로 배치되고 행 복제가 된다.
In [16]:
# Series를 색인에 맞추고 열 방향으로 복제가 일어나도록 하기.
조정2 = Series({'가':5, '나':3})
조정2
Out[16]:
In [17]:
frame - 조정2
# 방향이 맞지 않기 때문에 연산이 이상하게 수행 된다.
# A B - 가 나
#가 NaN NaN 가 NaN NaN
#나 NaN NaN 나 NaN NaN
Out[17]:
In [18]:
# sub 함수를 이용해 인자를 주고 원하는 방향의 연산이 되도록 한다.
# axis=0 : Series를 0축으로 데이터를 배치한다.
# 즉 데이터는 위에서 아래로 배치되고 칼럼 복제가 일어난다.
# --> 위에서 아래로 배치되고 왼쪽에서 오른쪽으로 데이터 복제한다.
# frame.sub(시리즈, axis=시리즈를배치할축방향값)
frame.sub(조정2, axis=0)
Out[18]:
연습¶
- 2015년도(nc15)의 각 선수들의 안타, 홈런 기록에 대해, 안타와 홈런이 합계에서 차지하는 비율 계산
- 예를 들어 안타홈런 합계가 100이고, 안타80, 홈런 20개인 경우 안타 비율은 0.8 홈런 비율은 0.2로 계산되어야 한다.
- 데이터의 안타는 실제 안타와 홈런의 합계이다.
In [19]:
열선택 = ['안타', '홈런']
nc15[열선택]
Out[19]:
In [20]:
안타 = nc15["안타"] - nc15["홈런"]
#안타비율 = 안타 / nc15['안타']
#안타비율 = pd.DataFrame(안타비율.fillna(0))
#안타비율.columns = ['안타비율']
#홈런비율 = 1 - 안타비율
#홈런비율.columns = ["홈런비율"]
#홈런비율
#안타비율
In [21]:
# 실질 안타는 안타-홈런을 해야 한다.
안타 = nc15["안타"] - nc15["홈런"]
# 안타비율을 구하고 NaN은 0으로 변경
안타비율 = 안타 / nc15['안타']
안타비율 = pd.DataFrame(안타비율.fillna(0))
# 안타비율과 홈런비율 칼럼 추가
안타비율.columns = ["안타비율"]
홈런비율 = nc15["홈런"] / nc15['안타']
홈런비율.columns = ["홈런비율"]
#안타비율
#print(안타비율)
실안홈비율 = pd.merge(안타비율.reset_index(), 홈런비율.reset_index())
실안홈비율 = 실안홈비율.set_index(["선수명"])
실안홈비율
Out[21]:
In [22]:
#안타비율
In [23]:
홈런비율
Out[23]:
In [ ]:
안타.values
In [25]:
# 다른 방식의 풀이: DataFrame에서 제공하는 기술통계 함수사용.
안타홈런 = nc15[열선택]
# 기술통계 계산
## sum()을 사용하면 기본적으로 0축 방향으로 합을 구한다.
## 행단위로 합계를 구하려면 sum(1)을 사용 한다.
## cumsum: 누적 합
## sum : 합
## mean : 평균
## idxmin, idxmax: 색인의 최대 최소
## describe 한번에 여러 통계 결과를 만든다.
# 안타를 함계에 담는다.
합계 = 안타홈런['안타']
합계
Out[25]:
In [26]:
# 실제 안타를 구한다. : 홈런에서 안타를 뺀 값.
안타 = 안타홈런.loc[:,'안타'].sub(안타홈런.loc[:,'홈런'])
안타
Out[26]:
In [27]:
# 안타홈런 데이터에 업데이트
안타홈런.loc[:, '안타'] = 안타.values
#합계 = 안타홈런['안타'] + 안타홈런['홈런']
In [28]:
# 데이터 확인
안타홈런
Out[28]:
In [29]:
# 데이터 확인
합계
Out[29]:
In [30]:
# div 함수를 이용해서 비율 계산하고 NaN 값은 0으로 채운다.
안타홈런.div(합계, axis=0).fillna(0)
Out[30]:
NumPy¶
- 행렬 연산을 이용하기 위해 만들어 졌다.
- NumPy의 자주 사용되는 함수 표...
- dialg :
- dot : 행렬 곱셈
- trace : 형렬 대각선 원소의 합
- linalg.det : 행렬식 계산
- linalg.eig :
- linalg.inv
- linalg.pinv
- linalg.qr
- linalg.svd
- linalg.solve
- linalg.lstsq
In [31]:
x = np.array([[1,2,3], [4,5,6]])
x
Out[31]:
In [32]:
k = np.array([2,2,2])
x.dot(k)
#np.ones(3)
Out[32]:
In [33]:
y = np.array([[6,23], [-1,7], [8,9]])
y
Out[33]:
In [34]:
# 각각의 원소(가장 바깥 쪽을 기준으로한 원소)의 곱 구하기 : dot 함수 사용. --> 앞의 행과 뒤의 열을 번갈아 곱한다.
# x 행 * y열 --> x1행*y1열: 6-2+24= 28, x1행*y2열: 23+14+27 = 64, x2행*y1열: 24-5+54=67, x2행*y2열: 92+35+54=181
x.dot(y)
Out[34]:
In [35]:
## pandas는 자료구조를 제공하고
## NumPy는 연산의 기능을 제공 한다.
b = np.array([[1,2], [3,4]])
a = np.array([[1,1], [2,2]])
a.dot(b)
Out[35]:
개발자 Vs. 데이터과학자¶
프로그래머 적인 접근 방식을 데이터과학자 방향으로 변환하기
- 가정 : 1보 전진 또는 후진을 랜덤하게 수행해서 그 결과를 저장 해라.
In [36]:
import random
In [37]:
random.randint(0,1)
Out[37]:
개발자적 사고 방식에 의한 계산¶
In [38]:
# 개발자적 방식의 수행 방식 --> 루프 순환
position = 0
walk = [position]
steps = 1000
for i in range(steps):
# random.randint(A,B) A~B까지의 정수 랜덤 생성
# 0, 1이 랜덤하게 발생: random.randint(0,1)
step = 1 if random.randint(0,1) else -1
position += step
walk.append(position)
## 마지막 10개만 확인
walk[-10:]
Out[38]:
데이터 과학자적 사고 방식에 의한 계산¶
In [39]:
# 데이터 과학자
# ==> 0, 1의 난수 데이터 표를 만든다.
steps = 1000
draw = np.random.randint(0,2, size=steps)
draw[-10:]
Out[39]:
In [40]:
# 표에 따른 스텝 데이터를 만든다.
# np.where(연산, 참값, 거짓값)
comSteps = np.where(draw > 0, 1, -1)
# 타입 확인
type(comSteps)
Out[40]:
In [41]:
# 걸음수의 누적 합계를 구한다.
# 누적합계함수 : cumsum
walk = comSteps.cumsum()
In [42]:
walk[-10:]
Out[42]:
5000회 시뮬레이션¶
- 위 수행 방식을 5000번 시뮬레이션 하기
In [43]:
timeit?
In [44]:
%%timeit
## 빌트인 매직 커맨드 %%timeit 실행시간을 측정한다.
# 개발자 방식
for _ in range(5000):
position = 0
walk = [position]
steps = 1000
for i in range(steps):
# random.randint(A,B) A~B까지의 정수 랜덤 생성
step = 1 if random.randint(0,1) else -1
position += step
walk.append(position)
#walk
In [45]:
%%timeit
# 데이터과학자 방식
# (5000, 1000)의 난수표 행렬 생성 --> draws
draws = np.random.randint(0,2, size=(5000,1000))
# 0보다크면 1 아니면 -1 값으로 변경.
steps = np.where(draws > 0, 1, -1)
# 행 방향으로 누적 합계를 구하면 된다. --> cumsum(1)
walks = steps.cumsum(1)
# 끝에서 두번째만 확인.
walks[:2]
Apply 함수와 Map 함수¶
- DataFrame의 apply --> "def f(시리즈)" 형식의 함수 사용.
- Series의 map --> "def f(값)" 형식의 함수 사용
- DataFrame의 apply 함수를 사용해서 Series의 map과 동일한 결과를 만들 수 있다.
- 이런 경우 map 사용 권장.
- 이유 : 동일한 결과를 얻기 위해서 Series를 루프로 순환해야 하기 때문이다.
apply 함수 이해하기¶
- DataFrame의 함수
- apply 함수를 시리즈에 대한 어떤 연산을 수행하는 함수를 인자로 받는다.
- 따라서 하나의 시리즈로 어떤 작업을 해야 하는 경우 사용 한다.
- 시리즈는 기본적으로 하나의 열(칼럼)을 사용하지만 axis=1을 사용하면 하나의 행을 사용할 수 있다.
In [142]:
안타홈런열 = ['안타', '홈런']
안타홈런 = nc15[안타홈런열]
실안타 = 안타홈런.loc[:, '안타'] - 안타홈런.loc[:,'홈런']
안타홈런.loc[:,'실안타'] = 실안타 # 안타홈런.loc[:, '안타'] - 안타홈런.loc[:,'홈런']
#안타홈런['안타홈런'] - 안타홈런['홈런']
In [47]:
안타홈런
Out[47]:
In [140]:
# 하나의 시리즈에서 최대값과 최소값을 차이를 계산해서 리턴.
def 최대최소차(시리즈):
return 시리즈.max() - 시리즈.min()
In [141]:
# 열단위로 apply 실행 만일 색인단위로 apply를 하려면 , apply(함수명, axis=1)로 설정한다.
## 다음은 안타와 홈런, 실안타의 데이터에서 최대값과 최소값의 차이를 보여 준다.
안타홈런.apply(최대최소차)
Out[141]:
In [50]:
## DataFrame.apply 기능 이해 하기 : for 문을 이용해 apply와 동일한 기능 구현.
## ==> apply는 칼럼을 루프로 순환하거나 행(axis=1)을 루프로 순환 한다.
결과사전 = {}
for 열제목 in 안타홈런:
열 = 안타홈런[열제목]
결과 = 최대최소차(열)
결과사전[열제목] = 결과
Series(결과사전)
Out[50]:
map 함수 이해하기¶
- Series의 함수
- Value에 대해 필요한 연산을 수행 할 수 있다.
타율을 계산하고 표시 형식 변경해보기¶
In [51]:
# 데이터 확인
nc15
Out[51]:
In [52]:
# 타율데이터가 있지만 직접 구해본다.
#안타수 = nc15['안타'] - nc15['홈런']
타율 = nc15['안타'] / nc15['타수']
In [53]:
타율
Out[53]:
In [54]:
## 타율의 표시 형식을 변경하려면...(데이터는 변경하지 않는다.)
## 문자열 양식을 활용 한다.
'{0:%} {0:.1%}'.format(0.3)
Out[54]:
In [55]:
## 출력형식 변경 함수 만들기 소숫점 둘째 자리까지 표기하고 % 출력.
def 출력형식(값):
return "{0:.2%}".format(값)
In [56]:
## 타율 Series를 루프로 순환하면서 출력.
for 값 in 타율:
출력 = 출력형식(값)
print(출력)
In [57]:
# map은 각각의 값들에 매핑되는 것.
## --> apply를 사용해도 동일 결과가 나오지만 시리즈에서는 map를 사용할 것을 권장.
# 출력형식 함수는 def f(값) 형태로 만들어야 한다.
# DataFrame의 apply --> def f(시리즈) 형식의 함수 사용.
# Series의 map --> def f(값) 형식의 함수 사용
타율.map(출력형식)
Out[57]:
In [58]:
## 원본 데이터를 가지고 해보자.
nc15["타율"].map(출력형식)
Out[58]:
안타와 홈런의 비율 계산¶
In [59]:
## 안타홈럼비
비율 = 안타홈런.div(안타홈런['안타'], axis=0).fillna(0)
비율[:5]
Out[59]:
In [60]:
비율.columns = ['비율합','홈런비율', '안타비율']
비율
Out[60]:
In [61]:
# 비율합 칼럼 제거
비율 = 비율.drop('비율합', axis=1)
비율
Out[61]:
In [62]:
# index 리셋
비율.reset_index()
Out[62]:
In [63]:
#안타홈런.reset_index()
## 안타홈런과 비율을 병합.
안타홈런비 = pd.merge(안타홈런.reset_index(), 비율.reset_index())
# 인덱스 선수명으로 지정
안타홈런비 = 안타홈런비.set_index('선수명')
안타홈런비
Out[63]:
applymap 함수를 사용해 전체 과정을 한줄로 실행¶
- applymap 함수 : DataFrame의 함수
- Series에 대해서 apply 후 그 시리즈의 값에 대해서 map을 하는 함수. apply -> map(f)
In [144]:
# DataFrame.applymap 함수 : Series에 대해서 apply 후 그 시리즈의 값에 대해서 map을 하는 함수. apply -> map(f)
비율.applymap(출력형식)
Out[144]:
In [65]:
#pd.merge(안타홈런비.reset_index(), 안타홈런비[["안타비율", '홈런비율']].applymap(출력형식).reset_index())
#안타홈런비[["안타비율", '홈런비율']].applymap(출력형식).reset_index()
#안타홈런비.reset_index()
안타홈런비[["안타비율", '홈런비율']].applymap(출력형식)
Out[65]:
In [145]:
## applymap 함수를 구현하면 다음과 같이 만들 수 있다.
# 각 열별로 (apply)
for 열제목 in 비율:
print('===========' + 열제목 + '==============')
열 = 비율[열제목]
# 개별 값 별로 반복 (map)
for 값 in 열:
출력 = 출력형식(값)
print(출력)
정렬¶
- sort_values() 함수 사용하기
sort_values() 함수¶
In [67]:
# 홈런 많은 기준으로 정렬
안타홈런비.sort_values(by='홈런', ascending=False)
Out[67]:
In [68]:
# 기준을 두개 이상 설정
안타홈런비.sort_values(by=['홈런', '안타'], ascending=False)
Out[68]:
index 정렬 : sort_index() 함수¶
In [69]:
안타홈런비.index
Out[69]:
In [70]:
# 색인의 값을 가지고 정렬
안타홈런비.sort_index()
Out[70]:
In [71]:
# 색인을 역순으로 조회
안타홈런비.sort_index(ascending=False)
Out[71]:
In [72]:
홈런 = 안타홈런비['홈런']
In [73]:
# 정렬은되나 등수를 확인할 수 없다.
홈런.sort_values(ascending=False)
Out[73]:
등수 확인 하기¶
- rank() 함수 사용
In [74]:
# 순위 매기기 --> 낮은 값이 더 높은 순위로 표기
홈런.rank()
Out[74]:
In [75]:
# 순위 매기기 (정렬이 안된다. ...)
홈런.rank(ascending=False)
Out[75]:
In [76]:
#순위 매기고 다시 소팅
## --> 7.5라는 등수가 나타남.
### ==> 7등이 2명이 나와서 이런 현상이 발생.
홈런.rank(ascending=False).sort_values()
Out[76]:
In [77]:
# 순위 매기기 동점의 등수를 순위를 매기는 방식
# 동점 처리 방식 : method='max' , 'min', 'first', 'average'(디폴트 방식)
홈런.rank(ascending=False, method='min').sort_values()
Out[77]:
Math 사용¶
In [147]:
# 함수를 사용하기 위한 모듈 가져오기
import math
In [79]:
## 함수에 대한 도움말 보기
math.ceil?
In [80]:
np.ceil?
In [81]:
np.ceil([1.5, 2.5, 3.5, 4.4, 4.5, -1.5])
Out[81]:
통계 분석 함수¶
In [82]:
주식=pd.read_csv('data/stock_px.csv', index_col=0)
In [83]:
주식[:5]
Out[83]:
In [84]:
# pct_change() : 윗값과 아랫값과의 변화량
수익률 = 주식.pct_change()
In [85]:
수익률[:10]
## 첫번째 줄에 변화량을 없기 때문에 NaN 표기
Out[85]:
In [86]:
# 필요없는 nan 데이터를 drop 시킨다.
수익률.dropna()[:10]
Out[86]:
In [87]:
# 확률통계의 correlation - 상관관계 --> 상관관계가 높을 수록 1에 접근한다. 0.5가 넘으면 상관관계가 높은걸로 볼 수 있다.
# XOM - SPX 간의 상관 관계가 가장 높게 나온다.
수익률.corr()
Out[87]:
In [88]:
# 공분산
수익률.cov()
Out[88]:
NaN 데이터 처리 (누락된 데이터 처리)¶
2013~2015 시즌 데이터를 읽어서 "시즌" 열을 추가하고 다시 저장¶
- 각 데이터를 읽어서 시즌 열 추가
- index를 스즌, 선수명으로 변경
- 이를 다시 엑셀에 저장
- 저장된 엑셀을 다시 로드 --> 시즌에 NaN 값으로 로딩.
단순한 NaN 처리 : fillna() 함수¶
In [89]:
#nc 데이터 다시 로딩.
경로목록 = [
'data/NC Dinos 2013.xlsx',
'data/NC Dinos 2014.xlsx',
'data/NC Dinos 2015.xlsx'
]
인덱스열 = ['시즌', '선수명']
frame_list = []
for 시즌 in range(2013, 2016):
경로 = 'data/NC Dinos {}.xlsx'.format(시즌)
frame = pd.read_excel(경로)
frame['시즌'] = 시즌
#frame = frame.set_index(인덱스열)
frame_list.append(frame)
# 풀기 - 리스트의 항목을 차례로 각각의 변수에 대입
nc13, nc14, nc15 = frame_list
In [90]:
# nc15['시즌'] = 2015
nc15
Out[90]:
In [91]:
## 인덱스 리셋 -- 시즌, 선수명으로 인덱스 다시 셋팅
## reset_index()를 하지 않으면 인덱스 셋팅되지 않는다.
nc15.reset_index().set_index(['시즌', '선수명'])
Out[91]:
In [92]:
# nc15에 갱신
nc15 = nc15.reset_index().set_index(['시즌', '선수명'])
In [93]:
# excel 파일에 저장
nc15.to_excel('nc15.xlsx')
In [94]:
# excel 파일에서 다시 읽어오기
nc15 = pd.read_excel('nc15.xlsx')
In [95]:
nc15
# 시즌 열이 유실되어 있는 모양을 확인할 수 있다. 중첩인덱스 설정된 상태에서 저장된 경우 상위 인덱스의 값은 생략되어 저장된다.
Out[95]:
In [96]:
# NaN을 2015로 채운다.
nc15 = nc15.fillna(2015)
In [97]:
# 인덱스 다시 설정.
nc15.reset_index()
nc15 = nc15.set_index(['시즌', '선수명'])
In [98]:
# 다시 복구 완료.
nc15
Out[98]:
복잡한 형태의 NaN 값 채우기¶
In [99]:
#nc13['시즌'] = 2013
인덱스열 = ['시즌', '선수명']
nc13 = nc13.reset_index().set_index(인덱스열)
#nc14['시즌'] = 2014
nc14 = nc14.reset_index().set_index(인덱스열)
In [100]:
## 세 시슨 데이터 합치기
nc = pd.concat([nc13, nc14, nc15])
In [101]:
# excel 내보내기
nc.to_excel('nc_all.xlsx')
In [102]:
# excel 다시 읽어오기
nc = pd.read_excel('nc_all.xlsx')
In [103]:
nc
# 시즌 데이터가.... 2013..NaN...2014..NaN...2015... --> NaN데이터를 동일한 값으로 채울수 없다.
# 전향보간 방식을 사용해서 채운다. 앞의 값으로 뒤의 값을 채운다.
Out[103]:
In [104]:
# nc.fillna?
#method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
# Method to use for filling holes in reindexed Series
# pad / ffill: propagate last valid observation forward to next valid
# backfill / bfill: use NEXT valid observation to fill gap
In [105]:
# 전향보간 방식의 옵션을 지정해서 채운다.
nc['시즌'].fillna(method='ffill')
Out[105]:
In [106]:
# 전향보간 방식의 옵션을 지정채우고 다시 스즌에 업데이트
nc['시즌'] = nc['시즌'].fillna(method='ffill')
nc
Out[106]:
색인(Index)¶
계층색인과 색인,칼럼 스위칭¶
In [107]:
#계층색인(2개 이상의 칼럼 리스트를 색으로 사용)
nc = nc.set_index(['시즌', '선수명'])
안타홈런 = nc[['안타', '홈런']]
안타홈런
Out[107]:
In [108]:
# 계층색인으로 리인덱싱
테나 = 안타홈런.reindex(['테임즈', '나성범'], level='선수명')
테나
Out[108]:
In [109]:
# unstack: 지정된 칼럼의 값을 열로 재배치
테나.unstack('시즌')
Out[109]:
In [110]:
테나.unstack('선수명')
Out[110]:
시리즈의 정수 색인¶
In [111]:
ser = Series(['a', 'b', 'c'], index=[3,2,1])
In [112]:
ser
Out[112]:
In [113]:
# 정수 색인의 모호함. (순서인지 인덱스 값인지를 모호하다.)
ser[1]
# 색인이 1인 것을 가져온다. 두번째 원소를 선택하고자 한다면....
Out[113]:
In [114]:
# 두번째 항목을 선택하기 위해서 iloc 사용.
ser.iloc[1]
Out[114]:
In [115]:
## 따라서 색인은 정수라고 하더라도 값으로 인식하는 것이 좋다.
# python for data analysis 213페이지 참조
pandas의 read_csv/read_table의 함수 인자.¶
read_csv 사용하기¶
특정행 스킵 후 읽기¶
In [126]:
# 포멧이 ... 일정치 않은 경우
pd.read_csv('data/ex4.csv')
Out[126]:
In [127]:
# 특정행을 스킵
pd.read_csv('data/ex4.csv', skiprows=[0,2,3])
Out[127]:
In [128]:
# 주석 처리 comment : #으로 시작하는 행 스킵
pd.read_csv('data/ex4.csv', comment='#')
Out[128]:
파일의 용량이 매우 클때¶
- 조금씩 읽어 오기
In [129]:
# nrows 옵션: 지정된 행의 수만큼만 읽어 온다.
pd.read_csv('data/us_presidental.csv', nrows=5)
Out[129]:
In [130]:
# chunksize 옵션: 여러조각으로 나누어서 읽고자 할때 : 단위는 행의 갯수...
chunker = pd.read_csv('data/us_presidental.csv', chunksize=1000)
chunker
Out[130]:
In [131]:
## chunker에서 하나씩 꺼내서 사용 한다. chunker는 TextFileReader 객체이다.
## 아래와 같이 루프를 돌면서 파일을 1000개 라인씩 읽으면서 처리 한다.
for frame in chunker:
pass
엑셀에서 데이터 읽어 오기¶
- read_excel() 함수 사용
- 텍스트 파일과는 다르게 sheet가 여러개 있다는 점에 주의를 해야 한다.
- 인코딩은 신경쓸 필요가 없다.
- 구분자를 신경쓸 필요가 없다.
In [132]:
pd.read_excel('data/NC Dinos.xlsx')
# 이렇게 실행하면 첫번째 sheet만 읽어 온다.
Out[132]:
In [133]:
# 여러 sheet읽어 오기 (sheetname 옵션을 사용, 특정 sheet이름을 작성하거나
# None으로 해서 모든 sheet를 읽어 올 수 있다. )
sheets = pd.read_excel('data/NC Dinos.xlsx', sheetname=None)
In [134]:
type(sheets)
Out[134]:
In [135]:
# 2015 시트 가져오기.
sheets['2015'][:10]
Out[135]:
In [136]:
# 시트 합치기
pd.concat(sheets)
Out[136]:
In [137]:
## 한 파일에 여러 sheet로 나누어서 저장하기.
nc13, nc14, nc15 = sheets.values()
In [138]:
# 빈 excel 파일을 하나 생성 한다.
writer = pd.ExcelWriter('NC sheets.xlsx')
for 시트명, 프레임 in sheets.items():
프레임.to_excel(writer, 시트명)
# 오픈된 파일을 close 한다. (반.드.시.)
writer.close()
Json 데이터 로딩¶
In [148]:
pd.read_json('data/foods-2011-10-03.json')
Out[148]:
In [ ]:
728x90
'프로그래밍 > Python' 카테고리의 다른 글
| 기초 자료형 I 정리 (0) | 2023.04.19 |
|---|---|
| 파이썬(Python) 시계열분석 (0) | 2020.12.31 |
| 파이썬(Python) 고급문자열 처리 (0) | 2020.12.31 |
| 파이썬(Python) - 분석 실습 영화평점분석 (0) | 2020.12.29 |
| 파이썬(Python) 분석실습 -웹로그 분석 (0) | 2020.12.29 |
