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 pandas

Anaconda 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-nose

For Fedora Users

sudo yum install numpyscipy python-matplotlibipython python-pandas sympy
python-nose atlas-devel

Pandas는 다음 세 가지 데이터 구조를 다룹니다.

  • 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: float64

Observe − 사전 키는 색인을 구성하는 데 사용됩니다.

예 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: float64

Observe − 인덱스 순서는 유지되고 누락 된 요소는 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.0

Note − 관찰, 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      Ricky

Note− 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    Ricky

Note − 관찰, 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.0

Note − 누락 된 영역에 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  NaN

Note− 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    4

Note − 시리즈 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 4

Note − 빈 패널과 위 패널의 치수를 관찰하십시오. 모든 개체가 다릅니다.

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_axisMinor_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       NaN

minor_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.302466

Note − 치수의 변화를 관찰하십시오.

지금까지 우리는 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?
False

ndim

개체의 차원 수를 반환합니다. 정의에 따라 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: float64

tail() 마지막을 반환 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: float64

DataFrame 기본 기능

이제 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.80

T (조옮김)

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?
False

ndim

개체의 차원 수를 반환합니다. 정의에 따라 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.24

tail() 마지막을 반환 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: float64

std ()

숫자 열의 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, stdIQR가치. 그리고 함수는 문자 열과 숫자 열에 대한 요약을 제외합니다.'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: float64

ReindexingDataFrame의 행 레이블 및 열 레이블을 변경합니다. 재 색인 이란 특정 축을 따라 주어진 레이블 집합과 일치하도록 데이터를 일치시키는 것을 의미합니다.

다음과 같은 인덱싱을 통해 여러 작업을 수행 할 수 있습니다.

  • 새 레이블 세트와 일치하도록 기존 데이터의 순서를 변경하십시오.

  • 레이블에 대한 데이터가없는 레이블 위치에 결 측값 (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.295275

Note − 여기서 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.133371

Note − 마지막 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         NaN

Note− 관찰하십시오. 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.435479

rename () 메서드는 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
y

DataFrame의 행을 반복하려면 다음 함수를 사용할 수 있습니다.

  • 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: float64

Note − 왜냐하면 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    1

col1 값이 정렬되고 각 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: object

len ()

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@t

get_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    0

startswith (패턴)

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: bool

endswith (패턴)

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: object

Null 목록 ([])은 요소에서 사용할 수있는 패턴이 없음을 나타냅니다.

스왑 케이스 ()

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: object

islower ()

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: bool

isupper ()

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: bool

isnumeric ()

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: bool

Pandas는 동작의 일부 측면을 사용자 지정하는 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 다음과 같습니다-

60

display.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 다음과 같습니다-

80

display.max_columns

사용 set_option(), 표시 할 기본 행 수를 변경할 수 있습니다.

import pandas as pd

pd.set_option("display.max_columns",30)

print pd.get_option("display.max_columns")

이것의 output 다음과 같습니다-

30

reset_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 다음과 같습니다-

60

describe_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: float64

Note − 값 목록을 []에 전달하여 해당 열을 선택할 수 있습니다.

예 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.12978405324

DataFrame에 적용될 때 공분산 방법은 다음을 계산합니다. 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.960761

Note − 관찰 cov 중에서 ab 첫 번째 명령문의 열과 동일한 값이 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.000000

DataFrame에 숫자가 아닌 열이 있으면 자동으로 제외됩니다.

데이터 랭킹

데이터 순위는 요소 배열의 각 요소에 대한 순위를 생성합니다. 동점 인 경우 평균 순위를 할당합니다.

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: float64

Rank는 기본적으로 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.067156

Note − 창 크기가 3이기 때문에 처음 두 요소의 경우 null이 있고 세 번째 요소의 값은 n, n-1n-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: float64

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[['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.383357

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['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.688583

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[['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      5

Pandas는 쉽게 결합 할 수있는 다양한 기능을 제공합니다. 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_rangebdate_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:00

to_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 보다 큼 bb 보다 큼 c.

기술

사용 .describe() 범주 형 데이터에 대한 명령을 실행하면 Series 또는 DataFrametype 끈.

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 축 형식을 지정합니다.

다음을 사용하여 한 열 대 다른 열을 그릴 수 있습니다. xy 키워드.

플로팅 방법을 사용하면 기본 선 플롯 이외의 몇 가지 플롯 스타일을 사용할 수 있습니다. 이러한 메소드는에 대한 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=None

pandas.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.0

header_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     3900

Skiprows

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, int64booldtypes지원됩니다. 원본에 따라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: bool

isin 운영

그러면 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

어떤 사람들은 ixreindex이것에 근거하여 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 라이브러리의 이전 장에서 배운 몇 가지 기본 작업입니다.