pd.read_csv でデータを読み込んだ時の列の型

自分が主催をしている Pandas 勉強会で read_csv について学んだことの一部をここに記載します。結論を言ってしまうと、 csv を受け取る時は列の型を聞いておく必要があるよねという話です。最後に、勉強会で、 pd.read_csv の引数である keep_date_col についても勉強したのでそれも記載します。

本題に入る前に ー テキストを csv ファイル形式で扱う方法

本題に入る前にテキストを csv ファイル形式で扱う方法について記載します。これは Pandas ではなく標準 Python のモジュールの話です。csv ファイルの読み込みの練習をする時には、ソースコード上に直接記載されている csv を仮想的にファイルとして扱えるようにできると便利です。以下のように io モジュールを使用するとメモリ上のデータをあたかもファイル上のデータであるかのように扱うことができます。(ただし、全く同じではありませんので注意してください)

import pandas as pd
import io

t = '''col1,col2,col3,col4,col5,col6
2019,10/1,1,2,3,NA
2020,11/1,,6,7,A
2021,12/1,9,10,11,X'''

f = io.StringIO(t)
print(f.read())
col1,col2,col3,col4,col5,col6
2019,10/1,1,2,3,NA
2020,11/1,,6,7,A
2021,12/1,9,10,11,X

Pandas で csv ファイルを読みこむ方法

ここから本題ですが、Pandas で csv ファイルを読みこむ方法は以下になります。pd.read_csv 関数でファイルを読み込みます。 変数 f は io.StringIO で作成したファイルオブジェクトのようなものです。

f = io.StringIO(t)
df = pd.read_csv(f)
print(df)
   col1  col2  col3  col4  col5 col6
0  2019  10/1   1.0     2     3  NaN
1  2020  11/1   NaN     6     7    A
2  2021  12/1   9.0    10    11    X

読み込んだ列の型(dtype)について

print 関数で df を 表示しました。ここで気になるのは、例えば 1列目が文字列なのか日付型なのか、はたまた整数型なのかということです。これを調べるために以下を実行します。 DataFrame の applymap メソッドを使用し全ての要素に type 関数を適用して型を調べています。

# 全ての要素の型を調べる
df.applymap(lambda x: type(x))
col1 col2 col3 col4 col5 col6
0 <class 'int'> <class 'str'> <class 'float'> <class 'int'> <class 'int'> <class 'float'>
1 <class 'int'> <class 'str'> <class 'float'> <class 'int'> <class 'int'> <class 'str'>
2 <class 'int'> <class 'str'> <class 'float'> <class 'int'> <class 'int'> <class 'str'>

実行結果を見ると、 col1 の先頭行の要素は 2019 となっており整数型になっていることがわかります。 col3 の要素は整数かと思いきや 浮動少数点型になっています(未入力の要素がありそれが NaN (浮動小数点型)になるため、その列の他の要素もそれになっているのかもしれません)。このように、 pd.read_csv 関数をデフォルトの状態で使用してデータを読み込んだ場合、想定する型と違うことになっていることがあるかもしれないということに注意が必要です。これは、csv は型の情報を含まないデータフォーマットであるためです。csv をちゃんと処理したい場合は、列の型の情報は知っていなければならないということです。csv のデータを他の人から受け取る時には列の型について聞いておくようにします。これは Pandas や Python に関係のない話です。

keep_date_col について

ここからの話は、おまけです。

勉強会では教科書(Python for Data Analysis)に記載されている引数について一つづつ確認して行ったのですが、ここでは、他の人が記事あまりにしていないもの keep_date_col について紹介しようと思います(需要はあまりないと思いますが)。以下のように parse_dates 引数と一緒に使用します(parse_dates引数に2次元リストを渡していることに注目)。 parse_dates 引数に2次元リストを渡すことで、日付列の集合を併合できます。この時、併合前の列を消す(デフォルトの動作)か保持するかを keep_date_col 引数で決めることができます。

keep_date_col=False (デフォルト)の時

f = io.StringIO(t)
df = pd.read_csv(f, parse_dates=[[0, 1]], keep_date_col=False)
df
col1_col2 col3 col4 col5 col6
0 2019-10-01 1.0 2 3 NaN
1 2020-11-01 NaN 6 7 A
2 2021-12-01 9.0 10 11 X

まず、 keep_date_col=False (デフォルト)の場合 parse_dates 引数で指定した列番号が日付パーサーで一つの列として併合されます。 parse_dates 引数で指定する列は複数列を指定する時は2次元配列として指定することに注意してください。

keep_date_col=True の時

f = io.StringIO(t)
df = pd.read_csv(f, parse_dates=[[0, 1]], keep_date_col=True)
df
col1_col2 col1 col2 col3 col4 col5 col6
0 2019-10-01 2019 10/1 1.0 2 3 NaN
1 2020-11-01 2020 11/1 NaN 6 7 A
2 2021-12-01 2021 12/1 9.0 10 11 X

keep_date_col=True の時は併合前の日付列が保持されていることがわかります。

date_parser で複数の列の集合を併合する

parse_dates 引数で指定する列は複数列を指定する時は2次元配列を指定するのでした。これは以下のように複数の列の集合を併合できるようしているからです。

まずテーブルを定義して、普通に読み込んだものを表示します。

t = '''col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11,co12
2019,10/1,1.0,2,3,,2019,1/1,1.0,2,3,
2020,11/1,,6,7,A,2020,2/1,,6,7,A
2021,12/1,9.0,10,11,X,2021,3/1,9.0,10,11,X
'''

f = io.StringIO(t)
df = pd.read_csv(f)
df
col1 col2 col3 col4 col5 col6 col7 col8 col9 col10 col11 co12
0 2019 10/1 1.0 2 3 NaN 2019 1/1 1.0 2 3 NaN
1 2020 11/1 NaN 6 7 A 2020 2/1 NaN 6 7 A
2 2021 12/1 9.0 10 11 X 2021 3/1 9.0 10 11 X

次に、 parse_dates で複数の列の集合を指定してみます。

f = io.StringIO(t)
df = pd.read_csv(f, parse_dates=[[0, 1], [6, 7]], keep_date_col=False)
df
col1_col2 col7_col8 col3 col4 col5 col6 col9 col10 col11 co12
0 2019-10-01 2019-01-01 1.0 2 3 NaN 1.0 2 3 NaN
1 2020-11-01 2020-02-01 NaN 6 7 A NaN 6 7 A
2 2021-12-01 2021-03-01 9.0 10 11 X 9.0 10 11 X

parse_dates 引数で指定した列の集合それぞれに対して併合が行われていることがわかります。

以上です。おやすみなさい。

Pandas の Series オブジェクトと DataFrame オブジェクト の四則演算(足し算)した時の挙動についていろいろ試してみた

Pandas の Series オブジェクトと DataFrame オブジェクト の四則演算(足算)の挙動を調べてみました。結果、 Series オブジェクト の index のラベルと DataFrame オブジェクト の columns のラベルがマッチする時、計算が行われることがわかりました。また計算は numpy 風に行われることがわかりました。説明が難しいため、コードだけ貼り付けておきます。

import pandas as pd
import numpy as np

np.random.seed(777)
s_data  = np.random.randint(0,5,5)
s_index = list('ABCDE')
s = pd.Series(s_data, index=s_index)

s
# In [243]: s
# Out[243]: 
# A    3
# B    1
# C    4
# D    1
# E    2
# dtype: int64

d_data  = np.random.randint(0,10,(3, 5))
d_columns = list('ABCDE')
d = pd.DataFrame(d_data, columns=d_columns)

d
# In [244]: d
# Out[244]: 
#    A  B  C  D  E
# 0  8  7  2  0  1
# 1  2  4  5  7  1
# 2  7  2  2  7  4

s + d
# In [245]: s + d
# Out[249]: 
#     A  B  C  D  E
# 0  11  8  6  1  3
# 1   5  5  9  8  3
# 2  10  3  6  8  6

d + s
# In [250]: d + s
# Out[251]: 
#     A  B  C  D  E
# 0  11  8  6  1  3
# 1   5  5  9  8  3
# 2  10  3  6  8  6

# s の index を並べ替えたものを s2 とする
s_index = np.random.choice(s.index.values, replace=False, size=5)
s2 = s.reindex(s_index)

s2
# In [439]: s2
# Out[439]: 
# B    1
# E    2
# D    1
# C    4
# A    3

s + s2
# In [440]: s + s2
# Out[445]: 
# A    6
# B    2
# C    8
# D    2
# E    4

s2 + d
# In [446]: s2 + d
# Out[452]: 
#     A  B  C  D  E
# 0  11  8  6  1  3
# 1   5  5  9  8  3
# 2  10  3  6  8  6

s_data  = np.concatenate(([-100], s2.values, [100]))
s_index = np.concatenate((['X'] , s2.index , ['Y']))
s3 = pd.Series(s_data, s_index)

s3
# In [495]: s3
# Out[495]: 
# X   -100
# B      1
# E      2
# D      1
# C      4
# A      3
# Y    100

s + s3
# In [496]: s + s3
# Out[505]: 
# A    6.0
# B    2.0
# C    8.0
# D    2.0
# E    4.0
# X    NaN
# Y    NaN


d + s3
# In [506]: d + s3
# Out[514]: 
#     A  B  C  D  E   X   Y
# 0  11  8  6  1  3 NaN NaN
# 1   5  5  9  8  3 NaN NaN
# 2  10  3  6  8  6 NaN NaN

# 上記の ABCDE列 については計算されていることを確認
(d + s3).loc[:, list('ABCDE')] == d + s2
# In [590]: (d + s3).loc[:, list('ABCDE')] == d + s2
# Out[612]: 
#       A     B     C     D     E
# 0  True  True  True  True  True
# 1  True  True  True  True  True
# 2  True  True  True  True  True

#########################################################################
# A,B,C,D,E の列は共通のラベルなので NaN にはならないが、 X,Y は共通で
# はないので NaN になる。以下のように共通のラベルがない時は全て NaN に
# なる。
#########################################################################

s_data  = np.random.randint(0,5,5)
s_index = list('PQRST')
s4 = pd.Series(s_data, index=s_index)

s4
# In [581]: s4
# Out[583]: 
# P    4
# Q    0
# R    0
# S    0
# T    3

s + s4
# In [584]: s + s4
# Out[586]: 
# A   NaN
# B   NaN
# C   NaN
# D   NaN
# E   NaN
# P   NaN
# Q   NaN
# R   NaN
# S   NaN
# T   NaN

d + s4
# In [587]: d + s4
# Out[589]: 
#     A   B   C   D   E   P   Q   R   S   T
# 0 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
# 1 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
# 2 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN

# 行ラベルのみに Series の index と同じ ラベルがあった場合
d.T
# In [621]: d.T
# Out[621]: 
#    0  1  2
# A  8  2  7
# B  7  4  2
# C  2  5  2
# D  0  7  7
# E  1  1  4

d.T.index
# In [622]: d.T.index
# Out[631]: Index(['A', 'B', 'C', 'D', 'E'], dtype='object')

d.T.columns
# In [632]: d.T.columns
# Out[635]: RangeIndex(start=0, stop=3, step=1)

d + s
# In [649]: d + s
# Out[649]: 
#     A  B  C  D  E
# 0  11  8  6  1  3
# 1   5  5  9  8  3
# 2  10  3  6  8  6

d.T + s
# In [650]: d.T + s
# Out[652]: 
#     0   1   2   A   B   C   D   E
# A NaN NaN NaN NaN NaN NaN NaN NaN
# B NaN NaN NaN NaN NaN NaN NaN NaN
# C NaN NaN NaN NaN NaN NaN NaN NaN
# D NaN NaN NaN NaN NaN NaN NaN NaN
# E NaN NaN NaN NaN NaN NaN NaN NaN

# 上記よりデフォルトでは常に DataFrame の列ラベルに対してマッチングが行われることがわかる

####################################################################
# おまけ(1)
# DataFrame オブジェクト の columns ではなく、 index にマッチして計算
# して欲しい場合は、 メソッドを使用し引数に axis='index' を指定すると
# できる
####################################################################

d.T.add(s, axis='index')
# In [745]: d.T.add(s, axis='index')
# Out[746]: 
#     0  1   2
# A  11  5  10
# B   8  5   3
# C   6  9   6
# D   1  8   8
# E   3  3   6

d.T.add(s, axis='index').T == d + s
# In [776]: d.T.add(s, axis='index').T == d + s
# Out[781]: 
#       A     B     C     D     E
# 0  True  True  True  True  True
# 1  True  True  True  True  True
# 2  True  True  True  True  True

####################################################################
# おまけ(2)
# index などを無視して、何がなんでも足したい場合は、 values に対して計
# 算を行う(この場合 numpy の計算なので、 numpy broadcastng rule が適用
# 可能な形状にかぎる))
####################################################################

s4
# In [782]: s4
# Out[814]: 
# P    4
# Q    0
# R    0
# S    0
# T    3

d
# In [815]: d
# Out[823]: 
#    A  B  C  D  E
# 0  8  7  2  0  1
# 1  2  4  5  7  1
# 2  7  2  2  7  4

dd = d.copy()
dd.loc[:,:] = dd.values + s4.values
# In [931]: dd
# Out[931]: 
#     A  B  C  D  E
# 0  12  7  2  0  4
# 1   6  4  5  7  4
# 2  11  2  2  7  7

共通ラベルにない値は 「NaN + 値」 で 「NaN」になってしまうが、 「NaN + 値」を 「0 + 値」、 「NaN + NaN」 を 「0 + 0」 のように計算して欲しい場合は、以下のように fill_value 引数を使用する。(ただし、DataFrame と Series 同士の演算で fill_value を使用するとエラーになってしまったので注意)

s
# In [243]: s
# Out[243]: 
# A    3
# B    1
# C    4
# D    1
# E    2
# dtype: int64

s3
# In [495]: s3
# Out[495]: 
# X   -100
# B      1
# E      2
# D      1
# C      4
# A      3
# Y    100

s + s3
# In [496]: s + s3
# Out[505]: 
# A    6.0
# B    2.0
# C    8.0
# D    2.0
# E    4.0
# X    NaN
# Y    NaN

s.add(s3, fill_value=0)
# In [938]: s.add(s3, fill_value=0)
# Out[971]: 
# A      6.0
# B      2.0
# C      8.0
# D      2.0
# E      4.0
# X   -100.0
# Y    100.0


d + s3
# In [506]: d + s3
# Out[514]: 
#     A  B  C  D  E   X   Y
# 0  11  8  6  1  3 NaN NaN
# 1   5  5  9  8  3 NaN NaN
# 2  10  3  6  8  6 NaN NaN

d.add(s3, fill_value=0.0)
# NotImplementedError: fill_value 0.0 not supported.
# 上のようにDataFrame と Series で fill_value 引数を指定するとエラーになる
# パッと思いつたところでは以下のようにかけば実現できるのではないかと思います
d.reindex(columns=s3.index).fillna(0) + s3.fillna(0)

# ただこれだと、元々持っていた d の列が消えてしまうのでそれを保持するには
# 以下のようにするとできるのではないかと思います
dd = d.reindex(columns=d.columns|s3.index)
dd.loc[:, s3.index] = d.reindex(columns=s3.index).fillna(0) + s3.fillna(0)

以上です。おやすみなさい。

Pandas の obj[i] と obj.loc[i] などの違いについて

Pandas の Series オブジェクトの話になります。 Series オブジェクトを obj とした時、 obj[i] と obj.loc[i] と obj.iloc[i] の違い、さらに obj[s:e] のようにスライスした時の動作の違いを理解するために、コードを書き実行して動作を確かめました。確認のためのコードは以下になります。Series オブジェクトの index が整数のみからなるか否かで、 obj[i] の振る舞いが変わるのには注意が必要だと思いました。コードの説明はコメントとして記載しました。

############################################################################
# index が整数型 Seires の場合(index の値が整数のみからなる Series の場合)
############################################################################
import pandas as pd

s1 = pd.Series([15,20,25,30,40], index=[3,4,5,6,7])
s2 = pd.Series([15,20,25,30,40])

# (1) s1[-1] を取得する
s1[-1]
# KeyError: -1

# (2) s2[-1] を取得する
s2[-1]
# KeyError: -1

# 上記よりindex が整数のみからなる場合は、obj[i] の i はラベルのように認
# 識されることがわかる。
# ただし、スライスの場合は obj[s:e] の s, e はインデックスとして扱われる

# (3) s1[3:5] を取得する
s1[3:5]
# 6    30
# 7    40
# dtype: int64

# (4) s1.loc[-1] を取得する
s1.loc[-1]
# KeyError: 'the label [-1] is not in the [index]'

# (5) s1.loc[3:5] で loc にスライスを使用して取得する
s1.loc[3:5]
# 3    15
# 4    20
# 5    25
# dtype: int64

# (6) s1.iloc[-1] を使った場合
s1.iloc[-1]
# 40

# (7) s1.iloc[3:5] で iloc にスライスを使用して取得する
s1.iloc[3:5]
# 6    30
# 7    40
# dtype: int64

################################################################
# index がオブジェクト型の  Series の場合
################################################################

s3 = pd.Series([15,20,25,30,40], index=[3,4,5,6,'X'])

# (8) s3[-1] を取得する
s3[-1]
# 40

# (9) s3[3] を取得する
s3[3]
# 15

# index がオブジェクト型の場合は、 obj[i] はインデックスとして扱われる
# loc, iloc, スライス を使用した際の挙動は (3)(4)(5)(6)(7) と同様になると思われる(未確認)

################################################################
# index が重複している時の Series の場合
################################################################

# インデックスが重複しているとき
s4 = pd.Series([10, 100, 1000, 10000], index=['a', 'a', 'b', 'b'])
s5 = pd.Series([200, 2000], index=['a', 'b'])
s6 = pd.Series([200, 200], index=['a', 'a'])

# (10) 値を取得する
s4['a']
# a     10
# a    100
# dtype: int64

# (11) 値を取得する
s4[['a','b']]
# a       10
# a      100
# b     1000
# b    10000
# dtype: int64

# (12) 重複していないインデックスを重複するように reindex する
s5.reindex(s4.index)
# a     200
# a     200
# b    2000
# b    2000
# dtype: int64

# (13) インデックスが重複しているとき reindex する
s6.reindex(['x', 'y'])
# ValueError: cannot reindex from a duplicate axis

以上です。

三面体のサイコロを2000回投げたとき、それぞれの面の出る回数の分布

1. はじめに

(注意:一般的に三面体のサイコロというものは現実には存在しません。説明の便宜上、3つの面をもつ空想のサイコロのことを三面体のサイコロと表現しています)
Pandas 勉強会で、サンプルの状態が割とよく発生することなのか、稀にしか発生しないことなのかを知りたいと言う話がありました。それに関連するような、確率の問題を自分で作って、シミュレーションを行いました。結果、仮定がデータと紐づいているのであれば、割とよく発生することなのか、稀にしか発生しないことなのかがわかることがわかりました。一方で仮定がデータと紐づかないのであれば、仮定に基づいて議論を進めたところであまり意味のない議論になってしまうこともわかりました。

2. 問題

以下のように問題を定義しました。

2000個のサンプルがあったとして、 3つの領域 A, B, C の内どれかに分類されるとした時、観測したそのサンプルが領域 A に分類された個数、 B に分類された個数、 C に分類された個数の状態が、割とよくおこるものなのか、そうでないのか知りたい。

3. 問題を解くための仮定

まず、Aに分類されるか、B または C に分類されるかは一定の確率で決まることとします。議論を進めるため、その確率を以下のように定義します。

A の出る確率: 1/3
B の出る確率: 1/3
C の出る確率: 1/3

これは、簡単に言えば三面体のサイコロのそれぞれの面がでる確率と同じです。サイコロの方が直感的にイメージしやすいため、問題を3面体のサイコロをを2000回投げた時、それぞれの面のでる回数の分布を求める問題に置き換えます。A に分類されるか、B または C に分類されるかの確率が決まっていますので、この確率を前提として、シミュレーションを行います。

4. シミュレーションを行うコード

シミュレーションを行うコードは以下になります。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import scipy.stats

# 1. 
samples = np.random.choice(['A', 'B', 'C'], p=[1/3, 1/3, 1/3], size=(10000, 2000))
# 2.
df = pd.DataFrame(samples)
# 3.
df = df.T.apply(lambda x: x.value_counts())
# 4.
plt.hist(df.loc['A', :], bins=50)
plt.show()

# 5.
mean = df.loc['A', :].mean()
sigma = df.loc['A', :].std()
print('平均:{}回\n標準偏差:{}'.format(mean, sigma))

# 6.
n, bins, patches = plt.hist(df.loc['A', :], bins=50, density=True) 
# 7.
y = scipy.stats.norm.pdf(loc=mean, scale=sigma, x=bins)
plt.plot(bins, y)
plt.show()

# 8.
print("'A'のでる回数xは...")
print("68% は {:.0f} < x < {:.0f}となる".format(mean - sigma, mean + sigma))
print("95% は {:.0f} < x < {:.0f}となる".format(mean - 2*sigma, mean + 2*sigma))
print("99.7% は{:.0f} < x < {:.0f}となる".format(mean - 3*sigma, mean + 3*sigma))

5. コードの説明

コードの説明は以下の通りです。

1. まず、 `np.random.choice` 関数で 'A', 'B', 'C' をそれぞれ 1/3 の確率で 2000個 出現する配列を作成します。 第2引数は第1引数で指定したリストの要素が出現する確率を指定しています 。今回はさらに、 それを10000回行ったこととし、 size 引数に (10000, 2000) を渡すことで 10000行 の行列を作成します。
2. 次に 1. で作成した numpy配列を DataFrame に変換します。
3. df を転置させたものの全ての列に対して、 `Series.value_counts` メソッドを適用します。
4. 3. で求めたものをヒストグラムで可視化します。形状が正規分布となっていることがわかります。
5. 平均と標準偏差を求めます。
6. `scipy.stats.norm.pdf` 関数のパラメータに先ほどの平均と標準偏差と 3. で表示したヒストグラムのバーのx座標の値を渡し、その母数での正規分布のx座標に対するy座標の値を得ます。
7. 3. で表示したヒストグラムを面積が1となるように正規化したグラフと、6. で求めた正規分布のグラフを重ねて表示します。
8. 正規分布の性質(平均値から±標準偏差の3倍までの面積は 0.997 、2倍までの面積は 0.95 、1倍までの面積は 0.68) から、範囲に対する確率を求め、表示します。

6. 出力結果

出力結果は以下になります。

平均:666.8196回
標準偏差:21.023074294814155
'A'のでる回数xは...
68% は 646 < x < 688となる
95% は 625 < x < 709となる
99.7% は604 < x < 730となる

f:id:keimina:20191005012451p:plain
ヒストグラム1

f:id:keimina:20191005012533p:plain
ヒストグラム1(正規化済)&正規分布

7. 考察・まとめ

問題を定義し、仮定を定義しました。三面体のサイコロ投げで面が出る回数について10000回シミュレーションを行い、その確率の分布を求めました。サイコロの目が出る回数を数えたら結局は正規分布になりました。今回行ったシミュレーションから 99.7% の割合で 'A' が出現する回数xは 604 < x < 730 の範囲となると推測しました。 この範囲外にあった場合、それは割とよく発生するものでない(異常な状態)ということがわかります。ただし、この推測が役に立つのは、あくまで仮定が成立する時の話で、この仮定とデータが何ら紐づかない場合は実際あまり意味のない議論になります。しかし、データと仮定が紐づかない場合でも、このような条件が議論する上で重要であるということがわかっているのであれば、何の指標も方向性も定まっていない状態より良いのではないかと思います。

以上です。

Pandas の DataFrame をエクセルで開く自作関数

表データを可視化したい時、まずエクセルで生のデータを表示したい時があります。これは具体的には「Pandas の DataFrame を Excel で保存し、それを開く」という作業です。この作業を自動化したら、便利だったので、ここに紹介します。

1. 動作環境

OS MacOS Mojave
Python Anaconda 1.6.14 (Python 3.6)

※少なくとも pandas と xlwings が必要です。

2. 作成した関数

def show_excel(df, out_filename='tmp.xlsx'):
    '''
    Parameters
    ----------
        df:
            DataFrame to show

        out_filename:
            Filename of the DataFrame(optional) default 'tmp.xlsx'
    
    Returns:
        None
    '''
    df.to_excel(out_filename)
    app = xw.App(visible=None, add_book=True)
    wb = xw.books.open(out_filename)
    wb.activate(steal_focus=True)

3. 作成した関数の説明

以下を行う関数です。

1. 引数で指定した DataFrame をカレントディレクトリに tmp.xlsx として保存

2. tmp.xlsx を開いて、最前面に持ってくる

4. 実行方法

import pandas as pd
import numpy as np
import xlwings as xw

df = pd.DataFrame(np.arange(15).reshape(5, 3), columns=['x', 'y', 'z'])
show_excel(df)

# エクセルのプロセスを全て終了(kill) する
# [app.quit() for app in xw.apps]

5. 実行結果

実行すると、 エクセルが起動し df の内容が表示されます。

f:id:keimina:20190922105956p:plain
実行結果

6. 注意事項

  • デフォルトでカレントディレクトリの 'tmp.xlsx' が上書き保存されますので注意してください

  • エクセルの新しいプロセスが起動します
  • 起動したエクセルを終了する場合は、プロセスを終了(kill)してください(実行方法は使用方法の一番下のコメントに記載)


以上です。

(勉強会用資料)Python Pandas もくもく勉強会 in 新潟 #3

1. はじめに

新潟で Python Pandas もくもく勉強会 というものを主催しています。本記事はその 2019/08/21 に行われる勉強会で私が行う 5分LT の資料です。1週間くらい Pandas を使ってみて、記憶に残っているものをまとめました。

connpass.com

2019/08/21 の Pandas 勉強会用
updated: <2019-08-20 Tue>

Pandas 覚えたことまとめ

2. import 文

import pandas as pd
import numpy as np

3. 出現頻度のカウント

data = ['YES', 'YES', 'NO', 'NO', '-']
s = pd.Series(data)
# series の value_counts メソッドを使用する
s.value_counts()

# NO     2
# YES    2
# -      1
# dtype: int64

# DataFrame の場合
data = ['YES', 'YES', 'NO', 'NO', '-']
data2 = ['A', 'A', 'A', 'B', 'C']
s2 = pd.Series(data2)
df = pd.concat([s, s2], axis=1)
# df に value_counts メソッドは存在しない
# df の列全体に value_counts を適用するときは apply を使用するとできる
df.apply(lambda s: s.value_counts())

#        0    1
# -    1.0  NaN
# A    NaN  3.0
# B    NaN  1.0
# C    NaN  1.0
# NO   2.0  NaN
# YES  2.0  NaN

4. Excel あるある

4.1. 作者の主観により特定の行がデータの区切りとなっていると思われるエクセルをどうにかする

data = ['・赤い果物', 'いちご', 'りんご', '・緑色の果物', 'キウイ', 'メロン', '・紫色の果物', 'ぶどう']
s = pd.Series(data)
s

# 0     ・赤い果物
# 1       いちご
# 2       りんご
# 3    ・緑色の果物
# 4       キウイ
# 5       メロン
# 6    ・紫色の果物
# 7       ぶどう
# dtype: object

# DataFrame に変換(あとで pd.merged で結合できるようにするため)
df = s.to_frame()

# '・赤い果物', '・緑色の果物', '・紫色の果物' に共通の'・'を含む行を抽出、name属性を設定しておく
s2 = s[s.map(lambda x: '・' in x)]
s2.name = '種類'
s2

# 0     ・赤い果物
# 3    ・緑色の果物
# 6    ・紫色の果物
# Name: 種類, dtype: object

# DataFrame に変換(あとで pd.merged で結合できるようにするため)
df2 = s2.to_frame()

# インデックスをキーとして結合
df3 = pd.merge(df2, df, left_index=True, right_index=True, how='outer')
df3

#        種類       0
# 0   ・赤い果物   ・赤い果物
# 1     NaN     いちご
# 2     NaN     りんご
# 3  ・緑色の果物  ・緑色の果物
# 4     NaN     キウイ
# 5     NaN     メロン
# 6  ・紫色の果物  ・紫色の果物
# 7     NaN     ぶどう

# 「種類」列の NaN を 埋める
df3['種類'].fillna(method='ffill', inplace=True)
df3

#        種類       0
# 0   ・赤い果物   ・赤い果物
# 1   ・赤い果物     いちご
# 2   ・赤い果物     りんご
# 3  ・緑色の果物  ・緑色の果物
# 4  ・緑色の果物     キウイ
# 5  ・緑色の果物     メロン
# 6  ・紫色の果物  ・紫色の果物
# 7  ・紫色の果物     ぶどう

# df3 から s2 のインデックスの行を削除する
df3.drop(index=s2.index, inplace=True)
df3

#        種類    0
# 1   ・赤い果物  いちご
# 2   ・赤い果物  りんご
# 4  ・緑色の果物  キウイ
# 5  ・緑色の果物  メロン
# 7  ・紫色の果物  ぶどう

(勉強会用資料)Python Pandas もくもく勉強会 in 新潟 #2

1. はじめに

新潟で Python Pandas もくもく勉強会 というものを主催しています。本記事はその 2019/08/04 に行われる勉強会で私が行う 5分LT の資料です。(資料置き場がないのでブログを活用しています)。1週間くらい Pandas を使ってみて、記憶に残っているものをまとめました。

connpass.com

2. import 文

import pandas as pd

3. Series または DataFrame の index を1始まりにする方法

3.1. Series の場合

3.1.1. 使用するデータ
data = ['a', 'b', 'c']
s = pd.Series(data)
s
#################
# In [392]: s   #
# Out[392]:     #
# 0    a        #
# 1    b        #
# 2    c        #
# dtype: object #
#################
3.1.2. 方法
'''index を指定しない場合、自動で 0 始まりのインデックスとなるので単に +1 すればよい'''
s.index += 1
s
#################
# In [89]: s    #
# Out[89]:      #
# 1    a        #
# 2    b        #
# 3    c        #
# dtype: object #
#################

3.2. DataFrame の場合

3.2.1. 使用するデータ
data = [['a', 'b', 'c'],
        ['d', 'e', 'f'],
        ['g', 'h', 'i']]
df = pd.DataFrame(data)
df
################
# In [397]: df #
# Out[398]:    #
#    0  1  2   #
# 0  a  b  c   #
# 1  d  e  f   #
# 2  g  h  i   #
################
3.2.2. 方法
'''(Series と同じ)index を指定しない場合、自動で 0 始まりのインデックスとなるので単に +1 すればよい'''
df.index += 1
df
################
# In [189]: df #
# Out[189]:    #
#    0  1  2   #
# 1  a  b  c   #
# 2  d  e  f   #
# 3  g  h  i   #
################

4. Series または DataFrame を比較して一致する行を探す

4.1. Series の場合

4.1.1. 使用するデータ
data = ['a', 'b', 'c']
data2 = ['a', 'x', 'c']
s = pd.Series(data)
s2 = pd.Series(data2)
s
s2
#################
# In [128]: s   #
# Out[128]:     #
# 0    a        #
# 1    b        #
# 2    c        #
# dtype: object #
#               #
# In [129]: s2  #
# Out[129]:     #
# 0    a        #
# 1    x        #
# 2    c        #
# dtype: object #
#################
4.1.2. 比較を行う
s3 = s==s2
s3
#################
# In [130]: s3  #
# Out[130]:     #
# 0     True    #
# 1    False    #
# 2     True    #
# dtype: bool   #
#################
4.1.3. フィルタリング
s4 = s[s3]
s4
################
# In [380]: s4 #
# Out[380]:    #
# 0    a       #
# 2    c       #
################

4.2. DataFrame の場合

4.2.1. 使用するデータ
data = [['a', 'b', 'c'],
        ['d', 'e', 'f'],
        ['g', 'h', 'i']]

data2 = [['a', 'b', 'c'],
         ['d', 'x', 'f'],
         ['g', 'h', 'i']]

df = pd.DataFrame(data)
df2 = pd.DataFrame(data2)
df
df2
#################
# In [227]: df  #
# Out[227]:     #
#    0  1  2    #
# 0  a  b  c    #
# 1  d  e  f    #
# 2  g  h  i    #
#               #
# In [228]: df2 #
# Out[228]:     #
#    0  1  2    #
# 0  a  b  c    #
# 1  d  x  f    #
# 2  g  h  i    #
#################
4.2.2. 一致する行を見つける方法
4.2.2.1. 比較
df3 = df==df2
df3
########################
# In [244]: df3        #
# Out[244]:            #
#       0      1     2 #
# 0  True   True  True #
# 1  True  False  True #
# 2  True   True  True #
########################
4.2.2.2.フィルタリング
# df と df2 で一致する行を抽出したい。
# df3 で全ての行が True の行のことなので、その行を抽出する
# all を使用するとできる
# all で reduce する方向は axis で決める、列方向に reduce するには axis=1 とする
# all は全ての行(観測点)に適用される
df4 = df3.all(axis=1)
df4
#################
# In [253]: df4 #
# Out[255]:     #
# 0     True    #
# 1    False    #
# 2     True    #
# dtype: bool   #
#################

# 以下のようにすると df と df2 の行において一致するの行だけ抽出できる
df5 = df[df4]
df5
#################
# In [280]: df5 #
# Out[280]:     #
#    0  1  2    #
# 0  a  b  c    #
# 2  g  h  i    #
#################
4.2.3. 一致しない行を見つける方法
4.2.3.1. 比較
df6 = df!=df2
df6
##########################
# In [288]: df6          #
# Out[288]:              #
#        0      1      2 #
# 0  False  False  False #
# 1  False   True  False #
# 2  False  False  False #
##########################
4.2.3.2. フィルタリング
# 注意!!: ひとつでも値が異なる行を見つけたいので、 all ではなく any を使用する
# (個人的にはまったのでメモ)
df7 = df6.any(axis=1)
df7
#################
# In [319]: df7 #
# Out[319]:     #
# 0    False    #
# 1     True    #
# 2    False    #
# dtype: bool   #
#################

df8 = df[df7]
df8
#################
# In [333]: df8 #
# Out[333]:     #
#    0  1  2    #
# 1  d  e  f    #
#################

# (Tips) 上記以外の書き方で、等価となる式
# 「"一致する行"でない行」を抽出
df9 = df[~df4]
df9
#################
# In [421]: df9 #
# Out[421]:     #
#    0  1  2    #
# 1  d  e  f    #
#################

5. np.full みたいに要素全てが同じ値からなる Series を作る方法

data = ['a']*5
s = pd.Series(data)
s
#################
# In [387]: s   #
# Out[387]:     #
# 0    a        #
# 1    a        #
# 2    a        #
# 3    a        #
# 4    a        #
# dtype: object #
#################