はじめに
今回も「Pythonによるデータ分析入門」を用いて学習を進めて参りました。今日はpandas。この本の著者の方がpandasの開発者であるためか、非常に読んでいてわかりやすく感じました。手を動かすので、体に馴染ませることができるという点も非常に良いです。
pandas基礎
まずはモジュールのインポート。
import pandas as pd #pandasのインポート。pdにするのは慣習らしい。
pandasのデータ構造
pandasはSeriesとDataFrameという2つのデータ構造を持つ。Seriesは一次元配列で、DataFrameは二次元配列。（物理的にはらしい）
Series
ここからはSeriesの基本的な使い方を見ていく。
s = pd.Series([1, 2, 3, 4]) #Seriesの作成。ｓは大文字。
#結果
0 1
1 2
2 3
3 4
dtype: int64
インデックスが左側の数字。(0,1,2,3)データ値が右側の数字。(1,2,3,4)
s = pd.Series([1, 2, 3, 4], index = ["a", "b", "c", "d"]) #引数にindexを設定し、値を格納することでインデックス付けが可能。
s["a"] #インデックス参照。
s["a"] = 100 #値の代入。
s[["b", "c", "a"]] #順番を変えてインデックス参照することも可能。
#結果
a 1
b 2
c 3
d 4
dtype: int64
np.int64(1)
b 2
c 3
a 100
dtype: int64
index にリスト[a,b,c,d]を代入したことで、(0,1,2,3)が(a,b,c,d)になっている。インデックス参照もndarrayの時と同様。さらに、真偽配列を使ったフィルタリングも可能。
s[s > 10]
s * 10
#結果
a 100
dtype: int64
a 1000
b 20
c 30
d 40
dtype: int64
辞書からSeriesを作成することも可能。
s = pd.Series({"a": 1, "b": 2, "c": 3})
s.to_dict() #辞書に戻すメソッド。
s = pd.Series({"a": 1, "b": 2, "c": 3}, index = ["b", "a", "d"])
#結果
a 1
b 2
c 3
dtype: int64
{'a': 1, 'b': 2, 'c': 3}
b 2.0
a 1.0
d NaN
dtype: float64
keyがインデックスに、valueがデータ値になると分かる。また、辞書をSeriesにするときは、置かれたkeyの順番にインデックスと値が並ぶ。上記の通り、上書きが可能であるが、"d"に対応するデータが元の辞書に存在しないため、NaN値となっている。pandasでは、これは欠損値（NA値）として扱われる。
s.isna() #欠損値である場合、Trueを返すメソッド。
s.notna() #欠損値でない場合、Trueを返すメソッド。
#結果
b False
a False
d True
dtype: bool
b True
a True
d False
dtype: bool
dが欠損値であることと一致。また、Series、インデックスはname属性と呼ばれるものを持ち、名前を付けることも可能で、代入に依る置き換えも可能。
s.name = "nums"
s.index.name = "index" #indexにnameを与える
s.index = ["x", "y", "z"]
#結果
index
b 2.0
a 1.0
d NaN
Name: nums, dtype: float64
x 2.0
y 1.0
z NaN
Name: nums, dtype: float64
DataFrame
DataFrameはテーブル形式のデータ構造を持つ。（エクセルみたいな感じ？）各列には別々の型を持つことが可能で、（ndarrayは全ての配列が同じ型でないといけなかった。）行と列の両方にインデックスを持つ。これは、SeriesをValueに持つ辞書として解釈することができる。
DataFrameの作成
df = pd.DataFrame({"a": [100, 200, 300, 1, 2, 3],
"b": [400, 500, 600, 4, 5, 6],
"c": [700, 800, 900, 7, 8, 9]})
df.head()
df.tail()
#結果
a b c
0 100 400 700
1 200 500 800
2 300 600 900
3 1 4 7
4 2 5 8
5 3 6 9
a b c
0 100 400 700
1 200 500 800
2 300 600 900
3 1 4 7
4 2 5 8
a b c
1 200 500 800
2 300 600 900
3 1 4 7
4 2 5 8
5 3 6 9
リストをvalueに持つ辞書を作成する方法が最も簡単。引数indexを設定しない場合、列インデックスは自動的に生成される。head()、tail()はそれぞれ、最初の5つ、最後の5つを表示する。
新しい列の作成
pd.DataFrame(df, columns = ["a", "c", "b"]) #第一引数に変更したいデータ、第二引数にcolumnsを設定し、順番を変更したリストを代入。
df2 = pd.DataFrame(df, columns = ["a", "c", "b", "d"]) #元のDataFrameには存在しないdを追加。
df2["a"] #ディクショナリ風の参照
df2.a #上のコードと結果は同じ
#結果
a c b
0 100 700 400
1 200 800 500
2 300 900 600
3 1 7 4
4 2 8 5
5 3 9 6
a c b d
0 100 700 400 NaN
1 200 800 500 NaN
2 300 900 600 NaN
3 1 7 4 NaN
4 2 8 5 NaN
5 3 9 6 NaN
0 100
1 200
2 300
3 1
4 2
5 3
Name: a, dtype: int64
0 100
1 200
2 300
3 1
4 2
5 3
Name: a, dtype: int64
"d"列は元のデータに存在しないため、列の値が丸ごとNaNになっている。DataFrameはディクショナリ風の参照ができる。
行の参照
行の参照。locとilocによって参照が可能。（ilocはindexによって行の参照を行う。）
df2.loc[1] #行インデックス名が「1」である行に含まれる要素
df2.iloc[0] #0行目に含まれる要素
#結果
a 200.0
c 800.0
b 500.0
d NaN
Name: 1, dtype: float64
a 100.0
c 700.0
b 400.0
d NaN
Name: 0, dtype: float64
列への代入
列の各値は代入によって変更が可能。Seriesを列に代入することも可能。
df2["d"] = 100
df2["d"] = np.arange(6)
s = pd.Series(np.arange(10,70,10))
df2["d"] = s
#結果
a c b d
0 100 700 400 100
1 200 800 500 100
2 300 900 600 100
3 1 7 4 100
4 2 8 5 100
5 3 9 6 100
a c b d
0 100 700 400 0
1 200 800 500 1
2 300 900 600 2
3 1 7 4 3
4 2 8 5 4
5 3 9 6 5
a c b d
0 100 700 400 10
1 200 800 500 20
2 300 900 600 30
3 1 7 4 40
4 2 8 5 50
5 3 9 6 60
ここで、Seriesを代入する際、DataFrameのインデックスに対応するものがないときは欠損値が代入されることには注意。ここではインデックスを設定していなかったためそのような事態は発生しなかった。
列の削除
列の削除。delキーワードを使う。
del df2["d"]
#結果
a c b
0 100 700 400
1 200 800 500
2 300 900 600
3 1 7 4
4 2 8 5
5 3 9 6
他のデータ形式には、ネストしたディクショナリがある。これをDataFrameに渡すと、外側のkeyは列インデックスに、内側のkeyは行インデックスになる。また、index、columnsに名前属性を与えることも可能。
```python
dict = {"X": {"a": 1, "b": 2, "c": 3},
"Y": {"a": 4, "b": 5, "c": 6},
"Z": {"a": 7, "b": 8, "c": 9}}
nested = pd.DataFrame(dict)
nested.index.name = "index"
nested.columns.name = "columns"
nested
#結果
columns X Y Z
index
a 1 4 7
b 2 5 8
c 3 6 9
ここで、DataFrameに渡すことができる入力値をメモしておく。
・2次元ndarray配列
・リスト、タプル、Series、辞書をvalueにもつ辞書
・ディクショナリ、シリーズ、タプルのリスト
・DataFrame
インデックスオブジェクト
pandasにはインデックスオブジェクトというものが存在する。インデックスオブジェクトは、軸のラベルを保存しておく役割がある。初期化の際に指定したラベルが内部的にインデックスオブジェクトに変換される。
s = pd.Series(rng.standard_normal(5), index = ["a", "b", "c", "d", "e"])
index = s.index
index[1] = "x"
#結果
Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[286], line 1
----> 1 index[1] = "x"
File ~\anaconda3\Lib\site-packages\pandas\core\indexes\base.py:5371, in Index.__setitem__(self, key, value)
5369 @final
5370 def __setitem__(self, key, value) -> None:
-> 5371 raise TypeError("Index does not support mutable operations")
TypeError: Index does not support mutable operations
エラーの内容から読み取れるように、インデックスオブジェクトはmutable（変更可能）でない。
再インデックス付け
reindexメソッドを用いることで新しいインデックスに従って並べ変えることが可能。
s = pd.Series(np.arange(4), index = ["a", "b", "c", "d"])
s_new = s.reindex(["a", "x", "b", "y"])
#結果
a 0.0
x NaN
b 1.0
y NaN
dtype: float64
"x"と"y"には対応する値が存在しなかったため、NaNとなっている。
s = pd.Series(["a", "b", "c"], index = [0,2,4])
s.reindex(np.arange(5), method = "ffill") #引数methodに"ffill"を代入することで、先頭から値の穴埋めを行っている。
#結果
0 a
2 b
4 c
dtype: object
0 a
1 a
2 b
3 b
4 c
dtype: object
Seriesだけでなく、DataFrameでも同じようなことができる。
reindexメソッドの引数を挙げておく。
index：指定したシーケンスをインデックスラベルとして使用する
columns：指定したシーケンスを列ラベルとして使用する
method：補完と穴埋め。ffillは前方に、bfillは後方に穴埋め。
fill_value：再インデックス付けのときに欠損値の代わりに使う値を指定。
limit：補完、穴埋めの時の制限値を設定
tolerance：補完、穴埋めの際にインデックスの数値にどのくらいの差があるときに穴埋めをするか決める最大値
軸から要素を削除(Series)
dropメソッドを用いると要素の削除が可能。
s = pd.Series(np.arange(5), index = list("abcde"))
s.drop("a")
s.drop(["a", "d"])
#結果
a 0
b 1
c 2
d 3
e 4
dtype: int64
b 1
c 2
d 3
e 4
dtype: int64
b 1
c 2
e 4
dtype: int64
軸から要素を削除(DataFrame)
df = pd.DataFrame(np.arange(16).reshape((4,4)),
index = ["a", "b", "c", "d"],
columns = ["A", "B", "C", "D"])
df.drop("a") #行から要素を削除
df.drop(index = ["b", "c"]) #行から要素を削除
df.drop(columns = ["A", "B"]) #列から要素を削除
#結果
A B C D
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
A B C D
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
A B C D
a 0 1 2 3
d 12 13 14 15
C D
a 2 3
b 6 7
c 10 11
d 14 15
インデックス参照等（Series）
loc、iloc演算子を用いてインデックスを参照する方が好ましいらしい。
locはインデックスのラベルを使って参照を行う。ilocはインデックス位置の要素を取り出す。
s = pd.Series(rng.standard_normal(5), index = list("abcde"))
s.loc["a"]
s.iloc[0] #上のコードと同じ結果
s.loc["a", "d"]
s.iloc[[0,3]] #上のコードと同じ結果
#結果
a -1.423825
b 1.263728
c -0.870662
d -0.259173
e -0.075343
dtype: float64
np.float64(-1.4238250364546312)
np.float64(-1.4238250364546312)
a -1.423825
d -0.259173
dtype: float64
インデックス参照等（DataFrame）
df = pd.DataFrame(rng.standard_normal(16).reshape((4,4)),
index = list("abcd"),
columns = list("ABCD"))
df["B"]
df["A", "D"]
df[:3]
df.loc["a"]
df.iloc[0]
df.loc[["a", "d"]]
df.iloc[[0,3]]
#結果
A B C D
a -1.423825 1.263728 -0.870662 -0.259173
b -0.075343 -0.740885 -1.367793 0.648893
c 0.361058 -1.952863 2.347410 0.968497
d -0.759387 0.902198 -0.466953 -0.060690
a 1.263728
b -0.740885
c -1.952863
d 0.902198
Name: B, dtype: float64
A B
a -1.423825 1.263728
b -0.075343 -0.740885
c 0.361058 -1.952863
d -0.759387 0.902198
A B C D
a -1.423825 1.263728 -0.870662 -0.259173
b -0.075343 -0.740885 -1.367793 0.648893
c 0.361058 -1.952863 2.347410 0.968497
A -1.423825
B 1.263728
C -0.870662
D -0.259173
Name: a, dtype: float64
A B C D
a -1.423825 1.263728 -0.870662 -0.259173
d -0.759387 0.902198 -0.466953 -0.060690
ここでは実行していないが、真偽値に依るインデックス参照も可能。
行と列の参照(loc、iloc)
df.loc["a", ["B"]] #a行B列の要素
df.iloc[0, [1]] #ilocでも同じことができる
df.loc[["a", "c"], ["B", "D"]] #a行とc行、B列とD列の要素
df.iloc[[0, 2], [1, 3]] #ilocでも同じことができる
B 1.263728
Name: a, dtype: float64
B D
a 1.263728 -0.259173
c -1.952863 0.968497
ilocでは真偽値配列は使用できない。ちなみに、重複するインデックスがある場合、重複するものすべてが出力される。
インデックス参照による代入
インデックス参照を用いることで各要素への代入も可能。
df.loc["a"] = 1 #a行のすべての要素に1を代入
df.iloc[0] = 1 #上と同じ。
df.loc["A"] = 1 #A列のすべての要素に1を代入
df.iloc[:, 0] = 1 #上と同じ
df.iloc[df["A"] > 0] = 1 #A列の中の要素で、正である要素が含まれる行すべてに1を代入
df.loc[df["A"] < 0, "B"] = 1 #A列の中の要素で、負である要素が含まれる行のうち、B列の要素に1を代入
#結果
A B C D
a 1.000000 1.000000 1.000000 1.000000
b -0.075343 -0.740885 -1.367793 0.648893
c 0.361058 -1.952863 2.347410 0.968497
d -0.759387 0.902198 -0.466953 -0.060690
A B C D
a 1.0 1.263728 -0.870662 -0.259173
b 1.0 -0.740885 -1.367793 0.648893
c 1.0 -1.952863 2.347410 0.968497
d 1.0 0.902198 -0.466953 -0.060690
A B C D
a -1.423825 1.263728 -0.870662 -0.259173
b -0.075343 -0.740885 -1.367793 0.648893
c 1.000000 1.000000 1.000000 1.000000
d -0.759387 0.902198 -0.466953 -0.060690
A B C D
a -1.423825 1.000000 -0.870662 -0.259173
b -0.075343 1.000000 -1.367793 0.648893
c 0.361058 -1.952863 2.347410 0.968497
d -0.759387 1.000000 -0.466953 -0.060690
言葉で説明すると非常にややこしい。行→列の順に操作を行うようなイメージ。df.loc[df["A"] < 0, "B"] = 1の場合、[]内の左側は、条件に該当する行を探していて、右側で列を探しているような感じ。
Series,DataFrameの算術演算
ndarrayの時と同じく、pandasのSeriesとDataFrameでも算術演算が可能。ただし、Seriesの場合、両方に共通するインデックスを持っている要素同士が計算され、DataFrameの場合、行インデックスと列インデックスの両方が共通する要素同士で計算される。他は欠損値として出力される。（結果を見た方が早い。）また、SeriesとDataFrameの算術演算も可能。
s1 = pd.Series([1, 2, 3, 4], index = list("abcd"))
s2 = pd.Series([4, 5, 6, 7], index = list("bcde"))
s1 + s2
d1 = pd.DataFrame(np.arange(16).reshape((4,4)),
index = list("abcd"),
columns = list("ABCD"))
d2 = pd.DataFrame(np.arange(1,17).reshape((4,4)),
index = list("bcde"),
columns = list("BCDE"))
d1 + d2
#結果
a 1
b 2
c 3
d 4
dtype: int64
b 4
c 5
d 6
e 7
dtype: int64
a NaN
b 6.0
c 8.0
d 10.0
e NaN
dtype: float64
A B C D
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
B C D E
b 1 2 3 4
c 5 6 7 8
d 9 10 11 12
e 13 14 15 16
A B C D E
a NaN NaN NaN NaN NaN
b NaN 6.0 8.0 10.0 NaN
c NaN 14.0 16.0 18.0 NaN
d NaN 22.0 24.0 26.0 NaN
e NaN NaN NaN NaN NaN
どちらの演算でも、両方に共通するb,c,dインデックスの要素のみが計算されていることがわかる。
算術メソッドと穴埋め
pandasは加減乗除、累乗計算のメソッドをサポートしており、引数にfill_valueを設定し、値を代入することで欠損値を穴埋めすることが可能。
df1 = pd.DataFrame(np.arange(0,32,2).reshape((4,4)),
index = list("abcd"),
columns = list("ABCD"))
df2 = pd.DataFrame(np.arange(0,32,2).reshape((4,4)),
index = list("abcd"),
columns = list("ABCD"))
df1.iloc[1:3, 2] = np.nan #欠損値を代入
df1.add(df2, fill_value = 100) #欠損値を100で穴埋めしたうえでdf1にdf2を足す。
df1.sub(df2, fill_value = 0) #欠損値を0で穴埋めしたうえでdf1からdf2を引く。
A B C D
a 0 2 4 6
b 8 10 12 14
c 16 18 20 22
d 24 26 28 30
A B C D
a 0 2 4.0 6
b 8 10 NaN 14
c 16 18 NaN 22
d 24 26 28.0 30
A B C D
a 0 4 8.0 12
b 16 20 112.0 28
c 32 36 120.0 44
d 48 52 56.0 60
A B C D
a 0 0 0 0
b 0 0 0 0
c 0 0 0 0
d 0 0 0 0
関数の適用
Numpyのufuncはpandasでも適用が可能。また、ユーザ定義関数をpandasのSeries、DataFrameに適用することも可能。これにはapplyメソッドを用いる。
df = pd.DataFrame(rng.standard_normal(16).reshape((4,4)),
index = ["Tokyo", "Osaka", "Yokohama", "Nagoya"],
columns = list("abcd"))
def f(x):
return x.max() -x.min() #最大値から最小値を引く関数を定義。
df.apply(f) #dfに関数fを適用。
df.apply(f,axis = "columns") #軸を行に設定したうえで関数を適用。
#結果
a b c d
Tokyo -1.423825 1.263728 -0.870662 -0.259173
Osaka -0.075343 -0.740885 -1.367793 0.648893
Yokohama 0.361058 -1.952863 2.347410 0.968497
Nagoya -0.759387 0.902198 -0.466953 -0.060690
a 1.784883
b 3.216592
c 3.715202
d 1.227670
dtype: float64
Tokyo 2.687553
Osaka 2.016686
Yokohama 4.300273
Nagoya 1.661585
dtype: float64
ソート
pandasのSeriesとDataFrameはソート機能を持つ。sort_index()はインデックスを基準に、sort_values()は値を基準にソートを行う。ただし、sort_valuesは一つ以上の「列」を指定することでソートが行われる。（行はできなかった）また、引数にascendingを設定し、Falseにすると降順になる。デフォルトは昇順。
df = pd.DataFrame(rng.standard_normal(16).reshape((4,4)),
index = list("badc"),
columns = list("ACDB"))
df.sort_index() #引数を指定しない場合は行ごとにソートする
df.sort_index(axis = "columns") #列ごとのソート
df.sort_values("B")
#結果
A C D B
b -0.006827 1.046143 0.741588 0.723957
a 1.618776 -1.205558 -0.626955 -1.320663
d -0.107753 0.998764 -0.021948 0.495880
c -1.910769 0.147064 -0.906943 1.775389
A C D B
a 1.618776 -1.205558 -0.626955 -1.320663
b -0.006827 1.046143 0.741588 0.723957
c -1.910769 0.147064 -0.906943 1.775389
d -0.107753 0.998764 -0.021948 0.495880
A B C D
b -0.006827 0.723957 1.046143 0.741588
a 1.618776 -1.320663 -1.205558 -0.626955
d -0.107753 0.495880 0.998764 -0.021948
c -1.910769 1.775389 0.147064 -0.906943
A C D B
a 1.618776 -1.205558 -0.626955 -1.320663
d -0.107753 0.998764 -0.021948 0.495880
b -0.006827 1.046143 0.741588 0.723957
c -1.910769 0.147064 -0.906943 1.775389
集約、記述統計量
pandasには記述統計量計算のメソッドと集約メソッドがある。
df = pd.DataFrame(rng.standard_normal(25).reshape((5,5)),
index = list("abcde"),
columns = list("ABCDE"))
df.sum() #デフォルトは行が軸
df.sum(axis = "columns") #列を軸にして計算
df.describe() #記述統計量を計算し、一気に表示
#結果
A B C D E
a 0.486381 -0.477392 0.669340 -1.387295 1.665888
b -0.190932 0.534349 0.776552 0.244750 0.179810
c -1.341585 -0.181981 -0.542161 0.001980 -2.699809
d -1.557226 -0.292793 0.259063 -0.201089 -1.101499
e -0.592834 -0.429007 -3.057709 -0.786701 -0.761773
A -3.196195
B -0.846824
C -1.894915
D -2.128355
E -2.717382
dtype: float64
a 0.956923
b 1.544530
c -4.763556
d -2.893543
e -5.628024
dtype: float64
A B C D E
count 5.000000 5.000000 5.000000 5.000000 5.000000
mean -0.639239 -0.169365 -0.378983 -0.425671 -0.543476
std 0.837577 0.410153 1.584577 0.659138 1.613478
min -1.557226 -0.477392 -3.057709 -1.387295 -2.699809
25% -1.341585 -0.429007 -0.542161 -0.786701 -1.101499
50% -0.592834 -0.292793 0.259063 -0.201089 -0.761773
75% -0.190932 -0.181981 0.669340 0.001980 0.179810
max 0.486381 0.534349 0.776552 0.244750 1.665888
正直、describe()で色々教えてくれるから他のメソッドは割愛し、その都度振り返ることにする。
相関と共分散
corrメソッドによって相関係数が求められ、covメソッドによって共分散が求められる。また、corrwith()によって特定の変数とその他の変数同士の相関係数を計算してくれる。
メモ：corrはcorrelation、covはcovarianceを略してる。
price = pd.read_pickle("examples/yahoo_price.pkl") #pickleファイルを読み込む
volume = pd.read_pickle("examples/yahoo_volume.pkl")
returns = price.pct_change() #パーセンテージの変化を求める
returns.head() #先頭5つを表示
retruns["AAPL"].corr(returns["MSFT"])
returns.corr() #勝手にすべての変数同士の相関係数を計算してくれる。
returns.corrwith(returns["AAPL"]) #AAPLとその他の変数同士の相関係数を計算。
#結果
AAPL GOOG IBM MSFT
Date
2010-01-04 NaN NaN NaN NaN
2010-01-05 0.001729 -0.004404 -0.012080 0.000323
2010-01-06 -0.015906 -0.025209 -0.006496 -0.006137
2010-01-07 -0.001849 -0.023280 -0.003462 -0.010400
2010-01-08 0.006648 0.013331 0.010035 0.006897
np.float64(0.38969458628057846)
AAPL GOOG IBM MSFT
AAPL 1.000000 0.407919 0.386817 0.389695
GOOG 0.407919 1.000000 0.405099 0.465919
IBM 0.386817 0.405099 1.000000 0.499764
MSFT 0.389695 0.465919 0.499764 1.000000
AAPL 1.000000
GOOG 0.407919
IBM 0.386817
MSFT 0.389695
dtype: float64
欠損値は除外して計算してくれるのはありがたい。今日はここまで。
ここで注意しなくてはいけないのが、データの読み込み。Pythonが参照しているディレクトリ内に渡したいファイルがないと、エラーが発生する。なので、Pythonが参照するディレクトリを変更するか、参照しているディレクトリにファイルを移す必要がある。
おわりに
今回、np.rng~~という疑似乱数生成メソッドを多用しましたが、都度に定義し、seed値を変えたりしております。（固定された結果を得るため。）
今回はpandasについて見ていきました。前回も書きましたが、すごく分かりやすい。（簡単な内容であるのもあると思うが）pandasの基本的な使い方は理解できた感じがします。手を動かしてアウトプットを大切にしていきたいと思います。。
参考書籍