Python-pandas-quick-guide
Pythonパンダ-はじめに
Pandasは、強力なデータ構造を使用して高性能のデータ操作および分析ツールを提供するオープンソースのPythonライブラリです。 パンダの名前は、多次元データからの計量経済学というパネルデータという言葉に由来しています。
2008年、開発者のWes McKinneyは、データ分析のための高性能で柔軟なツールが必要なときにパンダの開発を開始しました。
パンダ以前は、Pythonはデータの改ざんと準備に主に使用されていました。 データ分析にはほとんど貢献していません。 パンダはこの問題を解決しました。 Pandasを使用すると、データの出所に関係なく、データの処理と分析の5つの典型的なステップ（ロード、準備、操作、モデリング、分析）を実行できます。
Python with Pandasは、金融、経済、統計、分析などの学術および商業分野を含む幅広い分野で使用されています。
パンダの主な機能
- デフォルトおよびカスタマイズされたインデックス付けを備えた高速で効率的なDataFrameオブジェクト。
- さまざまなファイル形式からインメモリデータオブジェクトにデータをロードするためのツール。
- データのアライメントと欠落データの統合処理。
- 日付セットの形状変更とピボット。
- 大きなデータセットのラベルベースのスライス、インデックス作成、サブセット化。
- データ構造から列を削除または挿入できます。
- 集計および変換のためにデータごとにグループ化します。
- データの高性能なマージと結合。
- 時系列機能。
Pythonパンダ-環境設定
標準のPythonディストリビューションには、Pandasモジュールがバンドルされていません。 軽量の代替手段は、人気のあるPythonパッケージインストーラー* pip。*を使用してNumPyをインストールすることです
pip install pandasAnaconda 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]その*出力*は次のとおりです-
1例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']その*出力*は次のとおりです-
1例2
インデックスラベル値のリストを使用して複数の要素を取得します。
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve multiple elements
print s[[a','c','d']]その*出力*は次のとおりです-
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 |
データは、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その*出力*は次のとおりです-
0
0 1
1 2
2 3
3 4
4 5例2
import pandas as pd
data = [[Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print dfその*出力*は次のとおりです-
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その*出力*は次のとおりです-
a b
0 1 2
1 3 4
0 5 6
1 7 8行の削除
インデックスラベルを使用して、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.1105352つのアイテムがあり、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 NaNminor_axisを使用する
データには、* panel.minor_axis（index）。*メソッドを使用してアクセスできます。
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.minor_xs(1)その*出力*は次のとおりです-
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: float64axes
シリーズのラベルのリストを返します。
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?
Falsendim
オブジェクトの次元数を返します。 定義により、シリーズは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:
1size
シリーズのサイズ（長さ）を返します。
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: float64DataFrameの基本機能
ここで、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.80T（転置）
DataFrameの転置を返します。 行と列が入れ替わります。
import pandas as pd
import numpy as np
# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
# Create a DataFrame
df = pd.DataFrame(d)
print ("The transpose of the data series is:")
print df.Tその*出力*は次のとおりです-
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.8axes
行軸ラベルと列軸ラベルのリストを返します。
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?
Falsendim
オブジェクトの次元数を返します。 定義により、DataFrameは2Dオブジェクトです。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The dimension of the object is:")
print df.ndimその*出力*は次のとおりです-
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.8Pythonパンダ-記述統計
多数のメソッドが、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: float64std（）
数値列のブレセル標準偏差を返します。
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.800000Python 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: float64Pythonパンダ-インデックスの再作成
- 再インデックス*は、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.435479rename（）メソッドは、 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
yDataFrameの行を反復するには、次の関数を使用できます-
- * 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 1col1の値が並べ替えられ、それぞれのcol2の値と行インデックスがcol1とともに変化することに注意してください。 したがって、それらは分類されていないように見えます。
*'by'* 引数は列値のリストを取ります。import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by=['col1','col2'])
print sorted_dfその*出力*は次のとおりです-
col1 col2
2 1 2
1 1 3
3 1 4
0 2 1ソートアルゴリズム
- sort_values（）*は、mergesort、heapsort、quicksortからアルゴリズムを選択するための規定を提供します。 Mergesortは唯一の安定したアルゴリズムです。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')
print sorted_dfその*出力*は次のとおりです-
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1Python 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: objectlower（）
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: objectlen（）
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.len()その*出力*は次のとおりです-
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: objectsplit（パターン）
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: objectcat（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@tget_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: boolreplace（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 0startswith（パターン）
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that start with 'T':")
print s.str. startswith ('T')その*出力*は次のとおりです-
0 True
1 False
2 False
3 False
dtype: boolendswith（パターン）
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that end with 't':")
print s.str.endswith('t')その*出力*は次のとおりです-
Strings that end with 't':
0 False
1 False
2 False
3 True
dtype: boolfind（パターン）
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: objectNull 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: objectislower（）
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: boolisupper（）
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: boolisnumeric（）
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: boolPython 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")その*出力*は次のとおりです-
60display.max_columns
値のデフォルト数を表示します。 通訳者はこの値を読み取り、表示する上限としてこの値を持つ行を表示します。
import pandas as pd
print pd.get_option("display.max_columns")その*出力*は次のとおりです-
20ここで、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")その*出力*は次のとおりです-
80display.max_columns
- set_option（）*を使用して、表示するデフォルトの行数を変更できます。
import pandas as pd
pd.set_option("display.max_columns",30)
print pd.get_option("display.max_columns")その*出力*は次のとおりです-
30reset_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")その*出力*は次のとおりです-
60describe_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
101番目と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: float64Pythonパンダ-統計関数
統計的手法は、データの動作の理解と分析に役立ちます。 ここで、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.12978405324DataFrameに適用された共分散法は、すべての列間で cov を計算します。
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].cov(frame['b'])
print frame.cov()その*出力*は次のとおりです-
-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.000000DataFrameに数値以外の列がある場合、自動的に除外されます。
データランキング
データのランキングは、要素の配列内の各要素のランキングを生成します。 同順位の場合、平均ランクを割り当てます。
import pandas as pd
import numpy as np
s = pd.Series(np.random.np.random.randn(5), index=list('abcde'))
s['d'] = s['b'] # so there's a tie
print s.rank()その*出力*は次のとおりです-
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: float64DataFrameの複数の列に集計を適用する
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[[A','B']].aggregate(np.sum)その*出力*は次のとおりです-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B
2000-01-01 1.088512 -0.650942
2000-01-02 1.879182 -1.038796
2000-01-03 1.303660 -2.003821
2000-01-04 1.884801 -0.141119
2000-01-05 1.194699 0.010551
2000-01-06 1.925393 1.968551
2000-01-07 0.565208 0.032738
2000-01-08 0.564129 -0.759118
2000-01-09 2.048458 -1.820537
2000-01-10 2.065750 0.383357DataFrameの単一の列に複数の関数を適用する
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate([np.sum,np.mean])その*出力*は次のとおりです-
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
sum mean
2000-01-01 1.088512 1.088512
2000-01-02 1.879182 0.939591
2000-01-03 1.303660 0.434553
2000-01-04 1.884801 0.628267
2000-01-05 1.194699 0.398233
2000-01-06 1.925393 0.641798
2000-01-07 0.565208 0.188403
2000-01-08 0.564129 0.188043
2000-01-09 2.048458 0.682819
2000-01-10 2.065750 0.688583DataFrameの複数の列に複数の関数を適用する
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[[A','B']].aggregate([np.sum,np.mean])その*出力*は次のとおりです-
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.447078Pythonパンダ-欠落データ
現実のシナリオでは、データの欠落は常に問題です。 機械学習やデータマイニングなどの分野は、欠損値が原因でデータの品質が低下するため、モデル予測の精度に重大な問題があります。 これらの領域では、欠損値の処理がモデルをより正確かつ有効にするための主要な焦点です。
データが欠落するタイミングと理由
製品のオンライン調査について考えてみましょう。 多くの場合、人々は自分に関連するすべての情報を共有しません。 経験を共有している人はほとんどいませんが、製品を使用している期間はありません。製品を使用している期間、経験は共有しているが、連絡先情報は共有していない人はほとんどいません。 したがって、何らかの方法でデータの一部が常に欠落しています。これはリアルタイムでは非常に一般的です。
パンダを使用して欠損値（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 60Pythonパンダ-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 5Pythonパンダ-連結
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 sub5appendを使用した連結
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:00to_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-07Pythonパンダ-カテゴリーデータ
多くの場合、リアルタイムでは、データにはテキスト列が含まれますが、これは反復的です。 性別、国、コードなどの機能は常に繰り返されます。 これらは、カテゴリデータの例です。
カテゴリー変数は、限られた、通常は固定数の可能な値のみを取ります。 固定長に加えて、カテゴリデータには順序がありますが、数値演算を実行できません。 カテゴリーはパンダのデータ型です。
カテゴリーのデータ型は、次の場合に便利です-
- 少数の異なる値のみで構成される文字列変数。 このような文字列変数をカテゴリ変数に変換すると、メモリを節約できます。
- 変数の字句順序は、論理順序と同じではありません（「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: boolPythonパンダ-視覚化
基本的なプロット：プロット
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)その*出力*は次のとおりです-
列ごとに異なるヒストグラムをプロットするには、次のコードを使用します-
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=Nonepandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None*csv* ファイルのデータは次のようになります-S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900このデータを temp.csv として保存し、操作を実行します。
S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900このデータを temp.csv として保存し、操作を実行します。
read.csv
*read.csv* は、csvファイルからデータを読み取り、DataFrameオブジェクトを作成します。import pandas as pd
df=pd.read_csv("temp.csv")
print dfその*出力*は次のとおりです-
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.0header_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 3900Pythonパンダ-スパースデータ
スパースオブジェクトは、特定の値（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: float64Python 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: boolisin操作
これは、シリーズの各要素が渡された値のシーケンスに正確に含まれているかどうかを示すブールシリーズを返します。
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 4SELECT
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の前の章で学んだ、比較した数少ない基本的な操作です。
