Python Pandas-빠른 가이드
Pandas는 강력한 데이터 구조를 사용하여 고성능 데이터 조작 및 분석 도구를 제공하는 오픈 소스 Python 라이브러리입니다. Pandas라는 이름은 다차원 데이터의 계량 경제학 인 Panel Data라는 단어에서 파생되었습니다.
2008 년 개발자 Wes McKinney는 데이터 분석을위한 고성능의 유연한 도구가 필요할 때 팬더 개발을 시작했습니다.
Pandas 이전에는 Python이 주로 데이터 정리 및 준비에 사용되었습니다. 데이터 분석에 거의 기여하지 않았습니다. 판다는이 문제를 해결했습니다. Pandas를 사용하면 데이터 원본에 관계없이 데이터 처리 및 분석에서로드, 준비, 조작, 모델링 및 분석의 5 가지 일반적인 단계를 수행 할 수 있습니다.
Python with Pandas는 금융, 경제, 통계, 분석 등 학술 및 상업 분야를 포함한 광범위한 분야에서 사용됩니다.
Pandas의 주요 기능
- 기본 및 사용자 지정 인덱싱을 사용하는 빠르고 효율적인 DataFrame 개체입니다.
- 다양한 파일 형식에서 메모리 내 데이터 개체로 데이터를로드하기위한 도구입니다.
- 누락 된 데이터의 데이터 정렬 및 통합 처리.
- 날짜 세트의 모양 변경 및 피벗.
- 큰 데이터 세트의 레이블 기반 슬라이싱, 인덱싱 및 부분 집합 화.
- 데이터 구조의 열을 삭제하거나 삽입 할 수 있습니다.
- 집계 및 변환을 위해 데이터별로 그룹화합니다.
- 고성능 데이터 병합 및 결합.
- 시계열 기능.
표준 Python 배포는 Pandas 모듈과 함께 제공되지 않습니다. 가벼운 대안은 인기있는 Python 패키지 설치 프로그램을 사용하여 NumPy를 설치하는 것입니다.pip.
pip install pandasAnaconda Python 패키지를 설치하면 Pandas는 기본적으로 다음과 함께 설치됩니다.
윈도우
Anaconda (에서 https://www.continuum.io)는 SciPy 스택 용 무료 Python 배포판입니다. Linux 및 Mac에서도 사용할 수 있습니다.
Canopy (https://www.enthought.com/products/canopy/)는 Windows, Linux 및 Mac 용 전체 SciPy 스택과 함께 무료 및 상업용 배포로 제공됩니다.
Python(x, y)는 Windows OS 용 SciPy 스택 및 Spyder IDE가 포함 된 무료 Python 배포입니다. (에서 다운로드 가능http://python-xy.github.io/)
리눅스
각 Linux 배포판의 패키지 관리자는 SciPy 스택에 하나 이상의 패키지를 설치하는 데 사용됩니다.
For Ubuntu Users
sudo apt-get install python-numpy python-scipy python-matplotlibipythonipythonnotebook
python-pandas python-sympy python-noseFor Fedora Users
sudo yum install numpyscipy python-matplotlibipython python-pandas sympy
python-nose atlas-develPandas는 다음 세 가지 데이터 구조를 다룹니다.
- Series
- DataFrame
- Panel
이러한 데이터 구조는 Numpy 배열 위에 구축되므로 빠릅니다.
치수 및 설명
이러한 데이터 구조를 생각하는 가장 좋은 방법은 고차원 데이터 구조가 저 차원 데이터 구조의 컨테이너라는 것입니다. 예를 들어 DataFrame은 Series의 컨테이너이고 Panel은 DataFrame의 컨테이너입니다.
| 데이터 구조 | 치수 | 기술 |
|---|---|---|
| 시리즈 | 1 | 1D 레이블이 지정된 동종 배열, 크기는 변경할 수 없습니다. |
| 데이터 프레임 | 2 | 유형이 다른 열이있는 일반 2D 레이블이 지정되고 크기가 변경 가능한 테이블 형식 구조입니다. |
| 패널 | 삼 | 일반 3D 레이블, 크기 변경 가능 배열. |
2 차원 이상의 배열을 만들고 처리하는 것은 지루한 작업이며, 함수를 작성할 때 데이터 세트의 방향을 고려해야하는 부담이 사용자에게 있습니다. 그러나 Pandas 데이터 구조를 사용하면 사용자의 정신적 노력이 줄어 듭니다.
예를 들어, 테이블 형식 데이터 (DataFrame)의 경우 다음을 생각하는 것이 의미 론적으로 더 유용합니다. index (행) 및 columns 축 0과 축 1이 아니라
가변성
모든 Pandas 데이터 구조는 값을 변경할 수 있으며 (변경 가능) Series를 제외하고 모두 크기를 변경할 수 있습니다. 시리즈는 크기를 변경할 수 없습니다.
Note− DataFrame은 널리 사용되며 가장 중요한 데이터 구조 중 하나입니다. 패널은 훨씬 적게 사용됩니다.
시리즈
시리즈는 동일한 데이터가있는 구조와 같은 1 차원 배열입니다. 예를 들어, 다음 시리즈는 정수 10, 23, 56,…
| 10 | 23 | 56 | 17 | 52 | 61 | 73 | 90 | 26 | 72 |
키 포인트
- 동종 데이터
- 크기 불변
- 가변 데이터의 가치
DataFrame
DataFrame은 이기종 데이터가 포함 된 2 차원 배열입니다. 예를 들면
| 이름 | 나이 | 성별 | 평가 |
|---|---|---|---|
| 스티브 | 32 | 남성 | 3.45 |
| 리아 | 28 | 여자 | 4.6 |
| 빈 | 45 | 남성 | 3.9 |
| 케이티 | 38 | 여자 | 2.78 |
이 테이블은 전체 성과 등급과 함께 조직의 영업 팀 데이터를 나타냅니다. 데이터는 행과 열로 표시됩니다. 각 열은 속성을 나타내고 각 행은 사람을 나타냅니다.
열의 데이터 유형
네 열의 데이터 유형은 다음과 같습니다.
| 기둥 | 유형 |
|---|---|
| 이름 | 끈 |
| 나이 | 정수 |
| 성별 | 끈 |
| 평가 | 흙손 |
키 포인트
- 이기종 데이터
- 크기 변경 가능
- 데이터 변경 가능
패널
패널은 이기종 데이터가있는 3 차원 데이터 구조입니다. 패널을 그래픽으로 표현하는 것은 어렵습니다. 그러나 패널은 DataFrame의 컨테이너로 설명 할 수 있습니다.
키 포인트
- 이기종 데이터
- 크기 변경 가능
- 데이터 변경 가능
Series는 모든 유형 (정수, 문자열, 부동 소수점, 파이썬 객체 등)의 데이터를 보유 할 수있는 1 차원 레이블이 지정된 배열입니다. 축 레이블을 총칭하여 인덱스라고합니다.
pandas.Series
팬더 시리즈는 다음 생성자를 사용하여 만들 수 있습니다.
pandas.Series( data, index, dtype, copy)생성자의 매개 변수는 다음과 같습니다.
| Sr. 아니요 | 매개 변수 및 설명 |
|---|---|
| 1 | data 데이터는 ndarray, 목록, 상수와 같은 다양한 형태를 취합니다. |
| 2 | index 인덱스 값은 데이터와 길이가 같고 고유하고 해시 가능해야합니다. 기본np.arange(n) 인덱스가 전달되지 않은 경우. |
| 삼 | dtype dtype은 데이터 유형입니다. None이면 데이터 유형이 유추됩니다. |
| 4 | copy 데이터를 복사합니다. 기본값 False |
시리즈는 다음과 같은 다양한 입력을 사용하여 생성 할 수 있습니다.
- Array
- Dict
- 스칼라 값 또는 상수
빈 시리즈 만들기
생성 할 수있는 기본 시리즈는 빈 시리즈입니다.
예
#import the pandas library and aliasing as pd
import pandas as pd
s = pd.Series()
print s이것의 output 다음과 같습니다-
Series([], dtype: float64)ndarray에서 시리즈 만들기
데이터가 ndarray이면 전달 된 인덱스의 길이가 같아야합니다. 인덱스가 전달되지 않으면 기본적으로 인덱스는range(n) 어디 n 배열 길이, 즉 [0,1,2,3…. range(len(array))-1].
예 1
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data)
print s이것의 output 다음과 같습니다-
0 a
1 b
2 c
3 d
dtype: object인덱스를 전달하지 않았으므로 기본적으로 0에서 len(data)-1즉, 0 ~ 3입니다.
예 2
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data,index=[100,101,102,103])
print s이것의 output 다음과 같습니다-
100 a
101 b
102 c
103 d
dtype: object여기에 인덱스 값을 전달했습니다. 이제 출력에서 사용자 정의 된 색인 값을 볼 수 있습니다.
dict에서 시리즈 만들기
ㅏ dict입력으로 전달 될 수 있으며 색인이 지정되지 않은 경우 사전 키를 정렬 된 순서로 가져와 색인을 구성합니다. 만약index 전달되면 인덱스의 레이블에 해당하는 데이터의 값이 제거됩니다.
예 1
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print s이것의 output 다음과 같습니다-
a 0.0
b 1.0
c 2.0
dtype: float64Observe − 사전 키는 색인을 구성하는 데 사용됩니다.
예 2
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=['b','c','d','a'])
print s이것의 output 다음과 같습니다-
b 1.0
c 2.0
d NaN
a 0.0
dtype: float64Observe − 인덱스 순서는 유지되고 누락 된 요소는 NaN (Not a Number)으로 채워집니다.
스칼라에서 시리즈 생성
데이터가 스칼라 값이면 인덱스를 제공해야합니다. 값은 길이와 일치하도록 반복됩니다.index
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print s이것의 output 다음과 같습니다-
0 5
1 5
2 5
3 5
dtype: int64위치가있는 시리즈의 데이터에 액세스
시리즈의 데이터는 ndarray.
예 1
첫 번째 요소를 검색합니다. 이미 알고 있듯이 계수는 배열의 0부터 시작합니다. 즉, 첫 번째 요소가 0 번째 위치에 저장되는 식 입니다.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve the first element
print s[0]이것의 output 다음과 같습니다-
1예 2
시리즈의 처음 세 요소를 검색합니다. 앞에 :가 삽입되면 해당 색인 이후의 모든 항목이 추출됩니다. 두 개의 매개 변수 (둘 사이에 : 포함)가 사용되는 경우 두 인덱스 사이의 항목 (중지 인덱스 제외)
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve the first three element
print s[:3]이것의 output 다음과 같습니다-
a 1
b 2
c 3
dtype: int64예제 3
마지막 세 요소를 검색합니다.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve the last three element
print s[-3:]이것의 output 다음과 같습니다-
c 3
d 4
e 5
dtype: int64레이블 (색인)을 사용하여 데이터 검색
시리즈는 고정 된 크기와 같습니다. dict 인덱스 레이블로 값을 가져오고 설정할 수 있다는 점에서.
예 1
색인 레이블 값을 사용하여 단일 요소를 검색합니다.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve a single element
print s['a']이것의 output 다음과 같습니다-
1예 2
색인 레이블 값 목록을 사용하여 여러 요소를 검색합니다.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve multiple elements
print s[['a','c','d']]이것의 output 다음과 같습니다-
a 1
c 3
d 4
dtype: int64예제 3
레이블이 포함되어 있지 않으면 예외가 발생합니다.
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve multiple elements
print s['f']이것의 output 다음과 같습니다-
…
KeyError: 'f'데이터 프레임은 2 차원 데이터 구조입니다. 즉, 데이터는 행과 열에서 표 형식으로 정렬됩니다.
DataFrame의 특징
- 열이 다른 유형일 수 있음
- 크기 – 변경 가능
- 레이블이있는 축 (행 및 열)
- 행과 열에 대한 산술 연산 수행 가능
구조
학생의 데이터로 데이터 프레임을 만들고 있다고 가정 해 보겠습니다.
SQL 테이블 또는 스프레드 시트 데이터 표현으로 생각할 수 있습니다.
pandas.DataFrame
Pandas DataFrame은 다음 생성자를 사용하여 만들 수 있습니다.
pandas.DataFrame( data, index, columns, dtype, copy)생성자의 매개 변수는 다음과 같습니다.
| Sr. 아니요 | 매개 변수 및 설명 |
|---|---|
| 1 | data 데이터는 ndarray, 시리즈, 맵, 목록, dict, 상수 및 다른 DataFrame과 같은 다양한 형식을 취합니다. |
| 2 | index 행 레이블의 경우 결과 프레임에 사용할 인덱스는 인덱스가 전달되지 않으면 선택적 기본값 np.arange (n)입니다. |
| 삼 | columns 열 레이블의 경우 선택적 기본 구문은-np.arange (n)입니다. 인덱스가 전달되지 않은 경우에만 해당됩니다. |
| 4 | dtype 각 열의 데이터 유형. |
| 5 | copy 이 명령 (또는 그 무엇이든)은 기본값이 False 인 경우 데이터 복사에 사용됩니다. |
DataFrame 생성
Pandas DataFrame은 다음과 같은 다양한 입력을 사용하여 만들 수 있습니다.
- Lists
- dict
- Series
- Numpy ndarrays
- 다른 DataFrame
이 장의 다음 섹션에서는 이러한 입력을 사용하여 DataFrame을 만드는 방법을 살펴 봅니다.
빈 DataFrame 만들기
생성 할 수있는 기본 DataFrame은 빈 데이터 프레임입니다.
예
#import the pandas library and aliasing as pd
import pandas as pd
df = pd.DataFrame()
print df이것의 output 다음과 같습니다-
Empty DataFrame
Columns: []
Index: []목록에서 DataFrame 만들기
DataFrame은 단일 목록 또는 목록 목록을 사용하여 만들 수 있습니다.
예 1
import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df이것의 output 다음과 같습니다-
0
0 1
1 2
2 3
3 4
4 5예 2
import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print df이것의 output 다음과 같습니다-
Name Age
0 Alex 10
1 Bob 12
2 Clarke 13예제 3
import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print df이것의 output 다음과 같습니다-
Name Age
0 Alex 10.0
1 Bob 12.0
2 Clarke 13.0Note − 관찰, dtype 매개 변수는 Age 열의 유형을 부동 소수점으로 변경합니다.
ndarrays / 목록의 Dict에서 DataFrame 만들기
모든 ndarrays길이가 같아야합니다. 인덱스가 전달되면 인덱스의 길이는 배열의 길이와 같아야합니다.
인덱스가 전달되지 않으면 기본적으로 인덱스는 range (n)이됩니다. 여기서 n 배열 길이입니다.
예 1
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print df이것의 output 다음과 같습니다-
Age Name
0 28 Tom
1 34 Jack
2 29 Steve
3 42 RickyNote− 0,1,2,3 값을 관찰하십시오. 함수 범위 (n)를 사용하여 각각에 할당 된 기본 인덱스입니다.
예 2
이제 배열을 사용하여 인덱싱 된 DataFrame을 생성하겠습니다.
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print df이것의 output 다음과 같습니다-
Age Name
rank1 28 Tom
rank2 34 Jack
rank3 29 Steve
rank4 42 RickyNote − 관찰, index 매개 변수는 각 행에 색인을 할당합니다.
Dict 목록에서 DataFrame 만들기
사전 목록을 입력 데이터로 전달하여 DataFrame을 만들 수 있습니다. 사전 키는 기본적으로 열 이름으로 사용됩니다.
예 1
다음 예제는 사전 목록을 전달하여 DataFrame을 만드는 방법을 보여줍니다.
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print df이것의 output 다음과 같습니다-
a b c
0 1 2 NaN
1 5 10 20.0Note − 누락 된 영역에 NaN (숫자가 아님)이 추가됩니다.
예 2
다음 예제는 사전 목록과 행 인덱스를 전달하여 DataFrame을 만드는 방법을 보여줍니다.
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print df이것의 output 다음과 같습니다-
a b c
first 1 2 NaN
second 5 10 20.0예제 3
다음 예제에서는 사전, 행 인덱스 및 열 인덱스 목록을 사용하여 DataFrame을 만드는 방법을 보여줍니다.
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
#With two column indices, values same as dictionary keys
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])
#With two column indices with one index with other name
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print df1
print df2이것의 output 다음과 같습니다-
#df1 output
a b
first 1 2
second 5 10
#df2 output
a b1
first 1 NaN
second 5 NaNNote− df2 DataFrame은 딕셔너리 키가 아닌 열 인덱스로 생성됩니다. 따라서 NaN이 제자리에 추가되었습니다. 반면 df1은 사전 키와 동일한 열 인덱스로 생성되므로 NaN이 추가됩니다.
Dict of Series에서 DataFrame 만들기
Series 사전을 전달하여 DataFrame을 형성 할 수 있습니다. 결과 색인은 전달 된 모든 시리즈 색인의 합집합입니다.
예
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df이것의 output 다음과 같습니다-
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4Note − 시리즈 1의 경우 레이블이 없음을 관찰하십시오. ‘d’ 통과했지만 결과적으로 d 레이블, NaN에는 NaN이 추가됩니다.
이제 이해합시다 column selection, addition, 및 deletion 예를 통해.
열 선택
DataFrame에서 열을 선택하여이를 이해할 수 있습니다.
예
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df ['one']이것의 output 다음과 같습니다-
a 1.0
b 2.0
c 3.0
d NaN
Name: one, dtype: float64컬럼 추가
기존 데이터 프레임에 새 열을 추가하여이를 이해합니다.
예
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
# Adding a new column to an existing DataFrame object with column label by passing new series
print ("Adding a new column by passing as Series:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print df
print ("Adding a new column using the existing columns in DataFrame:")
df['four']=df['one']+df['three']
print df이것의 output 다음과 같습니다-
Adding a new column by passing as Series:
one two three
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
Adding a new column using the existing columns in DataFrame:
one two three four
a 1.0 1 10.0 11.0
b 2.0 2 20.0 22.0
c 3.0 3 30.0 33.0
d NaN 4 NaN NaN열 삭제
열을 삭제하거나 팝할 수 있습니다. 방법을 이해하기 위해 예를 들어 보겠습니다.
예
# Using the previous DataFrame, we will delete a column
# using del function
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']),
'three' : pd.Series([10,20,30], index=['a','b','c'])}
df = pd.DataFrame(d)
print ("Our dataframe is:")
print df
# using del function
print ("Deleting the first column using DEL function:")
del df['one']
print df
# using pop function
print ("Deleting another column using POP function:")
df.pop('two')
print df이것의 output 다음과 같습니다-
Our dataframe is:
one three two
a 1.0 10.0 1
b 2.0 20.0 2
c 3.0 30.0 3
d NaN NaN 4
Deleting the first column using DEL function:
three two
a 10.0 1
b 20.0 2
c 30.0 3
d NaN 4
Deleting another column using POP function:
three
a 10.0
b 20.0
c 30.0
d NaN행 선택, 추가 및 삭제
이제 예제를 통해 행 선택, 추가 및 삭제를 이해합니다. 선택의 개념부터 시작하겠습니다.
라벨 별 선택
행 레이블을 a로 전달하여 행을 선택할 수 있습니다. loc 함수.
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df.loc['b']이것의 output 다음과 같습니다-
one 2.0
two 2.0
Name: b, dtype: float64결과는 DataFrame의 열 이름으로 레이블이있는 시리즈입니다. 그리고 시리즈의 이름은 검색되는 레이블입니다.
정수 위치로 선택
정수 위치를 전달하여 행을 선택할 수 있습니다. iloc 함수.
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df.iloc[2]이것의 output 다음과 같습니다-
one 3.0
two 3.0
Name: c, dtype: float64슬라이스 행
':'연산자를 사용하여 여러 행을 선택할 수 있습니다.
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df[2:4]이것의 output 다음과 같습니다-
one two
c 3.0 3
d NaN 4행 추가
다음을 사용하여 DataFrame에 새 행을 추가합니다. append함수. 이 함수는 끝에 행을 추가합니다.
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
print df이것의 output 다음과 같습니다-
a b
0 1 2
1 3 4
0 5 6
1 7 8행 삭제
인덱스 레이블을 사용하여 DataFrame에서 행을 삭제하거나 삭제합니다. 레이블이 중복되면 여러 행이 삭제됩니다.
위의 예에서 관찰하면 레이블이 중복됩니다. 레이블을 삭제하고 얼마나 많은 행이 삭제되는지 살펴 보겠습니다.
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
# Drop rows with label 0
df = df.drop(0)
print df이것의 output 다음과 같습니다-
a b
1 3 4
1 7 8위의 예에서는 두 행에 동일한 레이블 0이 포함되어 있으므로 두 행이 삭제되었습니다.
ㅏ panel데이터의 3D 컨테이너입니다. 용어Panel data 계량 경제학에서 파생되었으며 판다라는 이름에 부분적으로 책임이 있습니다. pan(el)-da(ta)-에스.
세 축의 이름은 패널 데이터와 관련된 작업을 설명하는 데 의미 론적 의미를 부여하기위한 것입니다. 그들은-
items − 축 0, 각 항목은 내부에 포함 된 DataFrame에 해당합니다.
major_axis − 축 1, 각 DataFrame의 인덱스 (행)입니다.
minor_axis − 축 2, 각 DataFrame의 열입니다.
pandas.Panel ()
패널은 다음 생성자를 사용하여 만들 수 있습니다-
pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)생성자의 매개 변수는 다음과 같습니다.
| 매개 변수 | 기술 |
|---|---|
| 데이터 | 데이터는 ndarray, 시리즈, 맵, 목록, dict, 상수 및 다른 DataFrame과 같은 다양한 형식을 취합니다. |
| 항목 | 축 = 0 |
| major_axis | 축 = 1 |
| minor_axis | 축 = 2 |
| dtype | 각 열의 데이터 유형 |
| 부 | 데이터를 복사합니다. 기본,false |
패널 만들기
패널은 다음과 같은 여러 방법을 사용하여 만들 수 있습니다.
- ndarrays에서
- DataFrames 사전에서
3D ndarray에서
# creating an empty panel
import pandas as pd
import numpy as np
data = np.random.rand(2,4,5)
p = pd.Panel(data)
print p이것의 output 다음과 같습니다-
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 5 (minor_axis)
Items axis: 0 to 1
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 4Note − 빈 패널과 위 패널의 치수를 관찰하십시오. 모든 개체가 다릅니다.
DataFrame 객체의 dict에서
#creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p이것의 output 다음과 같습니다-
Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2빈 패널 만들기
다음과 같이 Panel 생성자를 사용하여 빈 패널을 만들 수 있습니다.
#creating an empty panel
import pandas as pd
p = pd.Panel()
print p이것의 output 다음과 같습니다-
<class 'pandas.core.panel.Panel'>
Dimensions: 0 (items) x 0 (major_axis) x 0 (minor_axis)
Items axis: None
Major_axis axis: None
Minor_axis axis: None패널에서 데이터 선택
−를 사용하여 패널에서 데이터를 선택합니다.
- Items
- Major_axis
- Minor_axis
아이템 사용
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p['Item1']이것의 output 다음과 같습니다-
0 1 2
0 0.488224 -0.128637 0.930817
1 0.417497 0.896681 0.576657
2 -2.775266 0.571668 0.290082
3 -0.400538 -0.144234 1.110535두 개의 항목이 있으며 item1을 검색했습니다. 결과는 4 개의 행과 3 개의 열이있는 DataFrame입니다.Major_axis 과 Minor_axis 치수.
major_axis 사용
방법을 사용하여 데이터에 액세스 할 수 있습니다. panel.major_axis(index).
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.major_xs(1)이것의 output 다음과 같습니다-
Item1 Item2
0 0.417497 0.748412
1 0.896681 -0.557322
2 0.576657 NaNminor_axis 사용
방법을 사용하여 데이터에 액세스 할 수 있습니다. panel.minor_axis(index).
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.minor_xs(1)이것의 output 다음과 같습니다-
Item1 Item2
0 -0.128637 -1.047032
1 0.896681 -0.557322
2 0.571668 0.431953
3 -0.144234 1.302466Note − 치수의 변화를 관찰하십시오.
지금까지 우리는 Pandas DataStructures 세 가지와이를 만드는 방법에 대해 배웠습니다. 실시간 데이터 처리에서의 중요성 때문에 DataFrame 개체에 주로 초점을 맞추고 몇 가지 다른 DataStructures에 대해서도 논의합니다.
시리즈 기본 기능
| Sr. 아니. | 속성 또는 방법 및 설명 |
|---|---|
| 1 | axes 행 축 레이블 목록을 반환합니다. |
| 2 | dtype 객체의 dtype을 반환합니다. |
| 삼 | empty 계열이 비어 있으면 True를 반환합니다. |
| 4 | ndim 정의 1에 따라 기본 데이터의 차원 수를 반환합니다. |
| 5 | size 기본 데이터의 요소 수를 반환합니다. |
| 6 | values Series를 ndarray로 반환합니다. |
| 7 | head() 처음 n 개 행을 반환합니다. |
| 8 | tail() 마지막 n 개 행을 반환합니다. |
이제 시리즈를 생성하고 위의 모든 표로 작성된 속성 작업을 살펴 보겠습니다.
예
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print s이것의 output 다음과 같습니다-
0 0.967853
1 -0.148368
2 -1.395906
3 -1.758394
dtype: float64축
시리즈의 레이블 목록을 반환합니다.
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("The axes are:")
print s.axes이것의 output 다음과 같습니다-
The axes are:
[RangeIndex(start=0, stop=4, step=1)]위의 결과는 0에서 5까지의 값 목록 (예 : [0,1,2,3,4])의 압축 형식입니다.
빈
Object가 비어 있는지 여부를 나타내는 Boolean 값을 반환합니다. True는 개체가 비어 있음을 나타냅니다.
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("Is the Object empty?")
print s.empty이것의 output 다음과 같습니다-
Is the Object empty?
Falsendim
개체의 차원 수를 반환합니다. 정의에 따라 Series는 1D 데이터 구조이므로 다음을 반환합니다.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s
print ("The dimensions of the object:")
print s.ndim이것의 output 다음과 같습니다-
0 0.175898
1 0.166197
2 -0.609712
3 -1.377000
dtype: float64
The dimensions of the object:
1크기
시리즈의 크기 (길이)를 반환합니다.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(2))
print s
print ("The size of the object:")
print s.size이것의 output 다음과 같습니다-
0 3.078058
1 -1.207803
dtype: float64
The size of the object:
2가치
계열의 실제 데이터를 배열로 반환합니다.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s
print ("The actual data series is:")
print s.values이것의 output 다음과 같습니다-
0 1.787373
1 -0.605159
2 0.180477
3 -0.140922
dtype: float64
The actual data series is:
[ 1.78737302 -0.60515881 0.18047664 -0.1409218 ]머리와 꼬리
Series 또는 DataFrame 객체의 작은 샘플을 보려면 head () 및 tail () 메서드를 사용하십시오.
head() 첫 번째를 반환 n행 (인덱스 값 관찰). 표시 할 기본 요소 수는 5 개이지만 사용자 지정 번호를 전달할 수 있습니다.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s
print ("The first two rows of the data series:")
print s.head(2)이것의 output 다음과 같습니다-
The original series is:
0 0.720876
1 -0.765898
2 0.479221
3 -0.139547
dtype: float64
The first two rows of the data series:
0 0.720876
1 -0.765898
dtype: float64tail() 마지막을 반환 n행 (인덱스 값 관찰). 표시 할 기본 요소 수는 5 개이지만 사용자 지정 번호를 전달할 수 있습니다.
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s
print ("The last two rows of the data series:")
print s.tail(2)이것의 output 다음과 같습니다-
The original series is:
0 -0.655091
1 -0.881407
2 -0.608592
3 -2.341413
dtype: float64
The last two rows of the data series:
2 -0.608592
3 -2.341413
dtype: float64DataFrame 기본 기능
이제 DataFrame 기본 기능이 무엇인지 이해하겠습니다. 다음 표에는 DataFrame 기본 기능에 도움이되는 중요한 속성 또는 메서드가 나열되어 있습니다.
| Sr. 아니. | 속성 또는 방법 및 설명 |
|---|---|
| 1 | T 행과 열을 바꿉니다. |
| 2 | axes 행 축 레이블과 열 축 레이블이 유일한 멤버 인 목록을 반환합니다. |
| 삼 | dtypes 이 객체의 dtype을 반환합니다. |
| 4 | empty NDFrame이 완전히 비어 있으면 참 [항목 없음]. 축의 길이가 0 인 경우. |
| 5 | ndim 축 수 / 배열 차원. |
| 6 | shape DataFrame의 차원을 나타내는 튜플을 반환합니다. |
| 7 | size NDFrame의 요소 수입니다. |
| 8 | values NDFrame의 Numpy 표현. |
| 9 | head() 처음 n 개 행을 반환합니다. |
| 10 | tail() 마지막 n 개 행을 반환합니다. |
이제 DataFrame을 만들고 위에서 언급 한 속성의 작동 방식을 모두 살펴 보겠습니다.
예
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data series is:")
print df이것의 output 다음과 같습니다-
Our data series is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80T (조옮김)
DataFrame의 전치를 반환합니다. 행과 열이 서로 바뀝니다.
import pandas as pd
import numpy as np
# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
# Create a DataFrame
df = pd.DataFrame(d)
print ("The transpose of the data series is:")
print df.T이것의 output 다음과 같습니다-
The transpose of the data series is:
0 1 2 3 4 5 6
Age 25 26 25 23 30 29 23
Name Tom James Ricky Vin Steve Smith Jack
Rating 4.23 3.24 3.98 2.56 3.2 4.6 3.8축
행 축 레이블 및 열 축 레이블 목록을 반환합니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Row axis labels and column axis labels are:")
print df.axes이것의 output 다음과 같습니다-
Row axis labels and column axis labels are:
[RangeIndex(start=0, stop=7, step=1), Index([u'Age', u'Name', u'Rating'],
dtype='object')]dtypes
각 열의 데이터 유형을 반환합니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("The data types of each column are:")
print df.dtypes이것의 output 다음과 같습니다-
The data types of each column are:
Age int64
Name object
Rating float64
dtype: object빈
Object가 비어 있는지 여부를 나타내는 부울 값을 반환합니다. True는 개체가 비어 있음을 나타냅니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Is the object empty?")
print df.empty이것의 output 다음과 같습니다-
Is the object empty?
Falsendim
개체의 차원 수를 반환합니다. 정의에 따라 DataFrame은 2D 개체입니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The dimension of the object is:")
print df.ndim이것의 output 다음과 같습니다-
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The dimension of the object is:
2모양
DataFrame의 차원을 나타내는 튜플을 반환합니다. 튜플 (a, b), 여기서 a는 행 수를 나타내고b 열 수를 나타냅니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The shape of the object is:")
print df.shape이것의 output 다음과 같습니다-
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The shape of the object is:
(7, 3)크기
DataFrame의 요소 수를 반환합니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The total number of elements in our object is:")
print df.size이것의 output 다음과 같습니다-
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The total number of elements in our object is:
21가치
DataFrame의 실제 데이터를 NDarray.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The actual data in our data frame is:")
print df.values이것의 output 다음과 같습니다-
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The actual data in our data frame is:
[[25 'Tom' 4.23]
[26 'James' 3.24]
[25 'Ricky' 3.98]
[23 'Vin' 2.56]
[30 'Steve' 3.2]
[29 'Smith' 4.6]
[23 'Jack' 3.8]]머리와 꼬리
DataFrame 개체의 작은 샘플을 보려면 head() 및 tail () 메서드. head() 첫 번째를 반환 n행 (인덱스 값 관찰). 표시 할 기본 요소 수는 5 개이지만 사용자 지정 번호를 전달할 수 있습니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The first two rows of the data frame is:")
print df.head(2)이것의 output 다음과 같습니다-
Our data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The first two rows of the data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24tail() 마지막을 반환 n행 (인덱스 값 관찰). 표시 할 기본 요소 수는 5 개이지만 사용자 지정 번호를 전달할 수 있습니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The last two rows of the data frame is:")
print df.tail(2)이것의 output 다음과 같습니다-
Our data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The last two rows of the data frame is:
Age Name Rating
5 29 Smith 4.6
6 23 Jack 3.8많은 메서드가 DataFrame에서 기술 통계 및 기타 관련 작업을 집합 적으로 계산합니다. 이들 중 대부분은 다음과 같은 집계입니다.sum(), mean(), 하지만 그들 중 일부는 sumsum(), 동일한 크기의 개체를 생성합니다. 일반적으로 이러한 방법은axisndarray. {sum, std, ...} 와 같은 인수 이지만 축은 이름 또는 정수로 지정할 수 있습니다.
DataFrame − "index"(축 = 0, 기본값), "columns"(axis = 1)
DataFrame을 만들고이 장에서 모든 작업에이 개체를 사용하겠습니다.
예
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df이것의 output 다음과 같습니다-
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
7 34 Lee 3.78
8 40 David 2.98
9 30 Gasper 4.80
10 51 Betina 4.10
11 46 Andres 3.65합집합()
요청 된 축에 대한 값의 합계를 반환합니다. 기본적으로 축은 인덱스 (축 = 0)입니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum()이것의 output 다음과 같습니다-
Age 382
Name TomJamesRickyVinSteveSmithJackLeeDavidGasperBe...
Rating 44.92
dtype: object각 개별 열이 개별적으로 추가됩니다 (문자열이 추가됨).
축 = 1
이 구문은 아래와 같이 출력을 제공합니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum(1)이것의 output 다음과 같습니다-
0 29.23
1 29.24
2 28.98
3 25.56
4 33.20
5 33.60
6 26.80
7 37.78
8 42.98
9 34.80
10 55.10
11 49.65
dtype: float64평균()
평균값을 반환합니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.mean()이것의 output 다음과 같습니다-
Age 31.833333
Rating 3.743333
dtype: float64std ()
숫자 열의 Bressel 표준 편차를 반환합니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.std()이것의 output 다음과 같습니다-
Age 9.232682
Rating 0.661628
dtype: float64기능 및 설명
이제 Python Pandas의 기술 통계에있는 함수를 이해하겠습니다. 다음 표에는 중요한 기능이 나열되어 있습니다.
| Sr. 아니. | 함수 | 기술 |
|---|---|---|
| 1 | 카운트() | Null이 아닌 관측치 수 |
| 2 | 합집합() | 값의 합계 |
| 삼 | 평균() | 가치의 평균 |
| 4 | 중앙값() | 가치의 중앙값 |
| 5 | 방법() | 가치 모드 |
| 6 | std () | 값의 표준 편차 |
| 7 | min () | 최소값 |
| 8 | max () | 최대 가치 |
| 9 | abs () | 절대 값 |
| 10 | 찌르다() | 가치의 제품 |
| 11 | cumsum () | 누적 합계 |
| 12 | cumprod () | 누적 제품 |
Note− DataFrame은 이기종 데이터 구조이기 때문입니다. 일반 작업은 모든 기능에서 작동하지 않습니다.
같은 기능 sum(), cumsum()오류없이 숫자 및 문자 (또는) 문자열 데이터 요소 모두에서 작동합니다. 그러나n 실제로 문자 집계는 일반적으로 사용되지 않으며 이러한 함수는 예외를 발생시키지 않습니다.
같은 기능 abs(), cumprod() 이러한 작업을 수행 할 수 없기 때문에 DataFrame에 문자 또는 문자열 데이터가 포함 된 경우 예외가 발생합니다.
데이터 요약
그만큼 describe() 함수는 DataFrame 열과 관련된 통계 요약을 계산합니다.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.describe()이것의 output 다음과 같습니다-
Age Rating
count 12.000000 12.000000
mean 31.833333 3.743333
std 9.232682 0.661628
min 23.000000 2.560000
25% 25.000000 3.230000
50% 29.500000 3.790000
75% 35.500000 4.132500
max 51.000000 4.800000이 기능은 mean, std 과 IQR가치. 그리고 함수는 문자 열과 숫자 열에 대한 요약을 제외합니다.'include'요약을 위해 고려해야 할 열에 대한 필수 정보를 전달하는 데 사용되는 인수입니다. 값 목록을 가져옵니다. 기본적으로 '숫자'입니다.
- object − 문자열 열 요약
- number − 숫자 열 요약
- all − 모든 열을 함께 요약합니다 (목록 값으로 전달하면 안 됨).
이제 프로그램에서 다음 명령문을 사용하고 출력을 확인하십시오.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.describe(include=['object'])이것의 output 다음과 같습니다-
Name
count 12
unique 12
top Ricky
freq 1이제 다음 문을 사용하여 출력을 확인하십시오.
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df. describe(include='all')이것의 output 다음과 같습니다-
Age Name Rating
count 12.000000 12 12.000000
unique NaN 12 NaN
top NaN Ricky NaN
freq NaN 1 NaN
mean 31.833333 NaN 3.743333
std 9.232682 NaN 0.661628
min 23.000000 NaN 2.560000
25% 25.000000 NaN 3.230000
50% 29.500000 NaN 3.790000
75% 35.500000 NaN 4.132500
max 51.000000 NaN 4.800000자신 또는 다른 라이브러리의 함수를 Pandas 개체에 적용하려면 세 가지 중요한 방법을 알고 있어야합니다. 방법은 아래에 설명되어 있습니다. 사용할 적절한 방법은 함수가 전체 DataFrame, 행 또는 열 단위 또는 요소 단위에서 작동할지 여부에 따라 다릅니다.
- 테이블 현명한 함수 응용 프로그램 : pipe ()
- 행 또는 열 현명한 함수 응용 프로그램 : apply ()
- 요소 별 함수 적용 : applymap ()
테이블 방식의 함수 적용
함수와 적절한 수의 매개 변수를 파이프 인수로 전달하여 사용자 지정 작업을 수행 할 수 있습니다. 따라서 전체 DataFrame에서 작업이 수행됩니다.
예를 들어 DataFrame의 모든 요소에 값 2를 추가합니다. 그때,
가산기 기능
가산기 함수는 두 개의 숫자 값을 매개 변수로 더하고 합계를 반환합니다.
def adder(ele1,ele2):
return ele1+ele2이제 사용자 지정 함수를 사용하여 DataFrame에서 작업을 수행합니다.
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)전체 프로그램을 보자-
import pandas as pd
import numpy as np
def adder(ele1,ele2):
return ele1+ele2
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)
print df.apply(np.mean)이것의 output 다음과 같습니다-
col1 col2 col3
0 2.176704 2.219691 1.509360
1 2.222378 2.422167 3.953921
2 2.241096 1.135424 2.696432
3 2.355763 0.376672 1.182570
4 2.308743 2.714767 2.130288행 또는 열 현명한 함수 응용 프로그램
DataFrame 또는 Panel의 축을 따라 임의의 기능을 적용 할 수 있습니다. apply()기술 통계 방법과 마찬가지로 선택적 축 인수를 사용하는 방법입니다. 기본적으로 작업은 각 열을 배열과 같이 사용하여 열 방식으로 수행합니다.
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
print df.apply(np.mean)이것의 output 다음과 같습니다-
col1 -0.288022
col2 1.044839
col3 -0.187009
dtype: float64통과함으로써 axis 매개 변수, 작업은 행 방식으로 수행 할 수 있습니다.
예 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean,axis=1)
print df.apply(np.mean)이것의 output 다음과 같습니다-
col1 0.034093
col2 -0.152672
col3 -0.229728
dtype: float64예제 3
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(lambda x: x.max() - x.min())
print df.apply(np.mean)이것의 output 다음과 같습니다-
col1 -0.167413
col2 -0.370495
col3 -0.707631
dtype: float64요소 현명한 기능 적용
모든 함수를 벡터화 할 수있는 것은 아닙니다 (다른 배열이나 값을 반환하는 NumPy 배열이 아님). applymap() DataFrame 및 analogously map() 시리즈에서는 단일 값을 취하고 단일 값을 반환하는 모든 Python 함수를 허용합니다.
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
# My custom function
df['col1'].map(lambda x:x*100)
print df.apply(np.mean)이것의 output 다음과 같습니다-
col1 0.480742
col2 0.454185
col3 0.266563
dtype: float64예 2
import pandas as pd
import numpy as np
# My custom function
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.applymap(lambda x:x*100)
print df.apply(np.mean)이것의 output 다음과 같습니다-
col1 0.395263
col2 0.204418
col3 -0.795188
dtype: float64ReindexingDataFrame의 행 레이블 및 열 레이블을 변경합니다. 재 색인 이란 특정 축을 따라 주어진 레이블 집합과 일치하도록 데이터를 일치시키는 것을 의미합니다.
다음과 같은 인덱싱을 통해 여러 작업을 수행 할 수 있습니다.
새 레이블 세트와 일치하도록 기존 데이터의 순서를 변경하십시오.
레이블에 대한 데이터가없는 레이블 위치에 결 측값 (NA) 마커를 삽입합니다.
예
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
#reindex the DataFrame
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])
print df_reindexed이것의 output 다음과 같습니다-
A C B
0 2016-01-01 Low NaN
2 2016-01-03 High NaN
5 2016-01-06 Low NaN다른 개체와 정렬하기 위해 다시 색인화
객체를 가져 와서 다른 객체와 동일하게 레이블이 지정되도록 해당 축을 다시 인덱싱 할 수 있습니다. 동일한 내용을 이해하려면 다음 예제를 고려하십시오.
예
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])
df1 = df1.reindex_like(df2)
print df1이것의 output 다음과 같습니다-
col1 col2 col3
0 -2.467652 -1.211687 -0.391761
1 -0.287396 0.522350 0.562512
2 -0.255409 -0.483250 1.866258
3 -1.150467 -0.646493 -0.222462
4 0.152768 -2.056643 1.877233
5 -1.155997 1.528719 -1.343719
6 -1.015606 -1.245936 -0.295275Note − 여기서 df1 DataFrame은 다음과 같이 변경되고 다시 색인화됩니다. df2. 열 이름이 일치해야합니다. 그렇지 않으면 전체 열 레이블에 NAN이 추가됩니다.
재 인덱싱 중 채우기
reindex() 다음과 같이 값을 채우는 방법 인 선택적 매개 변수 방법을 취합니다.
pad/ffill − 앞으로 값 채우기
bfill/backfill − 값을 뒤로 채우기
nearest − 가장 가까운 인덱스 값에서 채우기
예
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
# Padding NAN's
print df2.reindex_like(df1)
# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill:")
print df2.reindex_like(df1,method='ffill')이것의 output 다음과 같습니다-
col1 col2 col3
0 1.311620 -0.707176 0.599863
1 -0.423455 -0.700265 1.133371
2 NaN NaN NaN
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
Data Frame with Forward Fill:
col1 col2 col3
0 1.311620 -0.707176 0.599863
1 -0.423455 -0.700265 1.133371
2 -0.423455 -0.700265 1.133371
3 -0.423455 -0.700265 1.133371
4 -0.423455 -0.700265 1.133371
5 -0.423455 -0.700265 1.133371Note − 마지막 4 개 행이 채워집니다.
재색 인화 중 채우기 제한
limit 인수는 재색 인화하는 동안 채우기에 대한 추가 제어를 제공합니다. 제한은 연속 일치의 최대 개수를 지정합니다. 같은 것을 이해하기 위해 다음 예를 고려해 보겠습니다.
예
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
# Padding NAN's
print df2.reindex_like(df1)
# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill limiting to 1:")
print df2.reindex_like(df1,method='ffill',limit=1)이것의 output 다음과 같습니다-
col1 col2 col3
0 0.247784 2.128727 0.702576
1 -0.055713 -0.021732 -0.174577
2 NaN NaN NaN
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
Data Frame with Forward Fill limiting to 1:
col1 col2 col3
0 0.247784 2.128727 0.702576
1 -0.055713 -0.021732 -0.174577
2 -0.055713 -0.021732 -0.174577
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaNNote− 관찰하십시오. 7 번째 행만 이전 6 번째 행으로 채워집니다. 그런 다음 행은 그대로 유지됩니다.
이름 바꾸기
rename () 메서드를 사용하면 일부 매핑 (dict 또는 Series) 또는 임의의 함수를 기반으로 축의 레이블을 다시 지정할 수 있습니다.
이것을 이해하기 위해 다음 예제를 고려해 보겠습니다.
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print df1
print ("After renaming the rows and columns:")
print df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},
index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})이것의 output 다음과 같습니다-
col1 col2 col3
0 0.486791 0.105759 1.540122
1 -0.990237 1.007885 -0.217896
2 -0.483855 -1.645027 -1.194113
3 -0.122316 0.566277 -0.366028
4 -0.231524 -0.721172 -0.112007
5 0.438810 0.000225 0.435479
After renaming the rows and columns:
c1 c2 col3
apple 0.486791 0.105759 1.540122
banana -0.990237 1.007885 -0.217896
durian -0.483855 -1.645027 -1.194113
3 -0.122316 0.566277 -0.366028
4 -0.231524 -0.721172 -0.112007
5 0.438810 0.000225 0.435479rename () 메서드는 inplace기본적으로 False이며 기본 데이터를 복사합니다. 통과하다inplace=True 데이터의 이름을 바꿉니다.
Pandas 객체에 대한 기본 반복 동작은 유형에 따라 다릅니다. 시리즈를 반복하면 배열과 같은 것으로 간주되고 기본 반복이 값을 생성합니다. DataFrame 및 Panel과 같은 다른 데이터 구조는dict-like 반복하는 규칙 keys 개체의.
간단히 말해, 기본 반복 ( i 개체에서) 생성-
Series − 값
DataFrame − 열 레이블
Panel − 항목 라벨
DataFrame 반복
DataFrame을 반복하면 열 이름이 제공됩니다. 동일한 내용을 이해하기 위해 다음 예를 살펴 보겠습니다.
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
for col in df:
print col이것의 output 다음과 같습니다-
A
C
D
x
yDataFrame의 행을 반복하려면 다음 함수를 사용할 수 있습니다.
iteritems() − (키, 값) 쌍을 반복
iterrows() − (인덱스, 시리즈) 쌍으로 행을 반복
itertuples() − namedtuple로 행을 반복
iteritems ()
각 열을 키로, 값 쌍을 키로, 열 값을 Series 객체로 반복합니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
print key,value이것의 output 다음과 같습니다-
col1 0 0.802390
1 0.324060
2 0.256811
3 0.839186
Name: col1, dtype: float64
col2 0 1.624313
1 -1.033582
2 1.796663
3 1.856277
Name: col2, dtype: float64
col3 0 -0.022142
1 -0.230820
2 1.160691
3 -0.830279
Name: col3, dtype: float64각 열은 시리즈에서 키-값 쌍으로 개별적으로 반복됩니다.
iterrows ()
iterrows ()는 각 행의 데이터를 포함하는 시리즈와 함께 각 인덱스 값을 산출하는 반복자를 반환합니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row_index,row in df.iterrows():
print row_index,row이것의 output 다음과 같습니다-
0 col1 1.529759
col2 0.762811
col3 -0.634691
Name: 0, dtype: float64
1 col1 -0.944087
col2 1.420919
col3 -0.507895
Name: 1, dtype: float64
2 col1 -0.077287
col2 -0.858556
col3 -0.663385
Name: 2, dtype: float64
3 col1 -1.638578
col2 0.059866
col3 0.493482
Name: 3, dtype: float64Note − 왜냐하면 iterrows()행을 반복하면 행 전체에서 데이터 유형이 유지되지 않습니다. 0,1,2는 행 인덱스이고 col1, col2, col3은 열 인덱스입니다.
itertuples ()
itertuples () 메서드는 DataFrame의 각 행에 대해 명명 된 튜플을 생성하는 반복자를 반환합니다. 튜플의 첫 번째 요소는 행의 해당 인덱스 값이되고 나머지 값은 행 값입니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row in df.itertuples():
print row이것의 output 다음과 같습니다-
Pandas(Index=0, col1=1.5297586201375899, col2=0.76281127433814944, col3=-
0.6346908238310438)
Pandas(Index=1, col1=-0.94408735763808649, col2=1.4209186418359423, col3=-
0.50789517967096232)
Pandas(Index=2, col1=-0.07728664756791935, col2=-0.85855574139699076, col3=-
0.6633852507207626)
Pandas(Index=3, col1=0.65734942534106289, col2=-0.95057710432604969,
col3=0.80344487462316527)Note− 반복하는 동안 객체를 수정하지 마십시오. 반복은 읽기를위한 것이며 반복자는 원본 개체 (뷰)의 복사본을 반환하므로 변경 사항이 원본 개체에 반영되지 않습니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for index, row in df.iterrows():
row['a'] = 10
print df이것의 output 다음과 같습니다-
col1 col2 col3
0 -1.739815 0.735595 -0.295589
1 0.635485 0.106803 1.527922
2 -0.939064 0.547095 0.038585
3 -1.016509 -0.116580 -0.523158변경 사항이 반영되지 않은 것을 관찰하십시오.
Pandas에는 두 가지 종류의 정렬이 있습니다. 그들은-
- 라벨 별
- 실제 가치로
출력이있는 예를 살펴 보겠습니다.
import pandas as pd
import numpy as np
unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns=['col2','col1'])
print unsorted_df이것의 output 다음과 같습니다-
col2 col1
1 -2.063177 0.537527
4 0.142932 -0.684884
6 0.012667 -0.389340
2 -0.548797 1.848743
3 -1.044160 0.837381
5 0.385605 1.300185
9 1.031425 -1.002967
8 -0.407374 -0.435142
0 2.237453 -1.067139
7 -1.445831 -1.701035에 unsorted_df, labels 그리고 values정렬되지 않았습니다. 이것들이 어떻게 분류 될 수 있는지 봅시다.
라벨 별
사용 sort_index()메서드에서 축 인수와 정렬 순서를 전달하여 DataFrame을 정렬 할 수 있습니다. 기본적으로 정렬은 오름차순으로 행 레이블에서 수행됩니다.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df=unsorted_df.sort_index()
print sorted_df이것의 output 다음과 같습니다-
col2 col1
0 0.208464 0.627037
1 0.641004 0.331352
2 -0.038067 -0.464730
3 -0.638456 -0.021466
4 0.014646 -0.737438
5 -0.290761 -1.669827
6 -0.797303 -0.018737
7 0.525753 1.628921
8 -0.567031 0.775951
9 0.060724 -0.322425정렬 순서
부울 값을 오름차순 매개 변수에 전달하면 정렬 순서를 제어 할 수 있습니다. 동일한 내용을 이해하기 위해 다음 예를 살펴 보겠습니다.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df = unsorted_df.sort_index(ascending=False)
print sorted_df이것의 output 다음과 같습니다-
col2 col1
9 0.825697 0.374463
8 -1.699509 0.510373
7 -0.581378 0.622958
6 -0.202951 0.954300
5 -1.289321 -1.551250
4 1.302561 0.851385
3 -0.157915 -0.388659
2 -1.222295 0.166609
1 0.584890 -0.291048
0 0.668444 -0.061294열 정렬
값이 0 또는 1 인 축 인수를 전달하면 열 레이블에서 정렬을 수행 할 수 있습니다. 기본적으로 axis = 0, 행별로 정렬됩니다. 동일한 내용을 이해하기 위해 다음 예를 살펴 보겠습니다.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df=unsorted_df.sort_index(axis=1)
print sorted_df이것의 output 다음과 같습니다-
col1 col2
1 -0.291048 0.584890
4 0.851385 1.302561
6 0.954300 -0.202951
2 0.166609 -1.222295
3 -0.388659 -0.157915
5 -1.551250 -1.289321
9 0.374463 0.825697
8 0.510373 -1.699509
0 -0.061294 0.668444
7 0.622958 -0.581378가치 별
인덱스 정렬과 마찬가지로 sort_values()값을 기준으로 정렬하는 방법입니다. 값이 정렬되는 DataFrame의 열 이름을 사용하는 'by'인수를 허용합니다.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1')
print sorted_df이것의 output 다음과 같습니다-
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1col1 값이 정렬되고 각 col2 값과 행 인덱스가 col1과 함께 변경됩니다. 따라서 그들은 정렬되지 않은 것처럼 보입니다.
'by' 인수는 열 값 목록을받습니다.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by=['col1','col2'])
print sorted_df이것의 output 다음과 같습니다-
col1 col2
2 1 2
1 1 3
3 1 4
0 2 1정렬 알고리즘
sort_values()mergesort, heapsort 및 quicksort에서 알고리즘을 선택할 수있는 기능을 제공합니다. Mergesort는 유일한 안정적인 알고리즘입니다.
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')
print sorted_df이것의 output 다음과 같습니다-
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1이 장에서는 기본 시리즈 / 인덱스를 사용한 문자열 연산에 대해 설명합니다. 다음 장에서는 이러한 문자열 함수를 DataFrame에 적용하는 방법을 배웁니다.
Pandas는 문자열 데이터를 쉽게 조작 할 수 있도록 일련의 문자열 함수를 제공합니다. 가장 중요한 것은 이러한 함수가 누락 / NaN 값을 무시 (또는 제외)한다는 것입니다.
거의 모든이 메서드는 Python 문자열 함수와 함께 작동합니다 (참조 : https://docs.python.org/3/library/stdtypes.html#string-methods). 따라서 Series Object를 String Object로 변환 한 다음 작업을 수행합니다.
이제 각 작업이 어떻게 수행되는지 살펴 보겠습니다.
| Sr. 아니요 | 기능 및 설명 |
|---|---|
| 1 | lower() 시리즈 / 인덱스의 문자열을 소문자로 변환합니다. |
| 2 | upper() 시리즈 / 인덱스의 문자열을 대문자로 변환합니다. |
| 삼 | len() String length ()를 계산합니다. |
| 4 | strip() 양쪽에서 시리즈 / 인덱스의 각 문자열에서 공백 (줄 바꿈 포함)을 제거하는 데 도움이됩니다. |
| 5 | split(' ') 주어진 패턴으로 각 문자열을 분할합니다. |
| 6 | cat(sep=' ') 시리즈 / 인덱스 요소를 지정된 구분 기호로 연결합니다. |
| 7 | get_dummies() One-Hot Encoded 값이있는 DataFrame을 반환합니다. |
| 8 | contains(pattern) 하위 문자열이 요소에 포함되어 있으면 각 요소에 대해 부울 값 True를 반환하고 그렇지 않으면 False를 반환합니다. |
| 9 | replace(a,b) 값을 대체합니다. a 가치와 함께 b. |
| 10 | repeat(value) 지정된 횟수만큼 각 요소를 반복합니다. |
| 11 | count(pattern) 각 요소의 패턴 출현 횟수를 반환합니다. |
| 12 | startswith(pattern) 시리즈 / 인덱스의 요소가 패턴으로 시작하면 true를 반환합니다. |
| 13 | endswith(pattern) 시리즈 / 인덱스의 요소가 패턴으로 끝나면 true를 반환합니다. |
| 14 | find(pattern) 패턴이 처음 나타나는 첫 번째 위치를 반환합니다. |
| 15 | findall(pattern) 패턴의 모든 발생 목록을 반환합니다. |
| 16 | swapcase 케이스를 아래 / 위로 바꿉니다. |
| 17 | islower() 시리즈 / 인덱스의 각 문자열에있는 모든 문자가 소문자인지 여부를 확인합니다. 부울 반환 |
| 18 | isupper() 시리즈 / 인덱스의 각 문자열에있는 모든 문자가 대문자인지 여부를 확인합니다. 부울을 반환합니다. |
| 19 | isnumeric() 시리즈 / 인덱스의 각 문자열에있는 모든 문자가 숫자인지 확인합니다. 부울을 반환합니다. |
이제 시리즈를 생성하고 위의 모든 기능이 어떻게 작동하는지 살펴 보겠습니다.
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s이것의 output 다음과 같습니다-
0 Tom
1 William Rick
2 John
3 Alber@t
4 NaN
5 1234
6 Steve Smith
dtype: object보다 낮은()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.lower()이것의 output 다음과 같습니다-
0 tom
1 william rick
2 john
3 alber@t
4 NaN
5 1234
6 steve smith
dtype: object높은()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.upper()이것의 output 다음과 같습니다-
0 TOM
1 WILLIAM RICK
2 JOHN
3 ALBER@T
4 NaN
5 1234
6 STEVE SMITH
dtype: objectlen ()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.len()이것의 output 다음과 같습니다-
0 3.0
1 12.0
2 4.0
3 7.0
4 NaN
5 4.0
6 10.0
dtype: float64조각()
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After Stripping:")
print s.str.strip()이것의 output 다음과 같습니다-
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
After Stripping:
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object분할 (패턴)
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("Split Pattern:")
print s.str.split(' ')이것의 output 다음과 같습니다-
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
Split Pattern:
0 [Tom, , , , , , , , , , ]
1 [, , , , , William, Rick]
2 [John]
3 [Alber@t]
dtype: object고양이 (9 월 = 패턴)
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.cat(sep='_')이것의 output 다음과 같습니다-
Tom _ William Rick_John_Alber@tget_dummies ()
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.get_dummies()이것의 output 다음과 같습니다-
William Rick Alber@t John Tom
0 0 0 0 1
1 1 0 0 0
2 0 0 1 0
3 0 1 0 0포함 ()
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.contains(' ')이것의 output 다음과 같습니다-
0 True
1 True
2 False
3 False
dtype: bool대체 (a, b)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After replacing @ with $:") print s.str.replace('@','$')이것의 output 다음과 같습니다-
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
After replacing @ with $: 0 Tom 1 William Rick 2 John 3 Alber$t
dtype: object반복 (값)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.repeat(2)이것의 output 다음과 같습니다-
0 Tom Tom
1 William Rick William Rick
2 JohnJohn
3 Alber@tAlber@t
dtype: object개수 (패턴)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("The number of 'm's in each string:")
print s.str.count('m')이것의 output 다음과 같습니다-
The number of 'm's in each string:
0 1
1 1
2 0
3 0startswith (패턴)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that start with 'T':")
print s.str. startswith ('T')이것의 output 다음과 같습니다-
0 True
1 False
2 False
3 False
dtype: boolendswith (패턴)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that end with 't':")
print s.str.endswith('t')이것의 output 다음과 같습니다-
Strings that end with 't':
0 False
1 False
2 False
3 True
dtype: bool찾기 (패턴)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.find('e')이것의 output 다음과 같습니다-
0 -1
1 -1
2 -1
3 3
dtype: int64"-1"은 요소에 이러한 패턴이 없음을 나타냅니다.
findall (패턴)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.findall('e')이것의 output 다음과 같습니다-
0 []
1 []
2 []
3 [e]
dtype: objectNull 목록 ([])은 요소에서 사용할 수있는 패턴이 없음을 나타냅니다.
스왑 케이스 ()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.swapcase()이것의 output 다음과 같습니다-
0 tOM
1 wILLIAM rICK
2 jOHN
3 aLBER@T
dtype: objectislower ()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.islower()이것의 output 다음과 같습니다-
0 False
1 False
2 False
3 False
dtype: boolisupper ()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.isupper()이것의 output 다음과 같습니다-
0 False
1 False
2 False
3 False
dtype: boolisnumeric ()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.isnumeric()이것의 output 다음과 같습니다-
0 False
1 False
2 False
3 False
dtype: boolPandas는 동작의 일부 측면을 사용자 지정하는 API를 제공하며 디스플레이가 주로 사용됩니다.
API는 5 개의 관련 기능으로 구성됩니다. 그들은-
- get_option()
- set_option()
- reset_option()
- describe_option()
- option_context()
이제 함수가 어떻게 작동하는지 이해하겠습니다.
get_option (매개 변수)
get_option은 단일 매개 변수를 취하고 아래 출력에 주어진 값을 반환합니다.
display.max_rows
기본 값 수를 표시합니다. 인터프리터는이 값을 읽고이 값이있는 행을 표시 할 상한으로 표시합니다.
import pandas as pd
print pd.get_option("display.max_rows")이것의 output 다음과 같습니다-
60display.max_columns
기본 값 수를 표시합니다. 인터프리터는이 값을 읽고이 값이있는 행을 표시 할 상한으로 표시합니다.
import pandas as pd
print pd.get_option("display.max_columns")이것의 output 다음과 같습니다-
20여기서 60과 20은 기본 구성 매개 변수 값입니다.
set_option (매개 변수, 값)
set_option은 두 개의 인수를 취하고 다음과 같이 매개 변수에 값을 설정합니다.
display.max_rows
사용 set_option(), 표시 할 기본 행 수를 변경할 수 있습니다.
import pandas as pd
pd.set_option("display.max_rows",80)
print pd.get_option("display.max_rows")이것의 output 다음과 같습니다-
80display.max_columns
사용 set_option(), 표시 할 기본 행 수를 변경할 수 있습니다.
import pandas as pd
pd.set_option("display.max_columns",30)
print pd.get_option("display.max_columns")이것의 output 다음과 같습니다-
30reset_option (매개 변수)
reset_option 인수를 취하고 값을 기본값으로 다시 설정합니다.
display.max_rows
reset_option ()을 사용하여 값을 표시 할 기본 행 수로 다시 변경할 수 있습니다.
import pandas as pd
pd.reset_option("display.max_rows")
print pd.get_option("display.max_rows")이것의 output 다음과 같습니다-
60describe_option (매개 변수)
describe_option 인수에 대한 설명을 인쇄합니다.
display.max_rows
reset_option ()을 사용하여 값을 표시 할 기본 행 수로 다시 변경할 수 있습니다.
import pandas as pd
pd.describe_option("display.max_rows")이것의 output 다음과 같습니다-
display.max_rows : int
If max_rows is exceeded, switch to truncate view. Depending on
'large_repr', objects are either centrally truncated or printed as
a summary view. 'None' value means unlimited.
In case python/IPython is running in a terminal and `large_repr`
equals 'truncate' this can be set to 0 and pandas will auto-detect
the height of the terminal and print a truncated object which fits
the screen height. The IPython notebook, IPython qtconsole, or
IDLE do not run in a terminal and hence it is not possible to do
correct auto-detection.
[default: 60] [currently: 60]option_context ()
option_context 컨텍스트 관리자는 다음에서 옵션을 설정하는 데 사용됩니다. with statement일시적으로. 옵션 값은 종료 할 때 자동으로 복원됩니다.with block −
display.max_rows
option_context ()를 사용하여 값을 임시로 설정할 수 있습니다.
import pandas as pd
with pd.option_context("display.max_rows",10):
print(pd.get_option("display.max_rows"))
print(pd.get_option("display.max_rows"))이것의 output 다음과 같습니다-
10
10첫 번째와 두 번째 print 문의 차이점을 참조하십시오. 첫 번째 명령문은 다음에 의해 설정된 값을 인쇄합니다.option_context() 내에서 일시적인 with context그 자체. 후with context, 두 번째 print 문은 구성된 값을 인쇄합니다.
자주 사용되는 매개 변수
| Sr. 아니요 | 매개 변수 및 설명 |
|---|---|
| 1 | display.max_rows 표시 할 최대 행 수를 표시합니다. |
| 2 | 2 display.max_columns 표시 할 최대 열 수를 표시합니다. |
| 삼 | display.expand_frame_repr 페이지를 늘이기 위해 데이터 프레임을 표시합니다. |
| 4 | display.max_colwidth 최대 열 너비를 표시합니다. |
| 5 | display.precision 십진수의 정밀도를 표시합니다. |
이 장에서는 날짜를 슬라이스하고 주사위를 던지고 일반적으로 pandas 객체의 하위 집합을 가져 오는 방법에 대해 설명합니다.
Python 및 NumPy 인덱싱 연산자 "[]"및 속성 연산자 "." 광범위한 사용 사례에서 Pandas 데이터 구조에 빠르고 쉽게 액세스 할 수 있습니다. 그러나 접근 할 데이터의 유형을 미리 알 수 없기 때문에 표준 연산자를 직접 사용하면 최적화 한계가 있습니다. 프로덕션 코드의 경우이 장에서 설명하는 최적화 된 pandas 데이터 액세스 방법을 활용하는 것이 좋습니다.
Pandas는 이제 세 가지 유형의 다중 축 인덱싱을 지원합니다. 다음 표에는 세 가지 유형이 나와 있습니다.
| Sr. 아니요 | 인덱싱 및 설명 |
|---|---|
| 1 | .loc() 라벨 기반 |
| 2 | .iloc() 정수 기반 |
| 삼 | .ix() 레이블 및 정수 기반 |
.loc ()
Pandas는 순수하게 가질 수있는 다양한 방법을 제공합니다. label based indexing. 슬라이싱 할 때 시작 경계도 포함됩니다. 정수는 유효한 레이블이지만 위치가 아닌 레이블을 참조합니다.
.loc() 다음과 같은 여러 액세스 방법이 있습니다.
- 단일 스칼라 레이블
- 라벨 목록
- 슬라이스 객체
- 부울 배열
loc','로 구분 된 두 개의 단일 / 목록 / 범위 연산자를 사용합니다. 첫 번째는 행을 나타내고 두 번째는 열을 나타냅니다.
예 1
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
#select all rows for a specific column
print df.loc[:,'A']이것의 output 다음과 같습니다-
a 0.391548
b -0.070649
c -0.317212
d -2.162406
e 2.202797
f 0.613709
g 1.050559
h 1.122680
Name: A, dtype: float64예 2
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select all rows for multiple columns, say list[]
print df.loc[:,['A','C']]이것의 output 다음과 같습니다-
A C
a 0.391548 0.745623
b -0.070649 1.620406
c -0.317212 1.448365
d -2.162406 -0.873557
e 2.202797 0.528067
f 0.613709 0.286414
g 1.050559 0.216526
h 1.122680 -1.621420예제 3
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select few rows for multiple columns, say list[]
print df.loc[['a','b','f','h'],['A','C']]이것의 output 다음과 같습니다-
A C
a 0.391548 0.745623
b -0.070649 1.620406
f 0.613709 0.286414
h 1.122680 -1.621420예 4
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select range of rows for all columns
print df.loc['a':'h']이것의 output 다음과 같습니다-
A B C D
a 0.391548 -0.224297 0.745623 0.054301
b -0.070649 -0.880130 1.620406 1.419743
c -0.317212 -1.929698 1.448365 0.616899
d -2.162406 0.614256 -0.873557 1.093958
e 2.202797 -2.315915 0.528067 0.612482
f 0.613709 -0.157674 0.286414 -0.500517
g 1.050559 -2.272099 0.216526 0.928449
h 1.122680 0.324368 -1.621420 -0.741470예 5
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# for getting values with a boolean array
print df.loc['a']>0이것의 output 다음과 같습니다-
A False
B True
C False
D False
Name: a, dtype: bool.iloc ()
Pandas는 순수하게 정수 기반 인덱싱을 얻기 위해 다양한 방법을 제공합니다. python과 numpy처럼 이것들은0-based 인덱싱.
다양한 접근 방법은 다음과 같습니다.
- 정수
- 정수 목록
- 값의 범위
예 1
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# select all rows for a specific column
print df.iloc[:4]이것의 output 다음과 같습니다-
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251예 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Integer slicing
print df.iloc[:4]
print df.iloc[1:5, 2:4]이것의 output 다음과 같습니다-
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251
C D
1 -0.813012 0.631615
2 0.025070 0.230806
3 0.826977 -0.026251
4 1.423332 1.130568예제 3
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Slicing through list of values
print df.iloc[[1, 3, 5], [1, 3]]
print df.iloc[1:3, :]
print df.iloc[:,1:3]이것의 output 다음과 같습니다-
B D
1 0.890791 0.631615
3 -1.284314 -0.026251
5 -0.512888 -0.518930
A B C D
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
B C
0 0.256239 -1.270702
1 0.890791 -0.813012
2 -0.531378 0.025070
3 -1.284314 0.826977
4 -0.460729 1.423332
5 -0.512888 0.581409
6 -1.204853 0.098060
7 -0.947857 0.641358.ix ()
순수한 레이블 기반 및 정수 기반 외에도 Pandas는 .ix () 연산자를 사용하여 객체를 선택하고 부분 집합 화하는 하이브리드 방법을 제공합니다.
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Integer slicing
print df.ix[:4]이것의 output 다음과 같습니다-
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251예 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Index slicing
print df.ix[:,'A']이것의 output 다음과 같습니다-
0 0.699435
1 -0.685354
2 -0.783192
3 0.539042
4 -1.044209
5 -1.415411
6 1.062095
7 0.994204
Name: A, dtype: float64표기법 사용
다축 인덱싱으로 Pandas 객체에서 값을 가져 오는 것은 다음 표기법을 사용합니다.
| 목적 | 인덱서 | 반환 유형 |
|---|---|---|
| 시리즈 | s.loc [인덱서] | 스칼라 값 |
| DataFrame | df.loc [row_index, col_index] | 시리즈 객체 |
| 패널 | p.loc [항목 _ 색인, 주 _ 색인, 부 _ 색인] | p.loc [항목 _ 색인, 주 _ 색인, 부 _ 색인] |
Note − .iloc() & .ix() 동일한 인덱싱 옵션과 반환 값을 적용합니다.
이제 DataFrame 개체에서 각 작업을 수행하는 방법을 살펴 보겠습니다. 기본 인덱싱 연산자 '[]'를 사용합니다.
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df['A']이것의 output 다음과 같습니다-
0 -0.478893
1 0.391931
2 0.336825
3 -1.055102
4 -0.165218
5 -0.328641
6 0.567721
7 -0.759399
Name: A, dtype: float64Note − 값 목록을 []에 전달하여 해당 열을 선택할 수 있습니다.
예 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[['A','B']]이것의 output 다음과 같습니다-
A B
0 -0.478893 -0.606311
1 0.391931 -0.949025
2 0.336825 0.093717
3 -1.055102 -0.012944
4 -0.165218 1.550310
5 -0.328641 -0.226363
6 0.567721 -0.312585
7 -0.759399 -0.372696예제 3
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[2:2]이것의 output 다음과 같습니다-
Columns: [A, B, C, D]
Index: []속성 액세스
속성 연산자 '.'를 사용하여 열을 선택할 수 있습니다.
예
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df.A이것의 output 다음과 같습니다-
0 -0.478893
1 0.391931
2 0.336825
3 -1.055102
4 -0.165218
5 -0.328641
6 0.567721
7 -0.759399
Name: A, dtype: float64통계적 방법은 데이터의 동작을 이해하고 분석하는 데 도움이됩니다. 이제 Pandas 객체에 적용 할 수있는 몇 가지 통계 함수를 배웁니다.
Percent_change
시리즈, DatFrames 및 패널에는 모두 기능이 있습니다. pct_change(). 이 함수는 모든 요소를 이전 요소와 비교하고 변경 비율을 계산합니다.
import pandas as pd
import numpy as np
s = pd.Series([1,2,3,4,5,4])
print s.pct_change()
df = pd.DataFrame(np.random.randn(5, 2))
print df.pct_change()이것의 output 다음과 같습니다-
0 NaN
1 1.000000
2 0.500000
3 0.333333
4 0.250000
5 -0.200000
dtype: float64
0 1
0 NaN NaN
1 -15.151902 0.174730
2 -0.746374 -1.449088
3 -3.582229 -3.165836
4 15.601150 -1.860434기본적으로 pct_change()열에서 작동합니다. 동일한 행을 현명하게 적용하려면axis=1() 논의.
공분산
공분산은 계열 데이터에 적용됩니다. Series 객체에는 계열 객체 간의 공분산을 계산하는 cov 메서드가 있습니다. NA는 자동으로 제외됩니다.
Cov 시리즈
import pandas as pd
import numpy as np
s1 = pd.Series(np.random.randn(10))
s2 = pd.Series(np.random.randn(10))
print s1.cov(s2)이것의 output 다음과 같습니다-
-0.12978405324DataFrame에 적용될 때 공분산 방법은 다음을 계산합니다. cov 모든 열 사이.
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].cov(frame['b'])
print frame.cov()이것의 output 다음과 같습니다-
-0.58312921152741437
a b c d e
a 1.780628 -0.583129 -0.185575 0.003679 -0.136558
b -0.583129 1.297011 0.136530 -0.523719 0.251064
c -0.185575 0.136530 0.915227 -0.053881 -0.058926
d 0.003679 -0.523719 -0.053881 1.521426 -0.487694
e -0.136558 0.251064 -0.058926 -0.487694 0.960761Note − 관찰 cov 중에서 a 과 b 첫 번째 명령문의 열과 동일한 값이 DataFrame의 cov에서 반환 된 값입니다.
상관 관계
상관 관계는 두 값 배열 (계열) 간의 선형 관계를 보여줍니다. pearson (기본값), spearman 및 kendall과 같은 상관 관계를 계산하는 여러 방법이 있습니다.
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].corr(frame['b'])
print frame.corr()이것의 output 다음과 같습니다-
-0.383712785514
a b c d e
a 1.000000 -0.383713 -0.145368 0.002235 -0.104405
b -0.383713 1.000000 0.125311 -0.372821 0.224908
c -0.145368 0.125311 1.000000 -0.045661 -0.062840
d 0.002235 -0.372821 -0.045661 1.000000 -0.403380
e -0.104405 0.224908 -0.062840 -0.403380 1.000000DataFrame에 숫자가 아닌 열이 있으면 자동으로 제외됩니다.
데이터 랭킹
데이터 순위는 요소 배열의 각 요소에 대한 순위를 생성합니다. 동점 인 경우 평균 순위를 할당합니다.
import pandas as pd
import numpy as np
s = pd.Series(np.random.np.random.randn(5), index=list('abcde'))
s['d'] = s['b'] # so there's a tie
print s.rank()이것의 output 다음과 같습니다-
a 1.0
b 3.5
c 2.0
d 3.5
e 5.0
dtype: float64Rank는 기본적으로 true 인 오름차순 매개 변수를 선택적으로 취합니다. false이면 데이터의 순위가 반대로 지정되고 값이 클수록 더 작은 순위가 할당됩니다.
Rank는 method 매개 변수로 지정된 다른 타이 브레이킹 방법을 지원합니다.
average − 동점 그룹의 평균 순위
min − 그룹에서 가장 낮은 순위
max − 그룹에서 가장 높은 순위
first − 배열에 나타나는 순서대로 할당 된 순위
수치 데이터 작업을 위해 Pandas는 창 통계에 대해 롤링, 확장 및 지수 이동 가중치와 같은 몇 가지 변형을 제공합니다. 이들 중sum, mean, median, variance, covariance, correlation, 기타
이제 이들 각각을 DataFrame 개체에 적용하는 방법을 배웁니다.
.rolling () 함수
이 기능은 일련의 데이터에 적용 할 수 있습니다. 지정window=n 인수하고 그 위에 적절한 통계 함수를 적용하십시오.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.rolling(window=3).mean()이것의 output 다음과 같습니다-
A B C D
2000-01-01 NaN NaN NaN NaN
2000-01-02 NaN NaN NaN NaN
2000-01-03 0.434553 -0.667940 -1.051718 -0.826452
2000-01-04 0.628267 -0.047040 -0.287467 -0.161110
2000-01-05 0.398233 0.003517 0.099126 -0.405565
2000-01-06 0.641798 0.656184 -0.322728 0.428015
2000-01-07 0.188403 0.010913 -0.708645 0.160932
2000-01-08 0.188043 -0.253039 -0.818125 -0.108485
2000-01-09 0.682819 -0.606846 -0.178411 -0.404127
2000-01-10 0.688583 0.127786 0.513832 -1.067156Note − 창 크기가 3이기 때문에 처음 두 요소의 경우 null이 있고 세 번째 요소의 값은 n, n-1 과 n-2집단. 따라서 위에서 언급 한 다양한 기능을 적용 할 수도 있습니다.
.expanding () 함수
이 기능은 일련의 데이터에 적용 할 수 있습니다. 지정min_periods=n 인수하고 그 위에 적절한 통계 함수를 적용하십시오.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.expanding(min_periods=3).mean()이것의 output 다음과 같습니다-
A B C D
2000-01-01 NaN NaN NaN NaN
2000-01-02 NaN NaN NaN NaN
2000-01-03 0.434553 -0.667940 -1.051718 -0.826452
2000-01-04 0.743328 -0.198015 -0.852462 -0.262547
2000-01-05 0.614776 -0.205649 -0.583641 -0.303254
2000-01-06 0.538175 -0.005878 -0.687223 -0.199219
2000-01-07 0.505503 -0.108475 -0.790826 -0.081056
2000-01-08 0.454751 -0.223420 -0.671572 -0.230215
2000-01-09 0.586390 -0.206201 -0.517619 -0.267521
2000-01-10 0.560427 -0.037597 -0.399429 -0.376886.ewm () 함수
ewm일련의 데이터에 적용됩니다. com, span,halflife인수하고 그 위에 적절한 통계 함수를 적용하십시오. 가중치를 지수 적으로 할당합니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.ewm(com=0.5).mean()이것의 output 다음과 같습니다-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 0.865131 -0.453626 -1.137961 0.058747
2000-01-03 -0.132245 -0.807671 -0.308308 -1.491002
2000-01-04 1.084036 0.555444 -0.272119 0.480111
2000-01-05 0.425682 0.025511 0.239162 -0.153290
2000-01-06 0.245094 0.671373 -0.725025 0.163310
2000-01-07 0.288030 -0.259337 -1.183515 0.473191
2000-01-08 0.162317 -0.771884 -0.285564 -0.692001
2000-01-09 1.147156 -0.302900 0.380851 -0.607976
2000-01-10 0.600216 0.885614 0.569808 -1.110113창 함수는 곡선을 부드럽게하여 데이터 내에서 그래픽으로 추세를 찾는 데 주로 사용됩니다. 일상적인 데이터에 많은 변동이 있고 많은 데이터 포인트를 사용할 수있는 경우 샘플을 가져 와서 플로팅하는 것이 하나의 방법이며 창 계산을 적용하고 결과에 그래프를 그리는 것도 또 다른 방법입니다. 이러한 방법으로 곡선이나 추세를 부드럽게 할 수 있습니다.
롤링, 확장 및 ewm 개체가 생성되고 데이터에 대한 집계를 수행하는 데 여러 가지 방법을 사용할 수 있습니다.
DataFrame에 집계 적용
DataFrame을 만들고 여기에 집계를 적용 해 보겠습니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r이것의 output 다음과 같습니다-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 0.790670 -0.387854 -0.668132 0.267283
2000-01-03 -0.575523 -0.965025 0.060427 -2.179780
2000-01-04 1.669653 1.211759 -0.254695 1.429166
2000-01-05 0.100568 -0.236184 0.491646 -0.466081
2000-01-06 0.155172 0.992975 -1.205134 0.320958
2000-01-07 0.309468 -0.724053 -1.412446 0.627919
2000-01-08 0.099489 -1.028040 0.163206 -1.274331
2000-01-09 1.639500 -0.068443 0.714008 -0.565969
2000-01-10 0.326761 1.479841 0.664282 -1.361169
Rolling [window=3,min_periods=1,center=False,axis=0]함수를 전체 DataFrame에 전달하여 집계하거나 표준을 통해 열을 선택할 수 있습니다. get item 방법.
전체 데이터 프레임에 집계 적용
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate(np.sum)이것의 output 다음과 같습니다-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469데이터 프레임의 단일 열에 집계 적용
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate(np.sum)이것의 output 다음과 같습니다-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
2000-01-01 1.088512
2000-01-02 1.879182
2000-01-03 1.303660
2000-01-04 1.884801
2000-01-05 1.194699
2000-01-06 1.925393
2000-01-07 0.565208
2000-01-08 0.564129
2000-01-09 2.048458
2000-01-10 2.065750
Freq: D, Name: A, dtype: float64DataFrame의 여러 열에 집계 적용
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate(np.sum)이것의 output 다음과 같습니다-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B
2000-01-01 1.088512 -0.650942
2000-01-02 1.879182 -1.038796
2000-01-03 1.303660 -2.003821
2000-01-04 1.884801 -0.141119
2000-01-05 1.194699 0.010551
2000-01-06 1.925393 1.968551
2000-01-07 0.565208 0.032738
2000-01-08 0.564129 -0.759118
2000-01-09 2.048458 -1.820537
2000-01-10 2.065750 0.383357DataFrame의 단일 열에 여러 함수 적용
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate([np.sum,np.mean])이것의 output 다음과 같습니다-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
sum mean
2000-01-01 1.088512 1.088512
2000-01-02 1.879182 0.939591
2000-01-03 1.303660 0.434553
2000-01-04 1.884801 0.628267
2000-01-05 1.194699 0.398233
2000-01-06 1.925393 0.641798
2000-01-07 0.565208 0.188403
2000-01-08 0.564129 0.188043
2000-01-09 2.048458 0.682819
2000-01-10 2.065750 0.688583DataFrame의 여러 열에 여러 함수 적용
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate([np.sum,np.mean])이것의 output 다음과 같습니다-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B
sum mean sum mean
2000-01-01 1.088512 1.088512 -0.650942 -0.650942
2000-01-02 1.879182 0.939591 -1.038796 -0.519398
2000-01-03 1.303660 0.434553 -2.003821 -0.667940
2000-01-04 1.884801 0.628267 -0.141119 -0.047040
2000-01-05 1.194699 0.398233 0.010551 0.003517
2000-01-06 1.925393 0.641798 1.968551 0.656184
2000-01-07 0.565208 0.188403 0.032738 0.010913
2000-01-08 0.564129 0.188043 -0.759118 -0.253039
2000-01-09 2.048458 0.682819 -1.820537 -0.606846
2000-01-10 2.065750 0.688583 0.383357 0.127786데이터 프레임의 다른 열에 다른 함수 적용
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3, 4),
index = pd.date_range('1/1/2000', periods=3),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate({'A' : np.sum,'B' : np.mean})이것의 output 다음과 같습니다-
A B C D
2000-01-01 -1.575749 -1.018105 0.317797 0.545081
2000-01-02 -0.164917 -1.361068 0.258240 1.113091
2000-01-03 1.258111 1.037941 -0.047487 0.867371
A B
2000-01-01 -1.575749 -1.018105
2000-01-02 -1.740666 -1.189587
2000-01-03 -0.482555 -0.447078누락 된 데이터는 실제 시나리오에서 항상 문제입니다. 머신 러닝 및 데이터 마이닝과 같은 영역은 누락 된 값으로 인한 데이터 품질 저하로 인해 모델 예측의 정확성에 심각한 문제가 있습니다. 이러한 영역에서 결 측값 처리는 모델을보다 정확하고 유효하게 만들기위한 주요 초점입니다.
데이터가 누락 된시기와 이유
제품에 대한 온라인 설문 조사를 고려해 보겠습니다. 많은 경우 사람들은 그들과 관련된 모든 정보를 공유하지 않습니다. 경험을 공유하는 사람은 거의 없지만 제품을 얼마나 오래 사용하고 있는지는 알 수 없습니다. 제품 사용 기간과 경험을 공유하는 사람은 거의 없지만 연락처 정보는 공유하지 않습니다. 따라서 어떤 방식 으로든 데이터의 일부가 항상 누락되며 이는 실시간으로 매우 일반적입니다.
이제 Pandas를 사용하여 누락 된 값 (예 : NA 또는 NaN)을 처리하는 방법을 살펴 보겠습니다.
# import the pandas library
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df이것의 output 다음과 같습니다-
one two three
a 0.077988 0.476149 0.965836
b NaN NaN NaN
c -0.390208 -0.551605 -2.301950
d NaN NaN NaN
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g NaN NaN NaN
h 0.085100 0.532791 0.887415재 인덱싱을 사용하여 누락 된 값이있는 DataFrame을 만들었습니다. 출력에서NaN 방법 Not a Number.
결 측값 확인
누락 된 값을 더 쉽게 감지 할 수 있도록 (그리고 다른 배열 dtype에서) Pandas는 isnull() 과 notnull() 또한 Series 및 DataFrame 객체에 대한 메서드 인 함수-
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df['one'].isnull()이것의 output 다음과 같습니다-
a False
b True
c False
d True
e False
f False
g True
h False
Name: one, dtype: bool예 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df['one'].notnull()이것의 output 다음과 같습니다-
a True
b False
c True
d False
e True
f True
g False
h True
Name: one, dtype: bool누락 된 데이터로 계산
- 데이터를 합산 할 때 NA는 0으로 처리됩니다.
- 데이터가 모두 NA이면 결과는 NA가됩니다.
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df['one'].sum()이것의 output 다음과 같습니다-
2.02357685917예 2
import pandas as pd
import numpy as np
df = pd.DataFrame(index=[0,1,2,3,4,5],columns=['one','two'])
print df['one'].sum()이것의 output 다음과 같습니다-
nan누락 된 데이터 정리 / 채우기
Pandas는 누락 된 값을 정리하는 다양한 방법을 제공합니다. fillna 함수는 다음 섹션에서 설명하는 몇 가지 방법으로 Null이 아닌 데이터로 NA 값을 "채울"수 있습니다.
NaN을 스칼라 값으로 바꾸기
다음 프로그램은 "NaN"을 "0"으로 바꾸는 방법을 보여줍니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])
df = df.reindex(['a', 'b', 'c'])
print df
print ("NaN replaced with '0':")
print df.fillna(0)이것의 output 다음과 같습니다-
one two three
a -0.576991 -0.741695 0.553172
b NaN NaN NaN
c 0.744328 -1.735166 1.749580
NaN replaced with '0':
one two three
a -0.576991 -0.741695 0.553172
b 0.000000 0.000000 0.000000
c 0.744328 -1.735166 1.749580여기서 우리는 값 0으로 채우고 있습니다. 대신 다른 값으로 채울 수도 있습니다.
NA를 앞뒤로 채우기
리 인덱싱 장에서 논의 된 채우기 개념을 사용하여 누락 된 값을 채울 것입니다.
| Sr. 아니요 | 방법 및 조치 |
|---|---|
| 1 | pad/fill 채우기 방법 앞으로 |
| 2 | bfill/backfill 채우기 방법 뒤로 |
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.fillna(method='pad')이것의 output 다음과 같습니다-
one two three
a 0.077988 0.476149 0.965836
b 0.077988 0.476149 0.965836
c -0.390208 -0.551605 -2.301950
d -0.390208 -0.551605 -2.301950
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g -0.930230 -0.670473 1.146615
h 0.085100 0.532791 0.887415예 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.fillna(method='backfill')이것의 output 다음과 같습니다-
one two three
a 0.077988 0.476149 0.965836
b -0.390208 -0.551605 -2.301950
c -0.390208 -0.551605 -2.301950
d -2.000303 -0.788201 1.510072
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g 0.085100 0.532791 0.887415
h 0.085100 0.532791 0.887415결 측값 삭제
단순히 누락 된 값을 제외하려면 다음을 사용하십시오. dropna 기능과 함께 axis논의. 기본적으로 axis = 0, 즉 행을 따라, 즉 행 내의 값이 NA이면 전체 행이 제외됨을 의미합니다.
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna()이것의 output 다음과 같습니다-
one two three
a 0.077988 0.476149 0.965836
c -0.390208 -0.551605 -2.301950
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
h 0.085100 0.532791 0.887415예 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna(axis=1)이것의 output 다음과 같습니다-
Empty DataFrame
Columns: [ ]
Index: [a, b, c, d, e, f, g, h]누락 된 (또는) 일반 값 바꾸기
여러 번 일반적인 값을 특정 값으로 바꿔야합니다. replace 메서드를 적용하여이를 달성 할 수 있습니다.
NA를 스칼라 값으로 바꾸는 것은 fillna() 함수.
예 1
import pandas as pd
import numpy as np
df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})
print df.replace({1000:10,2000:60})이것의 output 다음과 같습니다-
one two
0 10 10
1 20 0
2 30 30
3 40 40
4 50 50
5 60 60예 2
import pandas as pd
import numpy as np
df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})
print df.replace({1000:10,2000:60})이것의 output 다음과 같습니다-
one two
0 10 10
1 20 0
2 30 30
3 40 40
4 50 50
5 60 60어떤 groupby작업에는 원본 개체에 대한 다음 작업 중 하나가 포함됩니다. 그들은-
Splitting 목적
Applying 기능
Combining 결과
많은 상황에서 데이터를 집합으로 분할하고 각 하위 집합에 일부 기능을 적용합니다. 적용 기능에서 다음 작업을 수행 할 수 있습니다.
Aggregation − 요약 통계 계산
Transformation − 그룹 별 작업 수행
Filtration − 일부 조건이있는 데이터 폐기
이제 DataFrame 객체를 생성하고 모든 작업을 수행해 보겠습니다.
#import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df이것의 output 다음과 같습니다-
Points Rank Team Year
0 876 1 Riders 2014
1 789 2 Riders 2015
2 863 2 Devils 2014
3 673 3 Devils 2015
4 741 3 Kings 2014
5 812 4 kings 2015
6 756 1 Kings 2016
7 788 1 Kings 2017
8 694 2 Riders 2016
9 701 4 Royals 2014
10 804 1 Royals 2015
11 690 2 Riders 2017데이터를 그룹으로 분할
Pandas 개체는 임의의 개체로 분할 할 수 있습니다. 다음과 같이 객체를 분할하는 방법에는 여러 가지가 있습니다.
- obj.groupby('key')
- obj.groupby(['key1','key2'])
- obj.groupby(key,axis=1)
이제 그룹화 개체를 DataFrame 개체에 적용하는 방법을 살펴 보겠습니다.
예
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team')이것의 output 다음과 같습니다-
<pandas.core.groupby.DataFrameGroupBy object at 0x7fa46a977e50>그룹보기
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team').groups이것의 output 다음과 같습니다-
{'Kings': Int64Index([4, 6, 7], dtype='int64'),
'Devils': Int64Index([2, 3], dtype='int64'),
'Riders': Int64Index([0, 1, 8, 11], dtype='int64'),
'Royals': Int64Index([9, 10], dtype='int64'),
'kings' : Int64Index([5], dtype='int64')}예
Group by 여러 열-
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby(['Team','Year']).groups이것의 output 다음과 같습니다-
{('Kings', 2014): Int64Index([4], dtype='int64'),
('Royals', 2014): Int64Index([9], dtype='int64'),
('Riders', 2014): Int64Index([0], dtype='int64'),
('Riders', 2015): Int64Index([1], dtype='int64'),
('Kings', 2016): Int64Index([6], dtype='int64'),
('Riders', 2016): Int64Index([8], dtype='int64'),
('Riders', 2017): Int64Index([11], dtype='int64'),
('Devils', 2014): Int64Index([2], dtype='int64'),
('Devils', 2015): Int64Index([3], dtype='int64'),
('kings', 2015): Int64Index([5], dtype='int64'),
('Royals', 2015): Int64Index([10], dtype='int64'),
('Kings', 2017): Int64Index([7], dtype='int64')}그룹을 통해 반복
와 더불어 groupby 개체를 손에 들고 itertools.obj와 유사한 개체를 반복 할 수 있습니다.
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
for name,group in grouped:
print name
print group이것의 output 다음과 같습니다-
2014
Points Rank Team Year
0 876 1 Riders 2014
2 863 2 Devils 2014
4 741 3 Kings 2014
9 701 4 Royals 2014
2015
Points Rank Team Year
1 789 2 Riders 2015
3 673 3 Devils 2015
5 812 4 kings 2015
10 804 1 Royals 2015
2016
Points Rank Team Year
6 756 1 Kings 2016
8 694 2 Riders 2016
2017
Points Rank Team Year
7 788 1 Kings 2017
11 690 2 Riders 2017기본적으로 groupby 개체에는 그룹 이름과 동일한 레이블 이름이 있습니다.
그룹 선택
사용 get_group() 방법으로 단일 그룹을 선택할 수 있습니다.
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
print grouped.get_group(2014)이것의 output 다음과 같습니다-
Points Rank Team Year
0 876 1 Riders 2014
2 863 2 Devils 2014
4 741 3 Kings 2014
9 701 4 Royals 2014집계
집계 함수는 각 그룹에 대해 단일 집계 값을 반환합니다. 일단group by 개체가 생성되면 그룹화 된 데이터에 대해 여러 집계 작업을 수행 할 수 있습니다.
명백한 것은 집계 또는 동등한 것을 통한 집계입니다. agg 방법-
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
print grouped['Points'].agg(np.mean)이것의 output 다음과 같습니다-
Year
2014 795.25
2015 769.50
2016 725.00
2017 739.00
Name: Points, dtype: float64각 그룹의 크기를 확인하는 또 다른 방법은 size () 함수를 적용하는 것입니다.
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
Attribute Access in Python Pandas
grouped = df.groupby('Team')
print grouped.agg(np.size)이것의 output 다음과 같습니다-
Points Rank Year
Team
Devils 2 2 2
Kings 3 3 3
Riders 4 4 4
Royals 2 2 2
kings 1 1 1한 번에 여러 집계 함수 적용
그룹화 된 시리즈를 사용하면 list 또는 dict of functions 집계를 수행하고 DataFrame을 출력으로 생성-
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Team')
print grouped['Points'].agg([np.sum, np.mean, np.std])이것의 output 다음과 같습니다-
Team sum mean std
Devils 1536 768.000000 134.350288
Kings 2285 761.666667 24.006943
Riders 3049 762.250000 88.567771
Royals 1505 752.500000 72.831998
kings 812 812.000000 NaN변형
그룹 또는 열에 대한 변환은 그룹화되는 것과 동일한 크기로 인덱싱 된 개체를 반환합니다. 따라서 변환은 그룹 청크와 동일한 크기의 결과를 반환해야합니다.
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print grouped.transform(score)이것의 output 다음과 같습니다-
Points Rank Year
0 12.843272 -15.000000 -11.618950
1 3.020286 5.000000 -3.872983
2 7.071068 -7.071068 -7.071068
3 -7.071068 7.071068 7.071068
4 -8.608621 11.547005 -10.910895
5 NaN NaN NaN
6 -2.360428 -5.773503 2.182179
7 10.969049 -5.773503 8.728716
8 -7.705963 5.000000 3.872983
9 -7.071068 7.071068 -7.071068
10 7.071068 -7.071068 7.071068
11 -8.157595 5.000000 11.618950여과법
필터링은 정의 된 기준에 따라 데이터를 필터링하고 데이터 하위 집합을 반환합니다. 그만큼filter() 함수는 데이터를 필터링하는 데 사용됩니다.
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team').filter(lambda x: len(x) >= 3)이것의 output 다음과 같습니다-
Points Rank Team Year
0 876 1 Riders 2014
1 789 2 Riders 2015
4 741 3 Kings 2014
6 756 1 Kings 2016
7 788 1 Kings 2017
8 694 2 Riders 2016
11 690 2 Riders 2017위의 필터 조건에서 IPL에 3 회 이상 참여한 팀의 반환을 요청합니다.
Pandas는 SQL과 같은 관계형 데이터베이스와 관용적으로 매우 유사한 모든 기능을 갖춘 고성능 메모리 내 조인 작업을 제공합니다.
Pandas는 단일 기능을 제공합니다. merge, DataFrame 객체 사이의 모든 표준 데이터베이스 조인 작업의 진입 점으로-
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)여기에서는 다음 매개 변수를 사용했습니다.
left − DataFrame 객체.
right − 다른 DataFrame 객체.
on− 결합 할 열 (이름). 왼쪽 및 오른쪽 DataFrame 개체 모두에서 발견되어야합니다.
left_on− 키로 사용할 왼쪽 DataFrame의 열. 길이가 DataFrame의 길이와 같은 열 이름 또는 배열 일 수 있습니다.
right_on− 키로 사용할 오른쪽 DataFrame의 열. 길이가 DataFrame의 길이와 같은 열 이름 또는 배열 일 수 있습니다.
left_index − 만약 True,왼쪽 DataFrame의 인덱스 (행 레이블)를 조인 키로 사용합니다. MultiIndex (계층 구조)가있는 DataFrame의 경우 수준 수가 오른쪽 DataFrame의 조인 키 수와 일치해야합니다.
right_index − 동일한 사용법 left_index 올바른 DataFrame을 위해.
how− 'left', 'right', 'outer', 'inner'중 하나. 기본값은 내부입니다. 각 방법은 아래에 설명되어 있습니다.
sort− 사전 순으로 결합 키로 결과 DataFrame을 정렬합니다. 기본값은 True이고 False로 설정하면 대부분의 경우 성능이 크게 향상됩니다.
이제 두 개의 다른 DataFrame을 만들고 병합 작업을 수행하겠습니다.
# import the pandas library
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame(
{'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print left
print right이것의 output 다음과 같습니다-
Name id subject_id
0 Alex 1 sub1
1 Amy 2 sub2
2 Allen 3 sub4
3 Alice 4 sub6
4 Ayoung 5 sub5
Name id subject_id
0 Billy 1 sub2
1 Brian 2 sub4
2 Bran 3 sub3
3 Bryce 4 sub6
4 Betty 5 sub5키에 두 개의 DataFrame 병합
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on='id')이것의 output 다음과 같습니다-
Name_x id subject_id_x Name_y subject_id_y
0 Alex 1 sub1 Billy sub2
1 Amy 2 sub2 Brian sub4
2 Allen 3 sub4 Bran sub3
3 Alice 4 sub6 Bryce sub6
4 Ayoung 5 sub5 Betty sub5여러 키의 두 DataFrame 병합
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on=['id','subject_id'])이것의 output 다음과 같습니다-
Name_x id subject_id Name_y
0 Alice 4 sub6 Bryce
1 Ayoung 5 sub5 Betty'how'인수를 사용하여 병합
그만큼 how병합 할 인수는 결과 테이블에 포함 할 키를 결정하는 방법을 지정합니다. 키 조합이 왼쪽 또는 오른쪽 테이블에 나타나지 않으면 조인 된 테이블의 값은 NA가됩니다.
다음은 how 옵션 및 해당 SQL 등가 이름-
| 병합 방법 | 동등한 SQL | 기술 |
|---|---|---|
| 왼쪽 | 왼쪽 외부 조인 | 왼쪽 개체의 키 사용 |
| 권리 | 오른쪽 외부 조인 | 오른쪽 개체의 키 사용 |
| 밖의 | 전체 외부 조인 | 키 통합 사용 |
| 안의 | 내부 조인 | 키 교차 사용 |
왼쪽 조인
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='left')이것의 output 다음과 같습니다-
Name_x id_x subject_id Name_y id_y
0 Alex 1 sub1 NaN NaN
1 Amy 2 sub2 Billy 1.0
2 Allen 3 sub4 Brian 2.0
3 Alice 4 sub6 Bryce 4.0
4 Ayoung 5 sub5 Betty 5.0오른쪽 조인
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='right')이것의 output 다음과 같습니다-
Name_x id_x subject_id Name_y id_y
0 Amy 2.0 sub2 Billy 1
1 Allen 3.0 sub4 Brian 2
2 Alice 4.0 sub6 Bryce 4
3 Ayoung 5.0 sub5 Betty 5
4 NaN NaN sub3 Bran 3외부 결합
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, how='outer', on='subject_id')이것의 output 다음과 같습니다-
Name_x id_x subject_id Name_y id_y
0 Alex 1.0 sub1 NaN NaN
1 Amy 2.0 sub2 Billy 1.0
2 Allen 3.0 sub4 Brian 2.0
3 Alice 4.0 sub6 Bryce 4.0
4 Ayoung 5.0 sub5 Betty 5.0
5 NaN NaN sub3 Bran 3.0내부 조인
인덱스에서 조인이 수행됩니다. 조인 작업은 호출 된 개체를 따릅니다. 그래서,a.join(b) 같지 않다 b.join(a).
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='inner')이것의 output 다음과 같습니다-
Name_x id_x subject_id Name_y id_y
0 Amy 2 sub2 Billy 1
1 Allen 3 sub4 Brian 2
2 Alice 4 sub6 Bryce 4
3 Ayoung 5 sub5 Betty 5Pandas는 쉽게 결합 할 수있는 다양한 기능을 제공합니다. Series, DataFrame, 및 Panel 사물.
pd.concat(objs,axis=0,join='outer',join_axes=None,
ignore_index=False)objs − 이것은 Series, DataFrame 또는 Panel 개체의 시퀀스 또는 매핑입니다.
axis − {0, 1, ...}, 기본값 0. 함께 연결할 축입니다.
join− { 'inner', 'outer'}, 기본 'outer'. 다른 축에서 인덱스를 처리하는 방법. 결합은 외부, 교차는 내부입니다.
ignore_index− 부울, 기본값은 False. True이면 연결 축에서 인덱스 값을 사용하지 마십시오. 결과 축은 0, ..., n-1로 레이블이 지정됩니다.
join_axes− Index 개체의 목록입니다. 내부 / 외부 집합 논리를 수행하는 대신 다른 (n-1) 축에 사용할 특정 인덱스입니다.
개체 연결
그만큼 concat함수는 축을 따라 연결 작업을 수행하는 모든 무거운 작업을 수행합니다. 다른 객체를 만들고 연결해 보겠습니다.
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two])이것의 output 다음과 같습니다-
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5잘게 잘린 DataFrame의 각 조각과 특정 키를 연결하려고한다고 가정합니다. 우리는keys 인수-
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'])이것의 output 다음과 같습니다-
x 1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
y 1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5결과의 색인이 중복됩니다. 각 인덱스가 반복됩니다.
결과 객체가 자체 인덱싱을 따라야하는 경우 ignore_index ...에 True.
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'],ignore_index=True)이것의 output 다음과 같습니다-
Marks_scored Name subject_id
0 98 Alex sub1
1 90 Amy sub2
2 87 Allen sub4
3 69 Alice sub6
4 78 Ayoung sub5
5 89 Billy sub2
6 80 Brian sub4
7 79 Bran sub3
8 97 Bryce sub6
9 88 Betty sub5색인이 완전히 변경되고 키도 재정의됩니다.
두 개체를 함께 추가해야하는 경우 axis=1, 그러면 새 열이 추가됩니다.
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],axis=1)이것의 output 다음과 같습니다-
Marks_scored Name subject_id Marks_scored Name subject_id
1 98 Alex sub1 89 Billy sub2
2 90 Amy sub2 80 Brian sub4
3 87 Allen sub4 79 Bran sub3
4 69 Alice sub6 97 Bryce sub6
5 78 Ayoung sub5 88 Betty sub5추가를 사용하여 연결
연결에 대한 유용한 바로 가기는 Series 및 DataFrame의 append 인스턴스 메서드입니다. 이 메서드는 실제로 concat보다 선행되었습니다. 그들은 함께 연결axis=0, 즉 인덱스-
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print one.append(two)이것의 output 다음과 같습니다-
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5그만큼 append 함수도 여러 객체를 취할 수 있습니다.
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print one.append([two,one,two])이것의 output 다음과 같습니다-
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5시계열
Pandas는 특히 금융 부문에서 시계열 데이터로 작업 시간을위한 강력한 도구를 제공합니다. 시계열 데이터로 작업하는 동안 우리는 자주 다음을 발견합니다.
- 시간 순서 생성
- 시계열을 다른 주파수로 변환
Pandas는 위 작업을 수행하기 위해 비교적 간결하고 독립적 인 도구 세트를 제공합니다.
현재 시간 얻기
datetime.now() 현재 날짜와 시간을 제공합니다.
import pandas as pd
print pd.datetime.now()이것의 output 다음과 같습니다-
2017-05-11 06:10:13.393147타임 스탬프 생성
타임 스탬프가있는 데이터는 값을 특정 시점과 연결하는 가장 기본적인 유형의 시계열 데이터입니다. pandas 객체의 경우 시점을 사용하는 것을 의미합니다. 예를 들어 보겠습니다.
import pandas as pd
print pd.Timestamp('2017-03-01')이것의 output 다음과 같습니다-
2017-03-01 00:00:00정수 또는 부동 epoch 시간을 변환 할 수도 있습니다. 기본 단위는 나노초입니다 (타임 스탬프가 저장되는 방식이므로). 그러나 종종 epoch는 지정할 수있는 다른 단위에 저장됩니다. 다른 예를 들어 봅시다
import pandas as pd
print pd.Timestamp(1587687255,unit='s')이것의 output 다음과 같습니다-
2020-04-24 00:14:15시간 범위 만들기
import pandas as pd
print pd.date_range("11:00", "13:30", freq="30min").time이것의 output 다음과 같습니다-
[datetime.time(11, 0) datetime.time(11, 30) datetime.time(12, 0)
datetime.time(12, 30) datetime.time(13, 0) datetime.time(13, 30)]시간의 빈도 변경
import pandas as pd
print pd.date_range("11:00", "13:30", freq="H").time이것의 output 다음과 같습니다-
[datetime.time(11, 0) datetime.time(12, 0) datetime.time(13, 0)]타임 스탬프로 변환
시리즈 또는 날짜와 같은 객체의 목록과 같은 객체 (예 : 문자열, 에포크 또는 혼합)를 변환하려면 다음을 사용할 수 있습니다. to_datetime함수. 전달되면 시리즈 (인덱스가 동일 함)가 반환되고list-like 로 변환됩니다 DatetimeIndex. 다음 예를 살펴보십시오-
import pandas as pd
print pd.to_datetime(pd.Series(['Jul 31, 2009','2010-01-10', None]))이것의 output 다음과 같습니다-
0 2009-07-31
1 2010-01-10
2 NaT
dtype: datetime64[ns]NaT 방법 Not a Time (NaN과 동일)
다른 예를 들어 보겠습니다.
import pandas as pd
print pd.to_datetime(['2005/11/23', '2010.12.31', None])이것의 output 다음과 같습니다-
DatetimeIndex(['2005-11-23', '2010-12-31', 'NaT'], dtype='datetime64[ns]', freq=None)시계열을 확장하면 날짜 기능이 재무 데이터 분석에서 중요한 역할을합니다. 날짜 데이터로 작업하는 동안 우리는 자주 다음을 보게 될 것입니다.
- 날짜 순서 생성
- 날짜 시리즈를 다른 빈도로 변환
날짜 범위 만들기
사용 date.range()기간과 빈도를 지정하여 함수를 사용하면 날짜 시리즈를 만들 수 있습니다. 기본적으로 범위 빈도는 일입니다.
import pandas as pd
print pd.date_range('1/1/2011', periods=5)이것의 output 다음과 같습니다-
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')날짜 빈도 변경
import pandas as pd
print pd.date_range('1/1/2011', periods=5,freq='M')이것의 output 다음과 같습니다-
DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31', '2011-04-30', '2011-05-31'],
dtype='datetime64[ns]', freq='M')bdate_range
bdate_range ()는 비즈니스 날짜 범위를 나타냅니다. date_range ()와 달리 토요일과 일요일을 제외합니다.
import pandas as pd
print pd.date_range('1/1/2011', periods=5)이것의 output 다음과 같습니다-
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')3 월 3 일 이후에는 날짜가 4 일과 5 일을 제외하고 3 월 6 일로 점프합니다. 달력에서 요일을 확인하십시오.
다음과 같은 편의 기능 date_range 과 bdate_range다양한 주파수 별칭을 활용합니다. date_range의 기본 빈도는 달력 일이고 bdate_range의 기본값은 영업일입니다.
import pandas as pd
start = pd.datetime(2011, 1, 1)
end = pd.datetime(2011, 1, 5)
print pd.date_range(start, end)이것의 output 다음과 같습니다-
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')오프셋 별칭
유용한 공통 시계열 주파수에 여러 문자열 별칭이 제공됩니다. 이러한 별칭을 오프셋 별칭이라고합니다.
| 별명 | 기술 | 별명 | 기술 |
|---|---|---|---|
| 비 | 영업일 빈도 | BQS | 비즈니스 분기 시작 빈도 |
| 디 | 역일 빈도 | ㅏ | 연간 (연도) 종료 빈도 |
| W | 주간 빈도 | BA | 비즈니스 연말 빈도 |
| 미디엄 | 월말 빈도 | BAS | 사업 연도 시작 빈도 |
| SM | 반달 종료 빈도 | BH | 업무 시간 빈도 |
| BM | 영업 월 종료 빈도 | H | 시간당 빈도 |
| MS | 월 시작 빈도 | T, 분 | 미세한 빈도 |
| SMS | SMS 반월 시작 빈도 | 에스 | 두 번째 빈도 |
| BMS | 영업 월 시작 빈도 | L, ms | 밀리 초 |
| 큐 | 분기 종료 빈도 | U, 우리 | 마이크로 초 |
| BQ | 비즈니스 분기 종료 빈도 | 엔 | 나노초 |
| QS | 분기 시작 빈도 |
타임 델타는 일, 시간, 분, 초와 같은 차이 단위로 표현되는 시간 차이입니다. 그들은 긍정적일 수도 있고 부정적 일 수도 있습니다.
아래와 같이 다양한 인수를 사용하여 Timedelta 객체를 만들 수 있습니다.
끈
문자열 리터럴을 전달하여 timedelta 객체를 만들 수 있습니다.
import pandas as pd
print pd.Timedelta('2 days 2 hours 15 minutes 30 seconds')이것의 output 다음과 같습니다-
2 days 02:15:30정수
단위와 함께 정수 값을 전달하면 인수가 Timedelta 객체를 만듭니다.
import pandas as pd
print pd.Timedelta(6,unit='h')이것의 output 다음과 같습니다-
0 days 06:00:00데이터 오프셋
주, 일, 시간, 분, 초, 밀리 초, 마이크로 초, 나노초와 같은 데이터 오프셋도 구성에 사용할 수 있습니다.
import pandas as pd
print pd.Timedelta(days=2)이것의 output 다음과 같습니다-
2 days 00:00:00to_timedelta ()
최상위 수준 사용 pd.to_timedelta, 인식 된 timedelta 형식 / 값의 스칼라, 배열, 목록 또는 계열을 Timedelta 유형으로 변환 할 수 있습니다. 입력이 Series이면 Series를 생성하고 입력이 스칼라와 유사하면 스칼라를 생성하고 그렇지 않으면TimedeltaIndex.
import pandas as pd
print pd.Timedelta(days=2)이것의 output 다음과 같습니다-
2 days 00:00:00운영
Series / DataFrames에서 작동하고 timedelta64[ns] 빼기 연산을 통한 시리즈 datetime64[ns] 시리즈 또는 타임 스탬프.
이제 Timedelta 및 datetime 객체로 DataFrame을 만들고 이에 대한 산술 연산을 수행해 보겠습니다.
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
print df이것의 output 다음과 같습니다-
A B
0 2012-01-01 0 days
1 2012-01-02 1 days
2 2012-01-03 2 days추가 작업
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
print df이것의 output 다음과 같습니다-
A B C
0 2012-01-01 0 days 2012-01-01
1 2012-01-02 1 days 2012-01-03
2 2012-01-03 2 days 2012-01-05빼기 연산
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
df['D']=df['C']+df['B']
print df이것의 output 다음과 같습니다-
A B C D
0 2012-01-01 0 days 2012-01-01 2012-01-01
1 2012-01-02 1 days 2012-01-03 2012-01-04
2 2012-01-03 2 days 2012-01-05 2012-01-07종종 실시간으로 데이터에는 반복적 인 텍스트 열이 포함됩니다. 성별, 국가 및 코드와 같은 기능은 항상 반복적입니다. 다음은 범주 형 데이터의 예입니다.
범주 형 변수는 제한적이고 일반적으로 고정 된 수의 가능한 값만 가질 수 있습니다. 고정 길이 외에 범주 형 데이터에는 순서가있을 수 있지만 숫자 연산을 수행 할 수 없습니다. 범주 형은 Pandas 데이터 유형입니다.
범주 형 데이터 유형은 다음과 같은 경우에 유용합니다.
몇 가지 다른 값으로 만 구성된 문자열 변수입니다. 이러한 문자열 변수를 범주 형 변수로 변환하면 메모리가 절약됩니다.
변수의 어휘 순서는 논리 순서 ( "1", "2", "3")와 동일하지 않습니다. 범주 형으로 변환하고 범주에 순서를 지정하면 정렬 및 최소 / 최대는 어휘 순서 대신 논리적 순서를 사용합니다.
다른 Python 라이브러리에 대한 신호로서이 열이 범주 형 변수로 처리되어야한다는 신호입니다 (예 : 적절한 통계 방법 또는 플롯 유형 사용).
개체 생성
범주 형 개체는 여러 방법으로 만들 수 있습니다. 다른 방법은 아래에 설명되어 있습니다.
범주
pandas 객체 생성에서 dtype을 "category"로 지정합니다.
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
print s이것의 output 다음과 같습니다-
0 a
1 b
2 c
3 a
dtype: category
Categories (3, object): [a, b, c]시리즈 객체에 전달되는 요소의 수는 4 개이지만 범주는 3 개에 불과합니다. 출력 카테고리에서 동일하게 관찰하십시오.
pd. 범주
표준 Pandas Categorical 생성자를 사용하여 범주 객체를 만들 수 있습니다.
pandas.Categorical(values, categories, ordered)예를 들어 보겠습니다.
import pandas as pd
cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat이것의 output 다음과 같습니다-
[a, b, c, a, b, c]
Categories (3, object): [a, b, c]다른 예를 들어 보겠습니다.
import pandas as pd
cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print cat이것의 output 다음과 같습니다-
[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]여기서 두 번째 인수는 범주를 나타냅니다. 따라서 카테고리에없는 값은 다음과 같이 처리됩니다.NaN.
이제 다음 예를 살펴보십시오.
import pandas as pd
cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat이것의 output 다음과 같습니다-
[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]논리적으로 순서는 다음을 의미합니다. a 보다 큼 b 과 b 보다 큼 c.
기술
사용 .describe() 범주 형 데이터에 대한 명령을 실행하면 Series 또는 DataFrame 의 type 끈.
import pandas as pd
import numpy as np
cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})
print df.describe()
print df["cat"].describe()이것의 output 다음과 같습니다-
cat s
count 3 3
unique 2 2
top c c
freq 2 2
count 3
unique 2
top c
freq 2
Name: cat, dtype: object카테고리 속성 가져 오기
obj.cat.categories 명령을 사용하여 categories of the object.
import pandas as pd
import numpy as np
s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print s.categories이것의 output 다음과 같습니다-
Index([u'b', u'a', u'c'], dtype='object')obj.ordered 명령은 개체의 순서를 가져 오는 데 사용됩니다.
import pandas as pd
import numpy as np
cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print cat.ordered이것의 output 다음과 같습니다-
False반환 된 함수 false 주문을 지정하지 않았기 때문입니다.
카테고리 이름 바꾸기
범주 이름 변경은 새 값을 series.cat.categoriesseries.cat.categories 속성.
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
s.cat.categories = ["Group %s" % g for g in s.cat.categories]
print s.cat.categories이것의 output 다음과 같습니다-
Index([u'Group a', u'Group b', u'Group c'], dtype='object')초기 카테고리 [a,b,c] 에 의해 업데이트됩니다 s.cat.categories 개체의 속성.
새 카테고리 추가
Categorical.add.categories () 메서드를 사용하여 새 범주를 추가 할 수 있습니다.
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
s = s.cat.add_categories([4])
print s.cat.categories이것의 output 다음과 같습니다-
Index([u'a', u'b', u'c', 4], dtype='object')카테고리 제거
사용 Categorical.remove_categories() 방법, 원하지 않는 범주를 제거 할 수 있습니다.
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
print ("Original object:")
print s
print ("After removal:")
print s.cat.remove_categories("a")이것의 output 다음과 같습니다-
Original object:
0 a
1 b
2 c
3 a
dtype: category
Categories (3, object): [a, b, c]
After removal:
0 NaN
1 b
2 c
3 NaN
dtype: category
Categories (2, object): [b, c]범주 형 데이터 비교
범주 형 데이터를 다른 개체와 비교하는 것은 세 가지 경우에 가능합니다.
범주 형 데이터와 길이가 같은 목록 형 객체 (목록, 시리즈, 배열, ...)와 같음 (== 및! =)을 비교합니다.
범주 형 데이터의 모든 비교 (==,! =,>,> =, <및 <=)는 ordered == True이고 범주가 동일한 경우 다른 범주 형 계열에 대한 데이터입니다.
스칼라에 대한 범주 형 데이터의 모든 비교.
다음 예를 살펴보십시오-
import pandas as pd
cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)
print cat>cat1이것의 output 다음과 같습니다-
0 False
1 False
2 True
dtype: bool기본 플로팅 : 플롯
Series 및 DataFrame의이 기능은 matplotlib libraries plot() 방법.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10,4),index=pd.date_range('1/1/2000',
periods=10), columns=list('ABCD'))
df.plot()이것의 output 다음과 같습니다-
인덱스가 날짜로 구성된 경우 다음을 호출합니다. gct().autofmt_xdate() 위의 그림과 같이 x 축 형식을 지정합니다.
다음을 사용하여 한 열 대 다른 열을 그릴 수 있습니다. x 과 y 키워드.
플로팅 방법을 사용하면 기본 선 플롯 이외의 몇 가지 플롯 스타일을 사용할 수 있습니다. 이러한 메소드는에 대한 kind 키워드 인수로 제공 될 수 있습니다.plot(). 여기에는-
- 막대 그래프의 경우 bar 또는 barh
- 히스토그램에 대한 히스 토
- boxplot 상자
- 면적 플롯의 경우 'area'
- 산점도의 경우 'scatter'
바 플롯
이제 Bar Plot을 만들어 보겠습니다. 막대 그래프는 다음과 같은 방법으로 만들 수 있습니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()이것의 output 다음과 같습니다-
누적 막대 그림을 생성하려면 pass stacked=True −
import pandas as pd
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar(stacked=True)이것의 output 다음과 같습니다-
수평 막대 그래프를 얻으려면 barh 방법-
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.barh(stacked=True)이것의 output 다음과 같습니다-
히스토그램
히스토그램은 plot.hist()방법. 빈 수를 지정할 수 있습니다.
import pandas as pd
import numpy as np
df = pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])
df.plot.hist(bins=20)이것의 output 다음과 같습니다-
각 열에 대해 다른 히스토그램을 그리려면 다음 코드를 사용하십시오.
import pandas as pd
import numpy as np
df=pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])
df.diff.hist(bins=20)이것의 output 다음과 같습니다-
상자 도표
상자 그림을 그릴 수 있습니다. Series.box.plot() 과 DataFrame.box.plot(), 또는 DataFrame.boxplot() 각 열 내의 값 분포를 시각화합니다.
예를 들어, 다음은 [0,1)에 대한 균일 랜덤 변수의 10 개 관측에 대한 5 번의 시행을 나타내는 상자 그림입니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
df.plot.box()이것의 output 다음과 같습니다-
면적 플롯
면적 플롯은 Series.plot.area() 아니면 그 DataFrame.plot.area() 행동 양식.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()이것의 output 다음과 같습니다-
산포도
산점도는 DataFrame.plot.scatter() 행동 양식.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(50, 4), columns=['a', 'b', 'c', 'd'])
df.plot.scatter(x='a', y='b')이것의 output 다음과 같습니다-
파이 차트
원형 차트는 DataFrame.plot.pie() 방법.
import pandas as pd
import numpy as np
df = pd.DataFrame(3 * np.random.rand(4), index=['a', 'b', 'c', 'd'], columns=['x'])
df.plot.pie(subplots=True)이것의 output 다음과 같습니다-
그만큼 Pandas I/O API 다음과 같이 액세스되는 최상위 수준 리더 기능 집합입니다. pd.read_csv() 일반적으로 Pandas 객체를 반환합니다.
텍스트 파일 (또는 플랫 파일)을 읽기위한 두 가지 주요 기능은 다음과 같습니다. read_csv() 과 read_table(). 둘 다 동일한 구문 분석 코드를 사용하여 표 형식 데이터를 지능적으로DataFrame 객체-
pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=Nonepandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None방법은 다음과 같습니다. csv 파일 데이터는 다음과 같습니다.
S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900이 데이터를 다른 이름으로 저장 temp.csv 작업을 수행합니다.
S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900이 데이터를 다른 이름으로 저장 temp.csv 작업을 수행합니다.
read.csv
read.csv csv 파일에서 데이터를 읽고 DataFrame 개체를 만듭니다.
import pandas as pd
df=pd.read_csv("temp.csv")
print df이것의 output 다음과 같습니다-
S.No Name Age City Salary
0 1 Tom 28 Toronto 20000
1 2 Lee 32 HongKong 3000
2 3 Steven 43 Bay Area 8300
3 4 Ram 38 Hyderabad 3900맞춤 색인
이것은 csv 파일의 열을 지정하여 다음을 사용하여 색인을 사용자 정의합니다. index_col.
import pandas as pd
df=pd.read_csv("temp.csv",index_col=['S.No'])
print df이것의 output 다음과 같습니다-
S.No Name Age City Salary
1 Tom 28 Toronto 20000
2 Lee 32 HongKong 3000
3 Steven 43 Bay Area 8300
4 Ram 38 Hyderabad 3900변환기
dtype 의 열은 dict로 전달 될 수 있습니다.
import pandas as pd
df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes이것의 output 다음과 같습니다-
S.No int64
Name object
Age int64
City object
Salary float64
dtype: object기본적으로 dtype 급여 열의 int하지만 결과는 다음과 같이 표시됩니다. float 유형을 명시 적으로 캐스팅했기 때문입니다.
따라서 데이터는 float처럼 보입니다.
S.No Name Age City Salary
0 1 Tom 28 Toronto 20000.0
1 2 Lee 32 HongKong 3000.0
2 3 Steven 43 Bay Area 8300.0
3 4 Ram 38 Hyderabad 3900.0header_names
names 인수를 사용하여 헤더의 이름을 지정하십시오.
import pandas as pd
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print df이것의 output 다음과 같습니다-
a b c d e
0 S.No Name Age City Salary
1 1 Tom 28 Toronto 20000
2 2 Lee 32 HongKong 3000
3 3 Steven 43 Bay Area 8300
4 4 Ram 38 Hyderabad 3900헤더 이름은 사용자 정의 이름과 함께 추가되지만 파일의 헤더는 제거되지 않았습니다. 이제 헤더 인수를 사용하여이를 제거합니다.
헤더가 첫 번째 행이 아닌 행에있는 경우 행 번호를 헤더에 전달하십시오. 이전 행을 건너 뜁니다.
import pandas as pd
df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print df이것의 output 다음과 같습니다-
a b c d e
0 S.No Name Age City Salary
1 1 Tom 28 Toronto 20000
2 2 Lee 32 HongKong 3000
3 3 Steven 43 Bay Area 8300
4 4 Ram 38 Hyderabad 3900Skiprows
skiprows는 지정된 행 수를 건너 뜁니다.
import pandas as pd
df=pd.read_csv("temp.csv", skiprows=2)
print df이것의 output 다음과 같습니다-
2 Lee 32 HongKong 3000
0 3 Steven 43 Bay Area 8300
1 4 Ram 38 Hyderabad 3900특정 값과 일치하는 데이터 (NaN / 누락 된 값, 임의의 값을 선택할 수 있음)가 생략되면 희소 개체가 "압축"됩니다. 특별한 SparseIndex 객체는 데이터가 "분할 된"위치를 추적합니다. 이것은 예에서 훨씬 더 의미가 있습니다. 모든 표준 Pandas 데이터 구조는to_sparse 방법-
import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts이것의 output 다음과 같습니다-
0 -0.810497
1 -1.419954
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 0.439240
9 -1.095910
dtype: float64
BlockIndex
Block locations: array([0, 8], dtype=int32)
Block lengths: array([2, 2], dtype=int32)희소 개체는 메모리 효율성을 위해 존재합니다.
이제 큰 NA DataFrame이 있다고 가정하고 다음 코드를 실행합니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10000, 4))
df.ix[:9998] = np.nan
sdf = df.to_sparse()
print sdf.density이것의 output 다음과 같습니다-
0.0001모든 희소 개체는 다음을 호출하여 표준 조밀 형식으로 다시 변환 할 수 있습니다. to_dense −
import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts.to_dense()이것의 output 다음과 같습니다-
0 -0.810497
1 -1.419954
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 0.439240
9 -1.095910
dtype: float64희소 D 유형
희소 데이터는 조밀 한 표현과 동일한 dtype을 가져야합니다. 현재float64, int64 과 booldtypes지원됩니다. 원본에 따라dtype, fill_value default 변화-
float64 − np.nan
int64 − 0
bool − 거짓
동일한 내용을 이해하기 위해 다음 코드를 실행 해 보겠습니다.
import pandas as pd
import numpy as np
s = pd.Series([1, np.nan, np.nan])
print s
s.to_sparse()
print s이것의 output 다음과 같습니다-
0 1.0
1 NaN
2 NaN
dtype: float64
0 1.0
1 NaN
2 NaN
dtype: float64경고는 경고를 의미하고 gotcha는 보이지 않는 문제를 의미합니다.
Pandas에서 If / Truth 문 사용
Pandas는 무언가를 변환하려고 할 때 오류를 발생시키는 numpy 규칙을 따릅니다. bool. 이것은if 또는 when 부울 연산을 사용하고, or, 또는 not. 결과가 무엇인지 명확하지 않습니다. 길이가 0이 아니므로 True 여야합니까? False 값이 있기 때문에 False? 불분명합니다. 대신 Pandas는ValueError −
import pandas as pd
if pd.Series([False, True, False]):
print 'I am True'이것의 output 다음과 같습니다-
ValueError: The truth value of a Series is ambiguous.
Use a.empty, a.bool() a.item(),a.any() or a.all().에 if조건, 그것으로 무엇을 해야할지 불분명합니다. 이 오류는 사용 여부를 암시합니다.None 또는 any of those.
import pandas as pd
if pd.Series([False, True, False]).any():
print("I am any")이것의 output 다음과 같습니다-
I am any부울 컨텍스트에서 단일 요소 pandas 객체를 평가하려면 다음 메서드를 사용하십시오. .bool() −
import pandas as pd
print pd.Series([True]).bool()이것의 output 다음과 같습니다-
True비트 부울
== 및 같은 비트 부울 연산자 != 거의 항상 필요한 부울 시리즈를 반환합니다.
import pandas as pd
s = pd.Series(range(5))
print s==4이것의 output 다음과 같습니다-
0 False
1 False
2 False
3 False
4 True
dtype: boolisin 운영
그러면 Series의 각 요소가 전달 된 값 시퀀스에 정확히 포함되어 있는지 여부를 보여주는 부울 계열이 반환됩니다.
import pandas as pd
s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s이것의 output 다음과 같습니다-
0 True
1 False
2 True
dtype: bool재색 인 vs ix Gotcha
많은 사용자가 ix indexing capabilities Pandas 객체에서 데이터를 선택하는 간결한 수단으로-
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.ix[['b', 'c', 'e']]이것의 output 다음과 같습니다-
one two three four
a -1.582025 1.335773 0.961417 -1.272084
b 1.461512 0.111372 -0.072225 0.553058
c -1.240671 0.762185 1.511936 -0.630920
d -2.380648 -0.029981 0.196489 0.531714
e 1.846746 0.148149 0.275398 -0.244559
f -1.842662 -0.933195 2.303949 0.677641
one two three four
b 1.461512 0.111372 -0.072225 0.553058
c -1.240671 0.762185 1.511936 -0.630920
e 1.846746 0.148149 0.275398 -0.244559물론 이것은이 경우에 reindex 방법-
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.reindex(['b', 'c', 'e'])이것의 output 다음과 같습니다-
one two three four
a 1.639081 1.369838 0.261287 -1.662003
b -0.173359 0.242447 -0.494384 0.346882
c -0.106411 0.623568 0.282401 -0.916361
d -1.078791 -0.612607 -0.897289 -1.146893
e 0.465215 1.552873 -1.841959 0.329404
f 0.966022 -0.190077 1.324247 0.678064
one two three four
b -0.173359 0.242447 -0.494384 0.346882
c -0.106411 0.623568 0.282401 -0.916361
e 0.465215 1.552873 -1.841959 0.329404어떤 사람들은 ix 과 reindex이것에 근거하여 100 % 동등합니다. 정수 인덱싱의 경우를 제외하고는 사실입니다. 예를 들어, 위의 작업은 다음과 같이 표현 될 수 있습니다.
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.ix[[1, 2, 4]]
print df.reindex([1, 2, 4])이것의 output 다음과 같습니다-
one two three four
a -1.015695 -0.553847 1.106235 -0.784460
b -0.527398 -0.518198 -0.710546 -0.512036
c -0.842803 -1.050374 0.787146 0.205147
d -1.238016 -0.749554 -0.547470 -0.029045
e -0.056788 1.063999 -0.767220 0.212476
f 1.139714 0.036159 0.201912 0.710119
one two three four
b -0.527398 -0.518198 -0.710546 -0.512036
c -0.842803 -1.050374 0.787146 0.205147
e -0.056788 1.063999 -0.767220 0.212476
one two three four
1 NaN NaN NaN NaN
2 NaN NaN NaN NaN
4 NaN NaN NaN NaN기억하는 것이 중요합니다 reindex is strict label indexing only. 이것은 인덱스에 정수와 문자열이 모두 포함 된 병리학적인 경우에 잠재적으로 놀라운 결과를 초래할 수 있습니다.
많은 잠재적 Pandas 사용자가 SQL에 어느 정도 익숙하기 때문에이 페이지에서는 Pandas를 사용하여 다양한 SQL 작업을 수행 할 수있는 방법에 대한 몇 가지 예를 제공합니다.
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips.head()이것의 output 다음과 같습니다-
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4고르다
SQL에서 선택은 선택한 열의 쉼표로 구분 된 목록을 사용하여 수행됩니다 (또는 모든 열을 선택하려면 *)-
SELECT total_bill, tip, smoker, time
FROM tips
LIMIT 5;Pandas를 사용하면 열 이름 목록을 DataFrame에 전달하여 열 선택이 수행됩니다.
tips[['total_bill', 'tip', 'smoker', 'time']].head(5)전체 프로그램을 확인해 보겠습니다.
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips[['total_bill', 'tip', 'smoker', 'time']].head(5)이것의 output 다음과 같습니다-
total_bill tip smoker time
0 16.99 1.01 No Dinner
1 10.34 1.66 No Dinner
2 21.01 3.50 No Dinner
3 23.68 3.31 No Dinner
4 24.59 3.61 No Dinner열 이름 목록없이 DataFrame을 호출하면 모든 열이 표시됩니다 (SQL의 *와 유사).
어디
SQL의 필터링은 WHERE 절을 통해 수행됩니다.
SELECT * FROM tips WHERE time = 'Dinner' LIMIT 5;DataFrame은 여러 방법으로 필터링 할 수 있습니다. 가장 직관적 인 것은 부울 인덱싱을 사용하는 것입니다.
tips[tips['time'] == 'Dinner'].head(5)전체 프로그램을 확인해 보겠습니다.
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips[tips['time'] == 'Dinner'].head(5)이것의 output 다음과 같습니다-
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4위의 문은 일련의 True / False 개체를 DataFrame에 전달하여 True로 모든 행을 반환합니다.
GroupBy
이 작업은 데이터 세트 전체에서 각 그룹의 레코드 수를 가져옵니다. 예를 들어, 성별이 남긴 팁의 수를 가져 오는 쿼리-
SELECT sex, count(*)
FROM tips
GROUP BY sex;팬더에 해당하는 것은-
tips.groupby('sex').size()전체 프로그램을 확인해 보겠습니다.
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips.groupby('sex').size()이것의 output 다음과 같습니다-
sex
Female 87
Male 157
dtype: int64상위 N 개 행
SQL은 top n rows 사용 LIMIT −
SELECT * FROM tips
LIMIT 5 ;팬더에 해당하는 것은-
tips.head(5)전체 예를 확인해 보겠습니다.
import pandas as pd
url = 'https://raw.github.com/pandas-dev/pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
tips = tips[['smoker', 'day', 'time']].head(5)
print tips이것의 output 다음과 같습니다-
smoker day time
0 No Sun Dinner
1 No Sun Dinner
2 No Sun Dinner
3 No Sun Dinner
4 No Sun Dinner다음은 Pandas 라이브러리의 이전 장에서 배운 몇 가지 기본 작업입니다.