Pythonパンダ-はじめに

Pandasは、強力なデータ構造を使用して高性能のデータ操作および分析ツールを提供するオープンソースのPythonライブラリです。パンダの名前は、多次元データからの計量経済学というパネルデータという言葉に由来しています。

2008年、開発者のWes McKinneyは、データ分析のための高性能で柔軟なツールが必要なときにパンダの開発を開始しました。

パンダ以前は、Pythonはデータの改ざんと準備に主に使用されていました。データ分析にはほとんど貢献していません。パンダはこの問題を解決しました。 Pandasを使用すると、データの出所に関係なく、データの処理と分析の5つの典型的なステップ（ロード、準備、操作、モデリング、分析）を実行できます。

Python with Pandasは、金融、経済、統計、分析などの学術および商業分野を含む幅広い分野で使用されています。

パンダの主な機能

デフォルトおよびカスタマイズされたインデックス付けを備えた高速で効率的なDataFrameオブジェクト。
さまざまなファイル形式からインメモリデータオブジェクトにデータをロードするためのツール。
データのアライメントと欠落データの統合処理。
日付セットの形状変更とピボット。
大きなデータセットのラベルベースのスライス、インデックス作成、サブセット化。
データ構造から列を削除または挿入できます。
集計および変換のためにデータごとにグループ化します。
データの高性能なマージと結合。
時系列機能。

Pythonパンダ-環境設定

標準のPythonディストリビューションには、Pandasモジュールがバンドルされていません。軽量の代替手段は、人気のあるPythonパッケージインストーラー* pip。*を使用してNumPyをインストールすることです

pip install pandas

Anaconda Pythonパッケージをインストールすると、パンダはデフォルトで次のようにインストールされます-

Windows

Anaconda （https://www.continuum.ioから）は、SciPyスタック用の無料のPythonディストリビューションです。 LinuxおよびMacでも利用可能です。
Canopy （https://www.enthought.com/products/canopy[https://www.enthought.com/products/canopy/]）は無料で入手でき、Windows用のフルSciPyスタックを備えた商用ディストリビューション、 LinuxおよびMac。
Python （x、y）は、SciPyスタックとWindows OS用のSpyder IDEを備えた無料のPythonディストリビューションです。（http://python-xy.github.io/からダウンロード可能）

Linux

各Linuxディストリビューションのパッケージマネージャーを使用して、1つ以上のパッケージをSciPyスタックにインストールします。

Ubuntuユーザー向け*

sudo apt-get install python-numpy python-scipy python-matplotlibipythonipythonnotebook
python-pandas python-sympy python-nose

Fedoraユーザーの場合*

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

データ構造の概要

パンダは、次の3つのデータ構造を扱います-

シリーズ
DataFrame
パネル

これらのデータ構造はNumpy配列の上に構築されているため、高速です。

寸法と説明

これらのデータ構造を考える最良の方法は、高次元のデータ構造が低次元のデータ構造のコンテナーであることです。たとえば、DataFrameはSeriesのコンテナであり、PanelはDataFrameのコンテナです。

Data Structure	Dimensions	Description
Series	1	1D labeled homogeneous array, sizeimmutable.
Data Frames	2	General 2D labeled, size-mutable tabular structure with potentially heterogeneously typed columns.
Panel	3	General 3D labeled, size-mutable array.

2次元以上の配列を作成して処理するのは退屈な作業であり、関数を記述するときにデータセットの方向を考慮するのはユーザーの負担となります。しかし、Pandasデータ構造を使用すると、ユーザーの精神的な労力は軽減されます。

たとえば、表形式のデータ（DataFrame）では、軸0と軸1ではなく、インデックス（行）と*列*を考える方が意味的に役立ちます。

ミュータビリティ

すべてのPandasデータ構造は値可変であり（変更可能）、シリーズを除きすべてサイズ可変です。シリーズはサイズ不変です。

注-DataFrameは広く使用されており、最も重要なデータ構造の1つです。パネルの使用はずっと少なくなります。

シリーズ

シリーズは、同種のデータを持つ構造のような1次元配列です。たとえば、次のシリーズは整数10、23、56、…のコレクションです

10

23

56

17

52

61

73

90

26

72

キーポイント

同種データ
サイズ不変
可変データの値

DataFrame

DataFrameは、異種データを含む2次元配列です。例えば、

Name	Age	Gender	Rating
Steve	32	Male	3.45
Lia	28	Female	4.6
Vin	45	Male	3.9
Katie	38	Female	2.78

この表は、組織の営業チームのデータと全体的なパフォーマンス評価を表します。データは行と列で表されます。各列は属性を表し、各行は人を表します。

列のデータ型

4列のデータ型は次のとおりです-

Column	Type
Name	String
Age	Integer
Gender	String
Rating	Float

キーポイント

異種データ
サイズ変更可能
可変データ

パネル

パネルは、異種データを含む3次元データ構造です。パネルをグラフィカルに表現するのは困難です。ただし、パネルはDataFrameのコンテナーとして示すことができます。

キーポイント

異種データ
サイズ変更可能
可変データ

Pythonパンダ-シリーズ

Seriesは、任意のタイプ（整数、文字列、浮動小数点、Pythonオブジェクトなど）のデータを保持できる1次元のラベル付き配列です。軸ラベルはまとめてインデックスと呼ばれます。

pandas.Series

パンダシリーズは、次のコンストラクタを使用して作成することができます-

pandas.Series( data, index, dtype, copy)

コンストラクタのパラメータは次のとおりです-

Sr.No	Parameter & Description
1	data データは、ndarray、リスト、定数などのさまざまな形式を取ります
2	index インデックス値は一意でハッシュ可能で、データと同じ長さでなければなりません。インデックスが渡されない場合のデフォルトの* np.arrange（n）*。
3	dtype dtypeはデータ型用です。なしの場合、データ型が推測されます
4	copy データをコピーします。デフォルトはFalse

シリーズは、次のようなさまざまな入力を使用して作成できます-

アレイ
Dict
スカラー値または定数

空のシリーズを作成する

作成できる基本シリーズは空のシリーズです。

例

#import the pandas library and aliasing as pd
import pandas as pd
s = pd.Series()
print s

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

b 1.0
c 2.0
d NaN
a 0.0
dtype: float64

*Observe* -インデックスの順序は維持され、欠落している要素はNaN（非数）で埋められます。

Scalarからシリーズを作成する

データがスカラー値の場合、インデックスを提供する必要があります。値は 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

その*出力*は次のとおりです-

0  5
1  5
2  5
3  5
dtype: int64

位置のあるシリーズのデータへのアクセス

シリーズのデータには、* ndarray。*のデータと同様にアクセスできます。

例1

最初の要素を取得します。既に知っているように、カウントは配列のゼロから始まります。つまり、最初の要素はzero ^ th ^の位置に格納されます。

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]

その*出力*は次のとおりです-

例2

シリーズの最初の3つの要素を取得します。：がその前に挿入されると、そのインデックス以降のすべてのアイテムが抽出されます。 2つのパラメーター（間に：がある）が使用される場合、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]

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

c  3
d  4
e  5
dtype: int64

ラベルを使用してデータを取得（インデックス）

Seriesは、インデックスラベルで値を取得および設定できるという点で、固定サイズの 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']

その*出力*は次のとおりです-

例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']]

その*出力*は次のとおりです-

a  1
c  3
d  4
dtype: int64

実施例３

ラベルが含まれていない場合、例外が発生します。

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s['f']

その*出力*は次のとおりです-

…
KeyError: 'f'

Pythonパンダ-DataFrame

データフレームは2次元のデータ構造です。つまり、データは表形式で行と列に配置されます。

DataFrameの機能

潜在的に列は異なるタイプです
サイズ-可変
ラベル付き軸（行と列） *行と列に対して算術演算を実行できます

構造

学生のデータでデータフレームを作成していると仮定しましょう。

構造テーブル

SQLテーブルまたはスプレッドシートのデータ表現と考えることができます。

pandas.DataFrame

パンダのDataFrameは、次のコンストラクタを使用して作成することができます-

pandas.DataFrame( data, index, columns, dtype, copy)

コンストラクタのパラメータは次のとおりです-

Sr.No	Parameter & Description
1	data* データは、ndarray、series、map、lists、dict、constant、および別のDataFrameなどのさまざまな形式を取ります。
2	index 行ラベルの場合、インデックスが渡されない場合、結果のフレームに使用されるインデックスはオプションのデフォルトnp.arrange（n）です。
3	columns 列ラベルの場合、オプションのデフォルト構文は-np.arrange（n）です。これは、インデックスが渡されない場合にのみ当てはまります。
4	dtype 各列のデータ型。
5	copy デフォルトがFalseの場合、このコマンド（またはそれが何であれ）はデータのコピーに使用されます。

DataFrameを作成

パンダDataFrameはのような様々な入力を使用して作成することができます-

リスト
dict
シリーズ
Numpy ndarrays
別のデータフレーム

この章の以降のセクションでは、これらの入力を使用してDataFrameを作成する方法について説明します。

空のデータフレームを作成する

作成できる基本的なDataFrameは空のDataframeです。

例

#import the pandas library and aliasing as pd
import pandas as pd
df = pd.DataFrame()
print df

その*出力*は次のとおりです-

Empty DataFrame
Columns: []
Index: []

リストからデータフレームを作成する

DataFrameは、単一のリストまたはリストのリストを使用して作成できます。

例1

import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df

その*出力*は次のとおりです-

例2

import pandas as pd
data = [[Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print df

その*出力*は次のとおりです-

      Name      Age
0     Alex      10
1     Bob       12
2     Clarke    13

実施例３

import pandas as pd
data = [[Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print df

その*出力*は次のとおりです-

      Name     Age
0     Alex     10.0
1     Bob      12.0
2     Clarke   13.0

注意- dtype パラメータは、Ageカラムのタイプを浮動小数点に変更します。

ndarrays/Listsの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

その*出力*は次のとおりです-

      Age      Name
0     28        Tom
1     34       Jack
2     29      Steve
3     42      Ricky

注-値0、1、2、3を確認します。それらは、関数range（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

その*出力*は次のとおりです-

         Age    Name
rank1    28      Tom
rank2    34     Jack
rank3    29    Steve
rank4    42    Ricky

注-観察、 index パラメータは各行にインデックスを割り当てます。

辞書のリストからデータフレームを作成する

辞書のリストを入力データとして渡して、DataFrameを作成できます。辞書キーはデフォルトで列名として使用されます。

例1

次の例は、辞書のリストを渡すことでDataFrameを作成する方法を示しています。

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print df

その*出力*は次のとおりです-

    a    b      c
0   1   2     NaN
1   5   10   20.0

注-観察、NaN（Not a Number）が欠落領域に追加されます。

例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

その*出力*は次のとおりです-

        a   b       c
first   1   2     NaN
second  5   10   20.0

実施例３

次の例は、辞書、行インデックス、および列インデックスのリストを使用して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

その*出力*は次のとおりです-

#df1 output
         a  b
first    1  2
second   5  10

#df2 output
         a  b1
first    1  NaN
second   5  NaN

注-観察、df2 DataFrameはディクショナリキー以外の列インデックスで作成されます。したがって、所定の位置にNaNを追加しました。一方、df1は辞書キーと同じ列インデックスで作成されるため、NaNが追加されます。

シリーズの辞書からデータフレームを作成する

シリーズの辞書を渡して、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    two
a     1.0    1
b     2.0    2
c     3.0    3
d     NaN    4

注-シリーズ1では、ラベル「」d *は渡されませんが、結果では、 *d ラベルではNaNにNaNが追加されます。

例を通して、列の選択、追加、および*削除*を理解しましょう。

列の選択

これを理解するには、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']

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

行の選択、追加、および削除

例を通して行の選択、追加、削除を理解します。選択の概念から始めましょう。

ラベルによる選択

行を選択するには、行ラベルを 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']

その*出力*は次のとおりです-

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]

その*出力*は次のとおりです-

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]

その*出力*は次のとおりです-

   one  two
c  3.0    3
d  NaN    4

行の追加

*append* 関数を使用して、DataFrameに新しい行を追加します。 この関数は、行を最後に追加します。

import pandas as pd

df = pd.DataFrame([[columns = ['a','b'])
df2 = pd.DataFrame([[columns = ['a','b'])

df = df.append(df2)
print df

その*出力*は次のとおりです-

行の削除

インデックスラベルを使用して、DataFrameから行を削除またはドロップします。ラベルが重複している場合、複数の行が削除されます。

上記の例では、ラベルが重複しています。ラベルをドロップして、ドロップされる行数を確認します。

import pandas as pd

df = pd.DataFrame([[columns = ['a','b'])
df2 = pd.DataFrame([[columns = ['a','b'])

df = df.append(df2)

# Drop rows with label 0
df = df.drop(0)

print df

その*出力*は次のとおりです-

  a b
1 3 4
1 7 8

上記の例では、2つの行に同じラベル0が含まれているため、2つの行が削除されました。

Pythonパンダ-パネル

パネル*は、データの3Dコンテナです。「パネルデータ」という用語は計量経済学から派生したものであり、パンダという名前の一部を担っています- pan（el）-da（ta）*-s。

3つの軸の名前は、パネルデータに関連する操作を説明する意味的な意味を与えることを意図しています。彼らは-

items -軸0、各アイテムは内部に含まれるDataFrameに対応します。
major_axis -軸1、これは各DataFrameのインデックス（行）です。
minor_axis -軸2、各DataFrameの列です。

pandas.Panel（）

パネルは、次のコンストラクタを使用して作成できます-

pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)

コンストラクタのパラメータは次のとおりです-

Parameter	Description
data	Data takes various forms like ndarray, series, map, lists, dict, constants and also another DataFrame
items	axis=0
major_axis	axis=1
minor_axis	axis=2
dtype	Data type of each column
copy	Copy data. Default, 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

その*出力*は次のとおりです-

<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

注意-空のパネルと上のパネルの寸法を確認してください。すべてのオブジェクトは異なります。

DataFrameオブジェクトの辞書から

#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

その*出力*は次のとおりです-

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

空のパネルを作成する

空のパネルは、次のようにパネルコンストラクタを使用して作成することができます-

#creating an empty panel
import pandas as pd
p = pd.Panel()
print p

その*出力*は次のとおりです-

<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

パネルからデータを選択する

を使用してパネルからデータを選択します-

アイテム
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']

その*出力*は次のとおりです-

            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

2つのアイテムがあり、item1を取得しました。結果は、4行3列のDataFrameになります。これらは、 Major_axis および Minor_axis ディメンションです。

major_axisを使用する

データには、* panel.major_axis（index）*メソッドを使用してアクセスできます。

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.major_xs(1)

その*出力*は次のとおりです-

      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)

その*出力*は次のとおりです-

       Item1       Item2
0   -0.128637   -1.047032
1    0.896681   -0.557322
2    0.571668    0.431953
3   -0.144234    1.302466

注-寸法の変化を観察します。

Pythonパンダ-基本機能

ここまでで、3つのPandas DataStructureとそれらの作成方法について学びました。リアルタイムデータ処理における重要性のため、主にDataFrameオブジェクトに焦点を当て、いくつかの他のDataStructureについても説明します。

シリーズの基本機能

Sr.No.	Attribute or Method & Description
1	axes 行軸ラベルのリストを返します
2	dtype オブジェクトのdtypeを返します。
3	empty シリーズが空の場合、Trueを返します。
4	ndim 基になるデータの次元数を定義1で返します。
5	size 基になるデータの要素の数を返します。
6	values シリーズを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

その*出力*は次のとおりです-

0   0.967853
1  -0.148368
2  -1.395906
3  -1.758394
dtype: float64

axes

シリーズのラベルのリストを返します。

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

その*出力*は次のとおりです-

The axes are:
[RangeIndex(start=0, stop=4, step=1)]

上記の結果は、0から5までの値のリストのコンパクトな形式、つまり[0,1,2,3,4]です。

空の

オブジェクトが空かどうかを示すブール値を返します。 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

その*出力*は次のとおりです-

Is the Object empty?
False

ndim

オブジェクトの次元数を返します。定義により、シリーズは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

その*出力*は次のとおりです-

0   0.175898
1   0.166197
2  -0.609712
3  -1.377000
dtype: float64

The dimensions of the object:
1

size

シリーズのサイズ（長さ）を返します。

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

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.No.	Attribute or Method & Description
1	T 行と列を入れ替えます。
2	axes 行軸ラベルと列軸ラベルを唯一のメンバーとして含むリストを返します。
3	dtypes このオブジェクトのdtypeを返します。
4	empty NDFrameが完全に空の場合[アイテムなし]の場合はtrue。軸の長さが0の場合。
5	ndim 軸の数/配列の次元。
6	shape DataFrameの次元を表すタプルを返します。
7	size NDFrameの要素の数。
8	values NDFrameのナンピー表現。
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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

axes

行軸ラベルと列軸ラベルのリストを返します。

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

The data types of each column are:
Age     int64
Name    object
Rating  float64
dtype: 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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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)

size

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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:
[[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)

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

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

Pythonパンダ-記述統計

多数のメソッドが、DataFrameの記述統計およびその他の関連操作をまとめて計算します。これらのほとんどは* sum（）、mean（）などの集約ですが、 sumsum（）などの一部は同じサイズのオブジェクトを生成します。一般的に、これらのメソッドは_ndarray。\ {sum、std、…}、_と同様に *axis 引数を取りますが、軸は名前または整数で指定できます

DataFrame -「インデックス」（軸= 0、デフォルト）、「列」（軸= 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

その*出力*は次のとおりです-

    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

和（）

要求された軸の値の合計を返します。デフォルトでは、軸はインデックス（axis = 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()

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

Age       31.833333
Rating     3.743333
dtype: float64

std（）

数値列のブレセル標準偏差を返します。

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()

その*出力*は次のとおりです-

Age       9.232682
Rating    0.661628
dtype: float64

機能と説明

Python Pandasの記述統計の機能を理解しましょう。次の表は、重要な機能の一覧です-

Sr.No.	Function	Description
1	count()	Number of non-null observations
2	sum()	Sum of values
3	mean()	Mean of Values
4	median()	Median of Values
5	mode()	Mode of values
6	std()	Standard Deviation of the Values
7	min()	Minimum Value
8	max()	Maximum Value
9	abs()	Absolute Value
10	prod()	Product of Values
11	cumsum()	Cumulative Sum
12	cumprod()	Cumulative Product

注-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()

その*出力*は次のとおりです-

               Age         Rating
count    12.000000      12.000000
mean     31.833333       3.743333
std       9.232682       0.661628
min      23.000000       2.560000
25%      25.000000       3.230000
50%      29.500000       3.790000
75%      35.500000       4.132500
max      51.000000       4.800000

この関数は、 mean、std 、および IQR 値を提供します。また、関数は文字列を除外し、数値列に関する概要を提供します。 'include' は、要約のために考慮する必要がある列に関する必要な情報を渡すために使用される引数です。値のリストを取得します。デフォルトでは、「number」。

オブジェクト-文字列の列を要約します
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'])

その*出力*は次のとおりです-

          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')

その*出力*は次のとおりです-

          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

Python Pandas-関数アプリケーション

独自のライブラリまたは別のライブラリの機能をPandasオブジェクトに適用するには、3つの重要な方法に注意する必要があります。これらの方法については以下で説明しました。使用する適切な方法は、関数がDataFrame全体、行単位または列単位、または要素単位で動作することを期待するかどうかによって異なります。

表ごとの関数アプリケーション：pipe（）
行または列のワイズ関数アプリケーション：apply（）
要素ごとの関数アプリケーション：applymap（）

テーブル単位の関数アプリケーション

関数と適切な数のパラメーターをパイプ引数として渡すことにより、カスタム操作を実行できます。したがって、操作はDataFrame全体で実行されます。

たとえば、値2を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)

その*出力*は次のとおりです-

        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

行または列のワイズ関数アプリケーション

任意の関数は、* apply（）*メソッドを使用して、DataFrameまたはPanelの軸に沿って適用できます。これは、記述統計メソッドと同様に、オプションの軸引数を取ります。デフォルトでは、操作は列ごとに実行され、各列を配列のように取ります。

例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)

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

col1    0.034093
col2   -0.152672
col3   -0.229728
dtype: float64

実施例３

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)

その*出力*は次のとおりです-

col1   -0.167413
col2   -0.370495
col3   -0.707631
dtype: float64

要素ワイズ関数アプリケーション

すべての関数をベクトル化できるわけではなく（別の配列も値も返さないNumPy配列も）、DataFrameの* applymap（）およびSeriesの analyously 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)

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

col1    0.395263
col2    0.204418
col3   -0.795188
dtype: float64

Pythonパンダ-インデックスの再作成

再インデックス*は、DataFrameの行ラベルと列ラベルを変更します。 _reindex_とは、特定の軸に沿ってラベルの特定のセットに一致するようにデータを適合させることを意味します。

複数の操作は、次のようなインデックス作成によって実現できます-

新しいラベルのセットと一致するように既存のデータを並べ替えます。
ラベルのデータが存在しないラベル位置に欠損値（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

その*出力*は次のとおりです-

            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

その*出力*は次のとおりです-

          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

注-ここでは、 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')

その*出力*は次のとおりです-

         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

注-最後の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)

その*出力*は次のとおりです-

         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

注-観察、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'})

その*出力*は次のとおりです-

         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 を渡して、その場でデータの名前を変更します。

Pythonパンダ-反復

Pandasオブジェクトに対する基本的な反復の動作は、タイプによって異なります。 Seriesを反復処理する場合、それは配列のようなものと見なされ、基本的な反復処理によって値が生成されます。 DataFrameやPanelなどの他のデータ構造は、オブジェクトの keys を反復処理する* dictのような*規則に従います。

要するに、基本的な反復（オブジェクトの i の場合）は次を生成します-

シリーズ-値
DataFrame -列ラベル
パネル-アイテムのラベル

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

その*出力*は次のとおりです-

A
C
D
x
y

DataFrameの行を反復するには、次の関数を使用できます-

* iteritems（）*-（キー、値）のペアを反復処理する
* iterrows（）*-（インデックス、シリーズ）のペアとして行を反復処理する
* itertuples（）*-namedtuplesとして行を反復処理します

iteritems（）

各列をキーとして、値のペアをラベルとしてキー、列の値をシリーズオブジェクトとして繰り返します。

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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

注-* 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

その*出力*は次のとおりです-

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)

注意-反復中はオブジェクトを変更しないでください。反復は読み取りを目的としており、反復子は元のオブジェクト（ビュー）のコピーを返すため、変更は元のオブジェクトに反映されません。

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

その*出力*は次のとおりです-

        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

観察、変更は反映されません。

Pythonパンダ-並べ替え

Pandasには2種類の並べ替えがあります。彼らは-

ラベル別
実際の値で

出力のある例を考えてみましょう。

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

その*出力*は次のとおりです-

        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

その*出力*は次のとおりです-

        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

その*出力*は次のとおりです-

         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

その*出力*は次のとおりです-

         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

その*出力*は次のとおりです-

   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

その*出力*は次のとおりです-

ソートアルゴリズム

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

その*出力*は次のとおりです-

  col1 col2
1    1    3
2    1    2
3    1    4
0    2    1

Python Pandas-テキストデータの操作

この章では、基本的なシリーズ/インデックスを使用した文字列操作について説明します。後続の章では、これらの文字列関数をDataFrameに適用する方法を学習します。

Pandasは、文字列データの操作を容易にする一連の文字列関数を提供します。最も重要なことは、これらの関数は欠損/NaN値を無視（または除外）することです。

ほとんどの場合、これらのメソッドはすべてPython文字列関数で機能します（https://docs.python.org/3/library/stdtypesl#string-methodsを参照）。そのため、SeriesオブジェクトをStringオブジェクトに変換してから、操作を実行します。

各操作の実行方法を見てみましょう。

Sr.No	Function & Description
1	lower() シリーズ/インデックスの文字列を小文字に変換します。
2	upper() Series/Indexの文字列を大文字に変換します。
3	len() String length（）を計算します。
4	strip() 両側のSeries/indexの各文字列から空白（改行を含む）を取り除くのに役立ちます。
5	split(' ') 指定されたパターンで各文字列を分割します。
6	cat(sep=' ') シリーズ/インデックス要素を指定されたセパレータで連結します。
7	get_dummies() ワンホットエンコード値でDataFrameを返します。
8	contains(pattern) 部分文字列が要素に含まれる場合は各要素に対してブール値Trueを返し、そうでない場合はFalseを返します。
9	replace(a,b) 値 a を値 b に置き換えます。
10	repeat(value) 指定された回数で各要素を繰り返します。
11	count(pattern) 各要素のパターンの出現回数を返します。
12	startswith(pattern) Series/Indexの要素がパターンで始まる場合、trueを返します。
13	endswith(pattern) Series/Indexの要素がパターンで終わる場合、trueを返します。
14	find(pattern) パターンが最初に現れる最初の位置を返します。
15	findall(pattern) パターンのすべての出現のリストを返します。
16	swapcase ケースの下部/上部を交換します。
17	islower() シリーズ/インデックスの各文字列のすべての文字が小文字かどうかを確認します。ブール値を返します
18	isupper() Series/Indexの各文字列のすべての文字が大文字かどうかを確認します。ブール値を返します。
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

その*出力*は次のとおりです-

0            Tom
1   William Rick
2           John
3        Alber@t
4            NaN
5           1234
6    Steve Smith
dtype: object

lower（）

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()

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

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

split（パターン）

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(' ')

その*出力*は次のとおりです-

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

cat（sep = pattern）

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.cat(sep='_')

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

   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(' ')

その*出力*は次のとおりです-

0   True
1   True
2   False
3   False
dtype: bool

replace（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('@','$')

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

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')

その*出力*は次のとおりです-

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')

その*出力*は次のとおりです-

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')

その*出力*は次のとおりです-

Strings that end with 't':
0  False
1  False
2  False
3  True
dtype: bool

find（パターン）

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.find('e')

その*出力*は次のとおりです-

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')

その*出力*は次のとおりです-

0 []
1 []
2 []
3 [e]
dtype: object

Null list（[]）は、要素にそのようなパターンが存在しないことを示します。

swapcase（）

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.swapcase()

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

0  False
1  False
2  False
3  False
dtype: bool

Python Pandas-オプションとカスタマイズ

パンダは、その動作のいくつかの側面をカスタマイズするためのAPIを提供し、ディスプレイが主に使用されています。

APIは、5つの関連する機能で構成されています。彼らは-

get_option（）
set_option（）
reset_option（）
describe_option（）
option_context（）

関数がどのように動作するかを理解しましょう。

get_option（param）

get_optionは単一のパラメータを取り、以下の出力で与えられた値を返します-

display.max_rows

値のデフォルト数を表示します。通訳者はこの値を読み取り、表示する上限としてこの値を持つ行を表示します。

import pandas as pd
print pd.get_option("display.max_rows")

その*出力*は次のとおりです-

display.max_columns

値のデフォルト数を表示します。通訳者はこの値を読み取り、表示する上限としてこの値を持つ行を表示します。

import pandas as pd
print pd.get_option("display.max_columns")

その*出力*は次のとおりです-

ここで、60および20はデフォルトの構成パラメーター値です。

set_option（param、value）

set_optionは2つの引数を取り、以下に示すようにパラメータに値を設定します-

display.max_rows

set_option（）*を使用して、表示するデフォルトの行数を変更できます。

import pandas as pd

pd.set_option("display.max_rows",80)

print pd.get_option("display.max_rows")

その*出力*は次のとおりです-

display.max_columns

set_option（）*を使用して、表示するデフォルトの行数を変更できます。

import pandas as pd

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

print pd.get_option("display.max_columns")

その*出力*は次のとおりです-

reset_option（param）

*reset_option* は引数を取り、値をデフォルト値に戻します。

display.max_rows

reset_option（）を使用して、表示するデフォルトの行数に戻すことができます。

import pandas as pd

pd.reset_option("display.max_rows")
print pd.get_option("display.max_rows")

その*出力*は次のとおりです-

describe_option（param）

*describe_option* は引数の説明を出力します。

display.max_rows

reset_option（）を使用して、表示するデフォルトの行数に戻すことができます。

import pandas as pd
pd.describe_option("display.max_rows")

その*出力*は次のとおりです-

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ステートメント*でオプションを一時的に設定するために使用されます。 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"))

その*出力*は次のとおりです-

10
10

1番目と2番目のprintステートメントの違いを参照してください。最初のステートメントは、 with_context 自体の内部で一時的な* option_context（）によって設定された値を出力します。 *with context の後、2番目のprintステートメントは設定された値を出力します。

よく使用されるパラメーター

Sr.No	Parameter & Description
1	display.max_rows 表示する最大行数を表示します
2	2 display.max_columns 表示する列の最大数を表示します
3	display.expand_frame_repr ページをストレッチするためのデータフレームを表示します
4	display.max_colwidth 最大列幅を表示します
5	display.precision 10進数の精度を表示します

Python Pandas-データのインデックス作成と選択

この章では、日付を切り刻み、パンダオブジェクトのサブセットを取得する方法について説明します。

PythonおよびNumPyのインデックス演算子「[]」および属性演算子「。」幅広いユースケースでPandasデータ構造にすばやく簡単にアクセスできます。ただし、アクセスするデータのタイプは事前にはわからないため、標準演算子を直接使用すると最適化の制限がいくつかあります。本番コードの場合、この章で説明する最適化されたパンダデータアクセス方法を利用することをお勧めします。

パンダは現在、3種類のマルチ軸インデックスをサポートしています。 3つのタイプは、次の表に記載されています-

Sr.No

Indexing & Description

1

.loc()

ラベルベース

2

.iloc()

整数ベース

3

.ix()

ラベルと整数ベースの両方

.loc（）

パンダは、純粋に*ラベルベースのインデックス作成*を行うためのさまざまな方法を提供します。スライスするとき、開始境界も含まれます。整数は有効なラベルですが、位置ではなくラベルを参照します。

.loc（）*には複数のアクセス方法があります-
単一のスカラーラベル
ラベルのリスト
スライスオブジェクト

ブール配列

*loc* は、「、」で区切られた2つのsingle/list/range演算子を取ります。 最初の行は行を示し、2番目の行は列を示します。

例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']

その*出力*は次のとおりです-

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']]

その*出力*は次のとおりです-

            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

実施例３

# 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']]

その*出力*は次のとおりです-

           A          C
a   0.391548   0.745623
b  -0.070649   1.620406
f   0.613709   0.286414
h   1.122680  -1.621420

実施例４

# 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']

その*出力*は次のとおりです-

            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

実施例５

# 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

その*出力*は次のとおりです-

A  False
B  True
C  False
D  False
Name: a, dtype: bool

.iloc（）

パンダは、純粋に整数ベースのインデックスを取得するためにさまざまなメソッドを提供します。 pythonやnumpyと同様に、これらは* 0ベースのインデックスです。

さまざまなアクセス方法は次のとおりです-

整数
整数のリスト
値の範囲

例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]

その*出力*は次のとおりです-

           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]

その*出力*は次のとおりです-

           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

実施例３

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[[print df.iloc[1:3, :]
print df.iloc[:,1:3]

その*出力*は次のとおりです-

           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]

その*出力*は次のとおりです-

           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']

その*出力*は次のとおりです-

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

表記法の使用

Multi-axesインデックスを使用してPandasオブジェクトから値を取得するには、次の表記法を使用します-

Object	Indexers	Return Type
Series	s.loc[indexer]	Scalar value
DataFrame	df.loc[row_index,col_index]	Series object
Panel	p.loc[item_index,major_index, minor_index]	p.loc[item_index,major_index, minor_index]

注意-.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']

その*出力*は次のとおりです-

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

注意-値のリストを[]に渡して、それらの列を選択できます。

例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']]

その*出力*は次のとおりです-

           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

実施例３

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]

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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

Pythonパンダ-統計関数

統計的手法は、データの動作の理解と分析に役立ちます。ここで、Pandasオブジェクトに適用できるいくつかの統計関数を学習します。

変化率

シリーズ、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()

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

-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()

その*出力*は次のとおりです-

-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

注-最初のステートメントの a と b 列の間の cov を観察します。これは、DataFrameのcovによって返される値です。

相関

相関関係は、任意の2つの値の配列（系列）の間の線形関係を示しています。ピアソン（デフォルト）、スピアマン、ケンドールなど、相関を計算する方法は複数あります。

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()

その*出力*は次のとおりです-

-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()

その*出力*は次のとおりです-

a  1.0
b  3.5
c  2.0
d  3.5
e  5.0
dtype: float64

ランクは、オプションで、デフォルトでtrueであるパラメータの昇順を取ります。 falseの場合、データは逆ランク付けされ、値が大きいほど小さいランクが割り当てられます。

ランクは、メソッドパラメータで指定されたさまざまなタイブレークメソッドをサポートしています-

平均-同順位グループの平均ランク
min -グループ内の最低ランク
max -グループ内の最高ランク
first -配列に現れる順序で割り当てられたランク

Pythonパンダ-ウィンドウ関数

Pandasは、数値データを扱うために、ウィンドウ統計の重みをローリング、拡張、指数関数的に移動するなど、いくつかのバリエーションを提供します。これらには、合計、平均、中央値、分散、共分散、相関などがあります。

次に、これらのそれぞれを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()

その*出力*は次のとおりです-

                    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

注-ウィンドウサイズは3であるため、最初の2つの要素にはnullがあり、3番目以降の値は n 、 n-1 、および n-2 要素の平均になります。したがって、前述のさまざまな機能を適用することもできます。

.expanding（）関数

この関数は、一連のデータに適用できます。 min_periods = n 引数を指定し、その上に適切な統計関数を適用します。

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.expanding(min_periods=3).mean()

その*出力*は次のとおりです-

                   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()

その*出力*は次のとおりです-

                    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

ウィンドウ関数は、曲線を平滑化することにより、データ内の傾向をグラフィカルに見つけるのに主に使用されます。毎日のデータに多くの変動があり、多くのデータポイントが利用できる場合、サンプルを取得してプロットすることは1つの方法であり、ウィンドウ計算を適用して結果にグラフをプロットすることは別の方法です。これらの方法により、曲線または傾向を滑らかにすることができます。

Pythonパンダ-集約

ローリング、エキスパンド、および 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

その*出力*は次のとおりです-

                    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)

その*出力*は次のとおりです-

                    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)

その*出力*は次のとおりです-

                 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)

その*出力*は次のとおりです-

                 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])

その*出力*は次のとおりです-

                 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])

その*出力*は次のとおりです-

                 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})

その*出力*は次のとおりです-

                    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

Pythonパンダ-欠落データ

現実のシナリオでは、データの欠落は常に問題です。機械学習やデータマイニングなどの分野は、欠損値が原因でデータの品質が低下するため、モデル予測の精度に重大な問題があります。これらの領域では、欠損値の処理がモデルをより正確かつ有効にするための主要な焦点です。

データが欠落するタイミングと理由

製品のオンライン調査について考えてみましょう。多くの場合、人々は自分に関連するすべての情報を共有しません。経験を共有している人はほとんどいませんが、製品を使用している期間はありません。製品を使用している期間、経験は共有しているが、連絡先情報は共有していない人はほとんどいません。したがって、何らかの方法でデータの一部が常に欠落しています。これはリアルタイムでは非常に一般的です。

パンダを使用して欠損値（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

その*出力*は次のとおりです-

         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はSeriesおよびDataFrameオブジェクトのメソッドでもある* isnull（）および notnull（）*関数を提供します-

例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()

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

a  True
b  False
c  True
d  False
e  True
f  True
g  False
h  True
Name: one, dtype: bool

欠損データを含む計算

データを合計する場合、NAはゼロとして扱われます
データがすべて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()

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

nan

欠損データのクリーニング/充填

パンダは、欠損値をクリーニングするためのさまざまな方法を提供します。 fillna関数は、次のセクションで説明したように、いくつかの方法でNA値に非NULLデータを「埋める」ことができます。

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)

その*出力*は次のとおりです-

         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

ここでは、値ゼロで埋めています。代わりに、他の値を入力することもできます。

NAを前後に埋める

ReIndexingの章で説明した充填の概念を使用して、欠損値を充填します。

Sr.No

Method & Action

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')

その*出力*は次のとおりです-

         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')

その*出力*は次のとおりです-

         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

欠損値を削除

欠損値を単純に除外したい場合は、 axis 引数と共に dropna 関数を使用します。デフォルトでは、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()

その*出力*は次のとおりです-

         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)

その*出力*は次のとおりです-

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})

その*出力*は次のとおりです-

   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})

その*出力*は次のとおりです-

   one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Pythonパンダ-GroupBy

*groupby* 操作には、元のオブジェクトに対する次の操作のいずれかが含まれます。 彼らは-

*分割*オブジェクト
*適用*関数
結果を組み合わせる

多くの場合、データをセットに分割し、各サブセットにいくつかの機能を適用します。適用機能では、次の操作を実行できます-

集計-要約統計量の計算
変換-いくつかのグループ固有の操作を実行します
フィルター-何らかの条件でデータを破棄する

ここで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

その*出力*は次のとおりです-

    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

データをグループに分割する

パンダオブジェクトは、任意のオブジェクトに分割できます。のようなオブジェクトを分割する複数の方法があります-

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')

その*出力*は次のとおりです-

<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

その*出力*は次のとおりです-

{'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')}

例

複数の列を持つ*でグループ化-

# 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

その*出力*は次のとおりです-

{('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

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

   Points  Rank     Team    Year
0     876     1   Riders    2014
2     863     2   Devils    2014
4     741     3   Kings     2014
9     701     4   Royals    2014

集計

集約関数は、グループごとに1つの集約値を返します。 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)

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

         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])

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

       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)

その*出力*は次のとおりです-

    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回以上参加したチームを返すよう求めています。

Python Pandas-マージ/参加

Pandasには、SQLなどのリレーショナルデータベースに非常によく似た、フル機能の高性能なメモリ内結合操作があります。

パンダは、DataFrameオブジェクト間のすべての標準データベース結合操作のエントリポイントとして、単一の関数 merge を提供します-

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)

ここでは、次のパラメータを使用しました-

左-DataFrameオブジェクト。
right -別のDataFrameオブジェクト。
on -結合する列（名前）。左右のDataFrameの両方にある必要がありますオブジェクト
left_on -キーとして使用する左側のDataFrameの列。 DataFrameの長さと等しい長さの列名または配列のいずれかです。
right_on -キーとして使用する右側のDataFrameの列。 DataFrameの長さと等しい長さの列名または配列のいずれかです。
left_index -* Trueの場合、*左側のDataFrameのインデックス（行ラベル）を結合キーとして使用します。 MultiIndex（階層）を持つDataFrameの場合、レベルの数は、右側のDataFrameからの結合キーの数と一致する必要があります。
right_index -右側のDataFrameの left_index と同じ使用法。
方法-「左」、「右」、「外側」、「内側」のいずれか。デフォルトは内部です。それぞれの方法について以下に説明します。
sort -辞書データ順に結合キーで結果のDataFrameをソートします。デフォルトはTrueで、Falseに設定すると、多くの場合、パフォーマンスが大幅に向上します。

2つの異なる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

その*出力*は次のとおりです-

    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

キー上の2つのデータフレームをマージする

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')

その*出力*は次のとおりです-

   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

複数のキーで2つのデータフレームをマージする

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'])

その*出力*は次のとおりです-

    Name_x   id   subject_id   Name_y
0    Alice    4         sub6    Bryce
1   Ayoung    5         sub5    Betty

「how」引数を使用したマージ

mergeの how 引数は、結果のテーブルに含めるキーを決定する方法を指定します。キーの組み合わせが左テーブルにも右テーブルにも表示されない場合、結合テーブルの値はNAになります。

ここに*方法*オプションとそれらに相当するSQL名の要約があります-

Merge Method	SQL Equivalent	Description
left	LEFT OUTER JOIN	Use keys from left object
right	RIGHT OUTER JOIN	Use keys from right object
outer	FULL OUTER JOIN	Use union of keys
inner	INNER JOIN	Use intersection of keys

左結合

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')

その*出力*は次のとおりです-

    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')

その*出力*は次のとおりです-

    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')

その*出力*は次のとおりです-

    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')

その*出力*は次のとおりです-

    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

Pythonパンダ-連結

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 -これは、インデックスオブジェクトのリストです。内部/外部セットロジックを実行する代わりに、他の（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])

その*出力*は次のとおりです-

    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'])

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

    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* に沿って2つのオブジェクトを追加する必要がある場合、新しい列が追加されます。

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)

その*出力*は次のとおりです-

    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

appendを使用した連結

concatへの便利なショートカットは、SeriesおよびDataFrameのappendインスタンスメソッドです。これらのメソッドは、実際に連結に先行していました。彼らは*軸= 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)

その*出力*は次のとおりです-

    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])

その*出力*は次のとおりです-

    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は、上記のタスクを実行するための比較的コンパクトで自己完結型のツールセットを提供します。

現在の時刻を取得

datetime.now（）*は現在の日付と時刻を提供します。

import pandas as pd

print pd.datetime.now()

その*出力*は次のとおりです-

2017-05-11 06:10:13.393147

タイムスタンプを作成する

タイムスタンプ付きデータは、値と時点を関連付ける最も基本的なタイプの時系列データです。パンダオブジェクトの場合は、特定の時点を使用することを意味します。例を見てみましょう-

import pandas as pd

print pd.Timestamp('2017-03-01')

その*出力*は次のとおりです-

2017-03-01 00:00:00

整数または浮動エポック時間に変換することも可能です。これらのデフォルトの単位はナノ秒です（これらはタイムスタンプの格納方法であるため）。ただし、多くの場合、エポックは指定可能な別のユニットに保存されます。別の例を見てみましょう

import pandas as pd

print pd.Timestamp(1587687255,unit='s')

その*出力*は次のとおりです-

2020-04-24 00:14:15

時間の範囲を作成する

import pandas as pd

print pd.date_range("11:00", "13:30", freq="30min").time

その*出力*は次のとおりです-

[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

その*出力*は次のとおりです-

[datetime.time(11, 0) datetime.time(12, 0) datetime.time(13, 0)]

タイムスタンプへの変換

文字列、エポック、または混合など、日付のようなオブジェクトのシリーズまたはリストのようなオブジェクトを変換するには、 to_datetime 関数を使用できます。渡されると、これは（同じインデックスを持つ）Seriesを返しますが、 list-like は DatetimeIndex に変換されます。次の例を見てください-

import pandas as pd

print pd.to_datetime(pd.Series(['Jul 31, 2009','2010-01-10', None]))

その*出力*は次のとおりです-

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])

その*出力*は次のとおりです-

DatetimeIndex(['2005-11-23', '2010-12-31', 'NaT'], dtype='datetime64[ns]', freq=None)

Pythonパンダ-日付機能

時系列を拡張する日付機能は、財務データ分析で重要な役割を果たします。日付データで作業している間、私たちは頻繁に次のものに遭遇します-

日付のシーケンスを生成する
日付シリーズを異なる頻度に変換する

日付の範囲を作成する

期間と頻度を指定して* date.range（）*関数を使用すると、日付系列を作成できます。デフォルトでは、範囲の頻度は日数です。

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

その*出力*は次のとおりです-

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')

その*出力*は次のとおりです-

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)

その*出力*は次のとおりです-

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日を除いて6月3日にジャンプします。カレンダーを確認してください。

*date_range* や *bdate_range* などの便利な関数は、さまざまな周波数エイリアスを利用します。 date_rangeのデフォルトの頻度は暦日ですが、bdate_rangeのデフォルトの頻度は営業日です。

import pandas as pd
start = pd.datetime(2011, 1, 1)
end = pd.datetime(2011, 1, 5)

print pd.date_range(start, end)

その*出力*は次のとおりです-

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

オフセットエイリアス

有用な一般的な時系列周波数に、多くの文字列エイリアスが与えられます。これらのエイリアスをオフセットエイリアスと呼びます。

Alias	Description	Alias	Description
B	business day frequency	BQS	business quarter start frequency
D	calendar day frequency	A	annual(Year) end frequency
W	weekly frequency	BA	business year end frequency
M	month end frequency	BAS	business year start frequency
SM	semi-month end frequency	BH	business hour frequency
BM	business month end frequency	H	hourly frequency
MS	month start frequency	T, min	minutely frequency
SMS	SMS semi month start frequency	S	secondly frequency
BMS	business month start frequency	L, ms	milliseconds
Q	quarter end frequency	U, us	microseconds
BQ	business quarter end frequency	N	nanoseconds
QS	quarter start frequency

Pythonパンダ-タイムデルタ

タイムデルタは時間の差であり、日、時間、分、秒などの異なる単位で表されます。彼らは正と負の両方にすることができます。

以下に示すように、さまざまな引数を使用してTimedeltaオブジェクトを作成できます-

ひも

文字列リテラルを渡すことで、timedeltaオブジェクトを作成できます。

import pandas as pd

print pd.Timedelta('2 days 2 hours 15 minutes 30 seconds')

その*出力*は次のとおりです-

2 days 02:15:30

整数

整数値をユニットに渡すことにより、引数はTimedeltaオブジェクトを作成します。

import pandas as pd

print pd.Timedelta(6,unit='h')

その*出力*は次のとおりです-

0 days 06:00:00

データオフセット

-週、日、時間、分、秒、ミリ秒、マイクロ秒、ナノ秒などのデータオフセットも構築に使用できます。

import pandas as pd

print pd.Timedelta(days=2)

その*出力*は次のとおりです-

2 days 00:00:00

to_timedelta（）

最上位の pd.to_timedelta を使用すると、スカラー、配列、リスト、またはシリーズを、認識されたタイムデルタ形式/値からタイムデルタ型に変換できます。入力がシリーズの場合はシリーズを構築し、入力がスカラーのような場合はスカラーを構築し、そうでない場合は TimedeltaIndex を出力します。

import pandas as pd

print pd.Timedelta(days=2)

その*出力*は次のとおりです-

2 days 00:00:00

オペレーション

Series/DataFramesを操作し、 datetime64 [ns] SeriesまたはTimestampsの減算演算により timedelta64 [ns] Seriesを構築できます。

ここで、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

その*出力*は次のとおりです-

            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

その*出力*は次のとおりです-

           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

その*出力*は次のとおりです-

           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

Pythonパンダ-カテゴリーデータ

多くの場合、リアルタイムでは、データにはテキスト列が含まれますが、これは反復的です。性別、国、コードなどの機能は常に繰り返されます。これらは、カテゴリデータの例です。

カテゴリー変数は、限られた、通常は固定数の可能な値のみを取ります。固定長に加えて、カテゴリデータには順序がありますが、数値演算を実行できません。カテゴリーはパンダのデータ型です。

カテゴリーのデータ型は、次の場合に便利です-

少数の異なる値のみで構成される文字列変数。このような文字列変数をカテゴリ変数に変換すると、メモリを節約できます。
変数の字句順序は、論理順序と同じではありません（「1」、「2」、「3」）。カテゴリに変換し、カテゴリの順序を指定することにより、並べ替えと最小/最大は、語彙の順序ではなく論理的な順序を使用します。
この列をカテゴリ変数として扱う必要があるという他のpythonライブラリへのシグナルとして（例：適切な統計手法またはプロットタイプを使用します）。

オブジェクト作成

カテゴリオブジェクトは複数の方法で作成できます。さまざまな方法が以下に説明されています-

カテゴリー

pandasオブジェクト作成でdtypeを「category」として指定します。

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print s

その*出力*は次のとおりです-

0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

シリーズオブジェクトに渡される要素の数は4ですが、カテゴリは3つだけです。出力カテゴリで同じことを確認します。

pd.Categorical

標準のパンダカテゴリコンストラクタを使用して、カテゴリオブジェクトを作成できます。

pandas.Categorical(values, categories, ordered)

例を見てみましょう-

import pandas as pd

cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat

その*出力*は次のとおりです-

[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

その*出力*は次のとおりです-

[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]

ここで、2番目の引数はカテゴリを示します。したがって、カテゴリに存在しない値は NaN として扱われます。

今、次の例を見てみましょう-

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat

その*出力*は次のとおりです-

[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]

論理的に、順序は、 a が b より大きく、 b が c より大きいことを意味します。

説明

カテゴリデータで* .describe（）コマンドを使用すると、 *type 文字列の Series または DataFrame に同様の出力が得られます。

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()

その*出力*は次のとおりです-

       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* コマンドを使用して、オブジェクトの *categoories* を取得します。

import pandas as pd
import numpy as np

s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print s.categories

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

False

順序を指定していないため、関数は false を返しました。

カテゴリの名前を変更する

カテゴリの名前を変更するには、* series.cat.categories * series.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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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")

その*出力*は次のとおりです-

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]

カテゴリデータの比較

カテゴリデータを他のオブジェクトと比較することは、次の3つの場合に可能です-

等しい（==および！=）をリストのようなオブジェクト（リスト、シリーズ、配列、…）と比較するカテゴリデータと同じ長さ。
別のカテゴリデータとのすべての比較（==、！=、>、> =、<、および⇐） categorical Series、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

その*出力*は次のとおりです-

0  False
1  False
2  True
dtype: bool

Pythonパンダ-視覚化

基本的なプロット：プロット

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()

その*出力*は次のとおりです-

基本的なプロット

インデックスが日付で構成されている場合、* gct（）。autofmt_xdate（）*を呼び出して、上の図に示すようにx軸をフォーマットします。

*x* および *y* キーワードを使用して、ある列と別の列をプロットできます。

プロット方法では、デフォルトのラインプロット以外のいくつかのプロットスタイルを使用できます。これらのメソッドは、* plot（）*のkindキーワード引数として提供できます。これらには-

バープロットのバーまたはバー
ヒストグラムの履歴
箱ひげ図の箱
面積プロットの「面積」
散布図の「散布」

バープロット

バープロットを作成して、バープロットとは何かを見てみましょう。バープロットは次の方法で作成できます-

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()

その*出力*は次のとおりです-

棒グラフ

積み上げ棒グラフを作成するには、 passstacked = True -

import pandas as pd
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar(stacked=True)

その*出力*は次のとおりです-

積み上げ棒グラフ

水平棒グラフを取得するには、 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)

その*出力*は次のとおりです-

水平バープロット

ヒストグラム

ヒストグラムは、* 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)

その*出力*は次のとおりです-

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.diff.hist(bins=20)

その*出力*は次のとおりです-

列のヒストグラム

箱ひげ図

Boxplotは、* 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()

その*出力*は次のとおりです-

ボックスプロット

面積プロット

エリアプロットは、* 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()

その*出力*は次のとおりです-

エリアプロット

散布図

散布図は、* 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')

その*出力*は次のとおりです-

散布図

円グラフ

円グラフは、* 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)

その*出力*は次のとおりです-

円グラフ

Pythonパンダ-IOツール

*Pandas I/O API* は、一般的にPandasオブジェクトを返す* pd.read_csv（）*のようにアクセスされる一連のトップレベルリーダー関数です。

テキストファイル（またはフラットファイル）を読み取るための2つの主な機能は、* 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

その*出力*は次のとおりです-

   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

その*出力*は次のとおりです-

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 を辞書として渡すことができます。

import pandas as pd

df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes

その*出力*は次のとおりです-

S.No       int64
Name      object
Age        int64
City      object
Salary   float64
dtype: object

デフォルトでは、Salary列の dtype は int ですが、明示的に型をキャストしているため、結果は 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

その*出力*は次のとおりです-

       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

その*出力*は次のとおりです-

      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は、指定された行数をスキップします。

import pandas as pd

df=pd.read_csv("temp.csv", skiprows=2)
print df

その*出力*は次のとおりです-

    2      Lee   32    HongKong   3000
0   3   Steven   43    Bay Area   8300
1   4      Ram   38   Hyderabad   3900

Pythonパンダ-スパースデータ

スパースオブジェクトは、特定の値（NaN/欠損値、任意の値を選択できます）に一致するデータが省略されると「圧縮」されます。特別なSparseIndexオブジェクトは、データが「スパース化」された場所を追跡します。これは、例でより意味があります。標準のパンダのデータ構造はすべて、 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

その*出力*は次のとおりです-

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

その*出力*は次のとおりです-

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()

その*出力*は次のとおりです-

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

スパースDtype

疎データは、その密表現と同じdtypeを持つ必要があります。現在、 float64、int64 、および booldtypes がサポートされています。元の dtypeに応じて、fill_value default が変更されます-

float64 -np.nan
int64 -0
bool -False

同じことを理解するために次のコードを実行してみましょう-

import pandas as pd
import numpy as np

s = pd.Series([1, np.nan, np.nan])
print s

s.to_sparse()
print s

その*出力*は次のとおりです-

0   1.0
1   NaN
2   NaN
dtype: float64

0   1.0
1   NaN
2   NaN
dtype: float64

Python Pandas-警告と落とし穴

警告は警告を意味し、落とし穴は目に見えない問題を意味します。

パンダでIf/Truthステートメントを使用する

Pandasは、何かを bool に変換しようとするとエラーを発生させるというnumpyの規則に従います。これは、ブール演算を使用する if または when 、および or または not で発生します。結果がどうあるべきかは明確ではありません。長さがゼロではないため、Trueである必要がありますか？ False値があるためFalse。それは明確ではないので、代わりに、パンダは ValueError を発生させます-

import pandas as pd

if pd.Series([False, True, False]):
   print 'I am True'

その*出力*は次のとおりです-

ValueError: The truth value of a Series is ambiguous.
Use a.empty, a.bool() a.item(),a.any() or a.all().

*if* 状態では、それをどうするかは不明です。 エラーは、 *None* または* anyのいずれかを使用するかどうかを示唆しています。

import pandas as pd

if pd.Series([False, True, False]).any():
   print("I am any")

その*出力*は次のとおりです-

I am any

ブールコンテキストで単一要素のパンダオブジェクトを評価するには、メソッド* .bool（）*を使用します−

import pandas as pd

print pd.Series([True]).bool()

その*出力*は次のとおりです-

True

ビットごとのブール

==や！ =のようなビット単位のブール演算子は、ブールシリーズを返します。これは、ほとんどの場合に必要なものです。

import pandas as pd

s = pd.Series(range(5))
print s==4

その*出力*は次のとおりです-

0 False
1 False
2 False
3 False
4 True
dtype: bool

isin操作

これは、シリーズの各要素が渡された値のシーケンスに正確に含まれているかどうかを示すブールシリーズを返します。

import pandas as pd

s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s

その*出力*は次のとおりです-

0 True
1 False
2 True
dtype: bool

再索引付けとix Gotcha

多くのユーザーは、パンダオブジェクトからデータを選択する簡潔な手段として* ixインデックス機能*を使用していることに気付くでしょう-

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']]

その*出力*は次のとおりです-

          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'])

その*出力*は次のとおりです-

          one        two      three       four
a    1.639081   1.369838   0.261287  -1.662003
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
d   -1.078791  -0.612607  -0.897289  -1.146893
e    0.465215   1.552873  -1.841959   0.329404
f    0.966022  -0.190077   1.324247   0.678064

          one        two      three       four
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
e    0.465215   1.552873  -1.841959   0.329404

*ix* と *reindex* はこれに基づいて100％同等であると結論付ける人もいます。 これは、整数のインデックス付けの場合を除いて当てはまります。 たとえば、上記の操作は、代わりに-

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[[print df.reindex([1, 2, 4])

その*出力*は次のとおりです-

          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は厳密なラベルインデックスのみであることに注意することが重要です。これにより、インデックスに整数と文字列の両方が含まれるような病理学的なケースで、驚くべき結果が生じる可能性があります。

Python Pandas-SQLとの比較

多くの潜在的なPandasユーザーはSQLにある程度精通しているため、このページはパンダを使用してさまざまな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()

その*出力*は次のとおりです-

    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

SELECT

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)

その*出力*は次のとおりです-

   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;

DataFramesは複数の方法でフィルタリングできます。最も直感的なのは、ブールインデックスを使用することです。

  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)

その*出力*は次のとおりです-

   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()

その*出力*は次のとおりです-

sex
Female   87
Male    157
dtype: int64

上位N行

SQLは LIMIT を使用して*上位n行*を返します-

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

その*出力*は次のとおりです-

   smoker   day     time
0      No   Sun   Dinner
1      No   Sun   Dinner
2      No   Sun   Dinner
3      No   Sun   Dinner
4      No   Sun   Dinner

これらは、Pandas Libraryの前の章で学んだ、比較した数少ない基本的な操作です。

Python-pandas-quick-guide

Pythonパンダ-はじめに

パンダの主な機能

Pythonパンダ-環境設定

Windows

Linux

データ構造の概要

寸法と説明

ミュータビリティ

シリーズ

キーポイント

DataFrame

列のデータ型

キーポイント

パネル

キーポイント

Pythonパンダ-シリーズ

pandas.Series

空のシリーズを作成する

例

ndarrayからシリーズを作成する

例1

例2

dictからシリーズを作成する

例1

例2

Scalarからシリーズを作成する

位置のあるシリーズのデータ​​へのアクセス

例1

例2

実施例３

ラベルを使用してデータを取得（インデックス）

例1

例2

実施例３

Pythonパンダ-DataFrame

DataFrameの機能

構造

pandas.DataFrame

DataFrameを作成

空のデータフレームを作成する

例

リストからデータフレームを作成する

例1

例2

実施例３

ndarrays/ListsのDictからDataFrameを作成します

例1

例2

辞書のリストからデータフレームを作成する

例1

例2

実施例３

シリーズの辞書からデータフレームを作成する

例

列の選択

例

列の追加

例

列の削除

例

行の選択、追加、および削除

ラベルによる選択

整数位置による選択

スライス行

行の追加

行の削除

Pythonパンダ-パネル

pandas.Panel（）

パネルを作成

3D ndarrayから

DataFrameオブジェクトの辞書から

空のパネルを作成する

パネルからデータを選択する

アイテムを使用する

major_axisを使用する

minor_axisを使用する

Pythonパンダ-基本機能

シリーズの基本機能

例

位置のあるシリーズのデータへのアクセス