DataFrame – 列の操作

2020-11-07 / tau / コメントする

概要

DataFrameの列の操作をまとめる。

以下、次のDataFrameを使う。

import numpy as np
import pandas as pd

ary = np.arange(16).reshape(4, 4)
df = pd.DataFrame(ary, columns=["one", "two", "three", "four"])
print(df)

#    one  two  three  four
# 0    0    1      2     3
# 1    4    5      6     7
# 2    8    9     10    11
# 3   12   13     14    15

import numpy as np

import pandas as pd

ary = np.arange(16).reshape(4, 4)

df = pd.DataFrame(ary, columns=["one", "two", "three", "four"])

print(df)

# one two three four

# 0 0 1 2 3

# 1 4 5 6 7

# 2 8 9 10 11

# 3 12 13 14 15

列の参照

DataFrameで列名を直接指定

1つの列を指定

DataFrameで直接列名を指定するとSeriesオブジェクトが得られ、リストやndarrayにも変換できる。

col = df["two"]
print(col)

# 0     1
# 1     5
# 2     9
# 3    13
# Name: two, dtype: int32

print(type(col))

# <class 'pandas.core.series.Series'>

print(list(col))
print(np.array(col))

# [1, 5, 9, 13]
# [ 1  5  9 13]

col = df["two"]

print(col)

# 0 1

# 1 5

# 2 9

# 3 13

# Name: two, dtype: int32

print(type(col))

# <class 'pandas.core.series.Series'>

print(list(col))

print(np.array(col))

# [1, 5, 9, 13]

# [ 1 5 9 13]

ファンシー・インデックスによる複数列の指定

DataFrameで直接列名を指定する際に列名のリストを渡すと、その要素の列が並んだDataFrameが返される。

cols = df[["two", "four"]]
print(cols)

#    two  four
# 0    1     3
# 1    5     7
# 2    9    11
# 3   13    15

print(type(cols))

# <class 'pandas.core.frame.DataFrame'>

cols = df[["two", "four"]]

print(cols)

# two four

# 0 1 3

# 1 5 7

# 2 9 11

# 3 13 15

print(type(cols))

# <class 'pandas.core.frame.DataFrame'>

`loc`による列の指定

1つの列の指定

locで全行のスライス':'とすることで、列名を指定して列を取り出すことができる。結果はSeriesオブジェクト。

print(df.loc[:, "two"])

# 0     1
# 1     5
# 2     9
# 3    13
Name: two, dtype: int32

print(df.loc[:, "two"])

# 0 1

# 1 5

# 2 9

# 3 13

Name: two, dtype: int32

スライスによる連続した列の指定

列名にもスライスを使って連続した列を参照することができ、複数列の場合はDataFrameが返される。

print(df.loc[:, "two":"three"])

#    two  three
# 0    1      2
# 1    5      6
# 2    9     10
# 3   13     14

print(df.loc[:, "two":"three"])

# two three

# 0 1 2

# 1 5 6

# 2 9 10

# 3 13 14

ファンシーインデックスによる複数列の指定

locでもファンシーインデックスを使うことができて、個別の列を組み合わせたDataFrameを得ることができる。

print(df.loc[:, ["two", "four"]])

#    two  four
# 0    1     3
# 1    5     7
# 2    9    11
# 3   13    15

print(df.loc[:, ["two", "four"]])

# two four

# 0 1 3

# 1 5 7

# 2 9 11

# 3 13 15

列の追加

`DataFrame`で直接列名を指定して追加

DataFrameに新たな列名を指定して末尾に列を追加。列にarray_likeではなく数値を指定すると、列の全ての要素が同じ数値で埋められる。

df_update = df.copy()
df_update["five"] = [50, 51, 52, 53]
print(df_update)

#    one  two  three  four  five
# 0    0    1      2     3    50
# 1    4    5      6     7    51
# 2    8    9     10    11    52
# 3   12   13     14    15    53

df_update["six"] = 60
print(df_update)

#    one  two  three  four  five  six
# 0    0    1      2     3    50   60
# 1    4    5      6     7    51   60
# 2    8    9     10    11    52   60
# 3   12   13     14    15    53   60

df_update = df.copy()

df_update["five"] = [50, 51, 52, 53]

print(df_update)

# one two three four five

# 0 0 1 2 3 50

# 1 4 5 6 7 51

# 2 8 9 10 11 52

# 3 12 13 14 15 53

df_update["six"] = 60

print(df_update)

# one two three four five six

# 0 0 1 2 3 50 60

# 1 4 5 6 7 51 60

# 2 8 9 10 11 52 60

# 3 12 13 14 15 53 60

`loc`でスライス指定して追加

全行をスライス指定、新たな行名を指定して末尾に列を追加。

df_update = df.copy()
df_update.loc[:, "five"] = [50, 51, 52, 53]
print(df_update)

#    one  two  three  four  five
# 0    0    1      2     3    50
# 1    4    5      6     7    51
# 2    8    9     10    11    52
# 3   12   13     14    15    53

df_update.loc[:, "six"] = 60
print(df_update)

#    one  two  three  four  five  six
# 0    0    1      2     3    50   60
# 1    4    5      6     7    51   60
# 2    8    9     10    11    52   60
# 3   12   13     14    15    53   60

df_update = df.copy()

df_update.loc[:, "five"] = [50, 51, 52, 53]

print(df_update)

# one two three four five

# 0 0 1 2 3 50

# 1 4 5 6 7 51

# 2 8 9 10 11 52

# 3 12 13 14 15 53

df_update.loc[:, "six"] = 60

print(df_update)

# one two three four five six

# 0 0 1 2 3 50 60

# 1 4 5 6 7 51 60

# 2 8 9 10 11 52 60

# 3 12 13 14 15 53 60

`assign`メソッドによる追加

assignメソッドで末尾に追加する場合、列名は文字列（"列名"）ではなく、直接「列名＝列」で指定する。assignメソッドは元のオブジェクトは変更せず、新たなDataFrameを生成して返す。

print(df.assign(five=[50, 51, 52, 53]))

#    one  two  three  four  five
# 0    0    1      2     3    50
# 1    4    5      6     7    51
# 2    8    9     10    11    52
# 3   12   13     14    15    53

print(df.assign(five=50))

#    one  two  three  four  five
# 0    0    1      2     3    50
# 1    4    5      6     7    50
# 2    8    9     10    11    50
# 3   12   13     14    15    50

print(df.assign(five=[50, 51, 52, 53]))

# one two three four five

# 0 0 1 2 3 50

# 1 4 5 6 7 51

# 2 8 9 10 11 52

# 3 12 13 14 15 53

print(df.assign(five=50))

# one two three four five

# 0 0 1 2 3 50

# 1 4 5 6 7 50

# 2 8 9 10 11 50

# 3 12 13 14 15 50

`insert`メソッドによる途中への追加

insertメソッドは（挿入する列位置、"列名"、挿入する列）で挿入する。

df_update = df.copy()
df_update.insert(2, "two_half", [25, 26, 27, 28])
print(df_update)

#    one  two  two_half  three  four
# 0    0    1        25      2     3
# 1    4    5        26      6     7
# 2    8    9        27     10    11
# 3   12   13        28     14    15

df_update.insert(4, "three_half", 30)
print(df_update)

#    one  two  two_half  three  three_half  four
# 0    0    1        25      2          30     3
# 1    4    5        26      6          30     7
# 2    8    9        27     10          30    11
# 3   12   13        28     14          30    15

df_update = df.copy()

df_update.insert(2, "two_half", [25, 26, 27, 28])

print(df_update)

# one two two_half three four

# 0 0 1 25 2 3

# 1 4 5 26 6 7

# 2 8 9 27 10 11

# 3 12 13 28 14 15

df_update.insert(4, "three_half", 30)

print(df_update)

# one two two_half three three_half four

# 0 0 1 25 2 30 3

# 1 4 5 26 6 30 7

# 2 8 9 27 10 30 11

# 3 12 13 28 14 30 15

列の更新

`DataFrame`で列名を直接指定

1つの列を指定

DataFrameで列名を直接指定して、その列に新たな列を代入する。代入する列は縦ベクトルでなくてもよく、1次元のリストや配列でよい。

df_update = df.copy()
df_update["two"] = [10, 50, 90, 130]
print(df_update)

#    one  two  three  four
# 0    0   10      2     3
# 1    4   50      6     7
# 2    8   90     10    11
# 3   12  130     14    15

df_update = df.copy()

df_update["two"] = [10, 50, 90, 130]

print(df_update)

# one two three four

# 0 0 10 2 3

# 1 4 50 6 7

# 2 8 90 10 11

# 3 12 130 14 15

ファンシーインデックスによる複数列の指定

ファンシーインデックスで複数列をリストで指定し、その列数と同じ列数のデータを与えて更新する。

df_update = df.copy()
df_update[["one", "three"]] = [
    [  0,  20],
    [ 40,  60],
    [ 80, 100],
    [120, 140]
]
print(df_update)

#    one  two  three  four
# 0    0    1     20     3
# 1   40    5     60     7
# 2   80    9    100    11
# 3  120   13    140    15

df_update = df.copy()

df_update[["one", "three"]] = [

[ 0, 20],

[ 40, 60],

[ 80, 100],

[120, 140]

]

print(df_update)

# one two three four

# 0 0 1 20 3

# 1 40 5 60 7

# 2 80 9 100 11

# 3 120 13 140 15

`loc`による列名・スライスの指定

1つの列の指定

locで全行のスライスと1つの列名を指定して列を更新。

df_update = df.copy()
df_update.loc[:, "four"] = [30, 70, 110, 150]
print(df_update)

#    one  two  three  four
# 0    0    1      2    30
# 1    4    5      6    70
# 2    8    9     10   110
# 3   12   13     14   150

df_update = df.copy()

df_update.loc[:, "four"] = [30, 70, 110, 150]

print(df_update)

# one two three four

# 0 0 1 2 30

# 1 4 5 6 70

# 2 8 9 10 110

# 3 12 13 14 150

スライスによる連続した列の指定

スライスで連続した列を指定して一括して更新することができる。その場合、指定されたDataFrameの形状に合った次元・次数のデータを与える必要がある。

df_update.loc[:, "one":"three"] = [
    [  0,  10,  20],
    [ 40,  50,  60],
    [ 80,  90, 100],
    [120, 130, 140]
]
print(df_update)

#    one  two  three  four
# 0    0   10     20    30
# 1   40   50     60    70
# 2   80   90    100   110
# 3  120  130    140   150

df_update.loc[:, "one":"three"] = [

[ 0, 10, 20],

[ 40, 50, 60],

[ 80, 90, 100],

[120, 130, 140]

]

print(df_update)

# one two three four

# 0 0 10 20 30

# 1 40 50 60 70

# 2 80 90 100 110

# 3 120 130 140 150

ファンシーインデックスによる複数列の指定

ファンシーインデックスも使うことができて、この場合も形状に合った次元・次数のデータを与える必要がある。

df_update.loc[:, ["two", "four"]] = [
    [ 1,  3],
    [ 5,  7],
    [ 9, 11],
    [13, 15],
]
print(df_update)

#    one  two  three  four
# 0    0    1     20     3
# 1   40    5     60     7
# 2   80    9    100    11
# 3  120   13    140    15

df_update.loc[:, ["two", "four"]] = [

[ 1, 3],

[ 5, 7],

[ 9, 11],

[13, 15],

]

print(df_update)

# one two three four

# 0 0 1 20 3

# 1 40 5 60 7

# 2 80 9 100 11

# 3 120 13 140 15

列の削除

例題のデータ

以下の2つのデータを使って、列番号指定の場合と列名指定の場合を確認する。

import numpy as np
import pandas as pd

array = np.arange(25).reshape(-1, 5)
df_numbered = pd.DataFrame(array)
df_named = pd.DataFrame(array, columns=["zero", "one", "two", "three", "four"])

print(df_numbered)
#     0   1   2   3   4
# 0   0   1   2   3   4
# 1   5   6   7   8   9
# 2  10  11  12  13  14
# 3  15  16  17  18  19
# 4  20  21  22  23  24

print(df_named)
#    zero  one  two  three  four
# 0     0    1    2      3     4
# 1     5    6    7      8     9
# 2    10   11   12     13    14
# 3    15   16   17     18    19
# 4    20   21   22     23    24

import numpy as np

import pandas as pd

array = np.arange(25).reshape(-1, 5)

df_numbered = pd.DataFrame(array)

df_named = pd.DataFrame(array, columns=["zero", "one", "two", "three", "four"])

print(df_numbered)

# 0 1 2 3 4

# 0 0 1 2 3 4

# 1 5 6 7 8 9

# 2 10 11 12 13 14

# 3 15 16 17 18 19

# 4 20 21 22 23 24

print(df_named)

# zero one two three four

# 0 0 1 2 3 4

# 1 5 6 7 8 9

# 2 10 11 12 13 14

# 3 15 16 17 18 19

# 4 20 21 22 23 24

1列の削除

drop()メソッドの引数に削除する列の列番号とaxis=1を指定して削除（axis指定の方向に注意）。

第1引数の列指定はlabels=1、labels="one"のように指定してもよい。

print(df_numbered.drop(1, axis=1))
#     0   2   3   4
# 0   0   2   3   4
# 1   5   7   8   9
# 2  10  12  13  14
# 3  15  17  18  19
# 4  20  22  23  24

print(df_named.drop("one",axis=1))
#    zero  two  three  four
# 0     0    2      3     4
# 1     5    7      8     9
# 2    10   12     13    14
# 3    15   17     18    19
# 4    20   22     23    24

print(df_numbered.drop(1, axis=1))

# 0 2 3 4

# 0 0 2 3 4

# 1 5 7 8 9

# 2 10 12 13 14

# 3 15 17 18 19

# 4 20 22 23 24

print(df_named.drop("one",axis=1))

# zero two three four

# 0 0 2 3 4

# 1 5 7 8 9

# 2 10 12 13 14

# 3 15 17 18 19

# 4 20 22 23 24

複数列の削除

複数列を削除する場合はリストで指定。

print(df_numbered.drop([1, 3], axis=1))
#     0   2   4
# 0   0   2   4
# 1   5   7   9
# 2  10  12  14
# 3  15  17  19
# 4  20  22  24

print(df_named.drop(["one", "three"], axis=1))
#    zero  two  four
# 0     0    2     4
# 1     5    7     9
# 2    10   12    14
# 3    15   17    19
# 4    20   22    24

print(df_numbered.drop([1, 3], axis=1))

# 0 2 4

# 0 0 2 4

# 1 5 7 9

# 2 10 12 14

# 3 15 17 19

# 4 20 22 24

print(df_named.drop(["one", "three"], axis=1))

# zero two four

# 0 0 2 4

# 1 5 7 9

# 2 10 12 14

# 3 15 17 19

# 4 20 22 24

連続した列の削除

連続した列を削除する場合はリストの内包表記で。

print(df.drop([x for x in range(1, 4)], axis=1))

#     0   4
# 0   0   4
# 1   5   9
# 2  10  14
# 3  15  19
# 4  20  24

print(df.drop([x for x in range(1, 4)], axis=1))

# 0 4

# 0 0 4

# 1 5 9

# 2 10 14

# 3 15 19

# 4 20 24

文字列の列名の場合は、泥臭いが以下の方法か。

print(df_named.drop(df_named.loc[:, "one":"three"].columns, axis=1))
#    zero  four
# 0     0     4
# 1     5     9
# 2    10    14
# 3    15    19
# 4    20    24\

print(df_named.drop(df_named.loc[:, "one":"three"].columns, axis=1))

# zero four

# 0 0 4

# 1 5 9

# 2 10 14

# 3 15 19

# 4 20 24\

DataFrame – 要素の内容の参照・変更

2020-11-03 / tau / コメントする

要素の操作

以下の2つのDataFrameを使っていく。

import numpy as np
import pandas as pd

lst = [
    ["Alex", "DC", 44, 168],
    ["Bert", "NY", 18, 176],
    ["Carl", "CA", 26, 175],
    ["Daryl", "DC", 32, 182],
    ["Eddy", "CA", 58, 192]
]
dflst = pd.DataFrame(lst, columns=["name", "state", "age", "height"])
dflst = dflst.set_index("name")
print(dflst)

#       state age height
# name                  
# Alex     DC  44    168
# Bert     NY  18    176
# Carl     CA  26    175
# Daryl    DC  32    182
# Eddy     CA  58    192

dfary = pd.DataFrame(np.arange(9).reshape(3, 3))
print(dfary)

#    0  1  2
# 0  0  1  2
# 1  3  4  5
# 2  6  7  8

import numpy as np

import pandas as pd

lst = [

["Alex", "DC", 44, 168],

["Bert", "NY", 18, 176],

["Carl", "CA", 26, 175],

["Daryl", "DC", 32, 182],

["Eddy", "CA", 58, 192]

]

dflst = pd.DataFrame(lst, columns=["name", "state", "age", "height"])

dflst = dflst.set_index("name")

print(dflst)

# state age height

# name

# Alex DC 44 168

# Bert NY 18 176

# Carl CA 26 175

# Daryl DC 32 182

# Eddy CA 58 192

dfary = pd.DataFrame(np.arange(9).reshape(3, 3))

print(dfary)

# 0 1 2

# 0 0 1 2

# 1 3 4 5

# 2 6 7 8

`at/iat`～単独要素の参照・変更

`at`～インデックス指定

atは行・列のラベルを指定して単独の要素を参照・変更

print(dflst.at["Alex", "age"])

# 44

dflst.at["Alex", "age"] = 55
print(dflst)

#       state  age  height
# name                    
# Alex     DC   55     168
# Bert     NY   18     176
# Carl     CA   26     175
# Daryl    DC   32     182
# Eddy     CA   58     192

print(dflst.at["Alex", "age"])

# 44

dflst.at["Alex", "age"] = 55

print(dflst)

# state age height

# name

# Alex DC 55 168

# Bert NY 18 176

# Carl CA 26 175

# Daryl DC 32 182

# Eddy CA 58 192

インデックスがデフォルトの数値の場合は数値指定。

print(dfary.at[2, 1])

# 7

dfary.at[2, 1] = 77
print(dfary)

#    0   1  2
# 0  0   1  2
# 1  3   4  5
# 2  6  77  8

print(dfary.at[2, 1])

# 7

dfary.at[2, 1] = 77

print(dfary)

# 0 1 2

# 0 0 1 2

# 1 3 4 5

# 2 6 77 8

`iat`～行・列番号指定

iatは行・列の番号を数値で指定して単独の要素を参照・変更。行・列のインデックスはカウントされない。

print(dflst.iat[1, 2])

# 176

dflst.iat[1, 2] = 199
print(dflst)

#       state  age  height
# name                    
# Alex     DC   55     168
# Bert     NY   18     199
# Carl     CA   26     175
# Daryl    DC   32     182
# Eddy     CA   58     192

print(dflst.iat[1, 2])

# 176

dflst.iat[1, 2] = 199

print(dflst)

# state age height

# name

# Alex DC 55 168

# Bert NY 18 199

# Carl CA 26 175

# Daryl DC 32 182

# Eddy CA 58 192

インデックスがデフォルトの数値の場合は数値指定。

print(dfary.iat[0, 2])

# 2

dfary.iat[0, 2] = 22
print(dfary)

#    0   1   2
# 0  0   1  22
# 1  3   4   5
# 2  6  77   8

print(dfary.iat[0, 2])

# 2

dfary.iat[0, 2] = 22

print(dfary)

# 0 1 2

# 0 0 1 22

# 1 3 4 5

# 2 6 77 8

`loc/iloc`～単独要素・スライスの参照・変更

`loc`～インデックス指定／終端含む

locの単独要素指定もatと同様。

print(dflst.loc["Carl", "state"])

# CA

dflst.loc["Carl", "state"] = "AZ"
print(dflst)

#       state  age  height
# name                    
# Alex     DC   55     168
# Bert     NY   18     199
# Carl     AZ   26     175
# Daryl    DC   32     182
# Eddy     CA   58     192

print(dflst.loc["Carl", "state"])

# CA

dflst.loc["Carl", "state"] = "AZ"

print(dflst)

# state age height

# name

# Alex DC 55 168

# Bert NY 18 199

# Carl AZ 26 175

# Daryl DC 32 182

# Eddy CA 58 192

locは行・列のラベルにスライスを指定可能。ただしlocのスライス指定ではリストや配列と異なり、（デフォルトの数値ラベルであっても）終端の行・列を含む点に注意。

print(dflst.loc["Bert":"Daryl", "state":"age"])

#       state  age
# name            
# Bert     NY   18
# Carl     AZ   26
# Daryl    DC   32

print(dfary.loc[1:2, 0:1])

#    0   1
# 1  3   4
# 2  6  77

print(dflst.loc["Bert":"Daryl", "state":"age"])

# state age

# name

# Bert NY 18

# Carl AZ 26

# Daryl DC 32

print(dfary.loc[1:2, 0:1])

# 0 1

# 1 3 4

# 2 6 77

スライス指定した範囲を変更可能。行単位・列単位のデータの更新の際に使う。

dfary.loc[:, 1] = [10, 40, 70]
print(dfary)

#    0   1   2
# 0  0  10  22
# 1  3  40   5
# 2  6  70   8

dfary.loc[:, 1] = [10, 40, 70]

print(dfary)

# 0 1 2

# 0 0 10 22

# 1 3 40 5

# 2 6 70 8

`iloc`～行・列番号指定／終端含まず

ilocは行・列の番号にスライスを指定可能。ilocのスライス指定では、リストや配列と同じで、終端の行・列は含まれない。

print(dflst.iloc[1:3, 0:2])

#      state  age
# name           
# Bert    NY   18
# Carl    AZ   26

print(dfary.iloc[0:2, 0:1])

#    0
# 0  0
# 1  3

print(dflst.iloc[1:3, 0:2])

# state age

# name

# Bert NY 18

# Carl AZ 26

print(dfary.iloc[0:2, 0:1])

# 0

# 0 0

# 1 3

ilocでもスライス指定で内容変更が可能。

dfary.iloc[:, 1] = [100, 400, 700]
print(dfary)

#    0    1   2
# 0  0  100  22
# 1  3  400   5
# 2  6  700   8

dfary.iloc[:, 1] = [100, 400, 700]

print(dfary)

# 0 1 2

# 0 0 100 22

# 1 3 400 5

# 2 6 700 8

DataFrame – 生成時の数値と文字列の混在について

2020-11-03 / tau / コメントする

概要

DataFrameは列同士の型が異なってもよいが、配列でデータを組み立てる場合に数値と文字を混在させると、数値が全て文字列となってしまうので注意が必要。

配列は不適

以下のようにndarrayで文字列と数値を混在させたデータを基にしてDataFrameを生成すると、その内容が全て文字列になってしまう。

import numpy as np
from pandas import DataFrame

ary = np.array([
    ["Alex", "DC", 44, 168],
    ["Bert", "NY", 18, 176],
    ["Carl", "CA", 26, 175]
])

df = DataFrame(ary, columns=["name", "state", "age", "height"])
df = df.set_index("name")
print(df.values)

# [['DC' '44' '168']
#  ['NY' '18' '176']
#  ['CA' '26' '175']

import numpy as np

from pandas import DataFrame

ary = np.array([

["Alex", "DC", 44, 168],

["Bert", "NY", 18, 176],

["Carl", "CA", 26, 175]

])

df = DataFrame(ary, columns=["name", "state", "age", "height"])

df = df.set_index("name")

print(df.values)

# [['DC' '44' '168']

# ['NY' '18' '176']

# ['CA' '26' '175']

このデータの数値演算を行おうとすると以下のように文字列演算になってしまう。

print(df.loc["Alex", "age"] + df.loc["Bert", "age"])

# 4418

print(df.loc["Alex", "age"] + df.loc["Bert", "age"])

# 4418

これはndarrayが型の混在を許さないためで、いわばケアレスミスだが注意。

リストはOK

元のデータをリストにすれば問題なく数値と文字列に分けられる。

lst = [
    ["Alex", "DC", 44, 168],
    ["Bert", "NY", 18, 176],
    ["Carl", "CA", 26, 175]
]

df = DataFrame(lst, columns=["name", "state", "age", "height"])
df = df.set_index("name")
print(df.values)

# [['DC' 44 168]
#  ['NY' 18 176]
#  ['CA' 26 175]]

print(df.loc["Alex", "age"] + df.loc["Bert", "age"])

# 62

lst = [

["Alex", "DC", 44, 168],

["Bert", "NY", 18, 176],

["Carl", "CA", 26, 175]

]

df = DataFrame(lst, columns=["name", "state", "age", "height"])

df = df.set_index("name")

print(df.values)

# [['DC' 44 168]

# ['NY' 18 176]

# ['CA' 26 175]]

print(df.loc["Alex", "age"] + df.loc["Bert", "age"])

# 62

列の辞書もOK

列ごとのリストを辞書で組み立てても数値と文字は分けられる。

names = ["Alex", "Bert", "Carl"]
states = ["DC", "NY", "CA"]
ages = [44, 18, 26]
heights = [168, 176, 175]

df = DataFrame({"state":states, "age":ages, "height":heights}, index=names)
print(df.values)

# [['DC' 44 168]
#  ['NY' 18 176]
#  ['CA' 26 175]]

names = ["Alex", "Bert", "Carl"]

states = ["DC", "NY", "CA"]

ages = [44, 18, 26]

heights = [168, 176, 175]

df = DataFrame({"state":states, "age":ages, "height":heights}, index=names)

print(df.values)

# [['DC' 44 168]

# ['NY' 18 176]

# ['CA' 26 175]]

DataFrame – 生成

2020-11-03 / tau / コメントする

リスト・配列からの生成

リストからの生成

2次元のリストをそのまま引数にしてDataFrameを生成。列名・行名には自動的に番号が振られる。

import numpy as np
from pandas import DataFrame

lst = [[0, 1, 2], [3, 4, 5]]
df = DataFrame(lst)
print(df)

#    0  1  2
# 0  0  1  2
# 1  3  4  5

import numpy as np

from pandas import DataFrame

lst = [[0, 1, 2], [3, 4, 5]]

df = DataFrame(lst)

print(df)

# 0 1 2

# 0 0 1 2

# 1 3 4 5

ndarrayからの生成

2次元のndarrayからもDataFrameを生成可能。

ary = np.arange(6).reshape(2, 3)
df = DataFrame(ary)
print(df)

#    0  1  2
# 0  0  1  2
# 1  3  4  5

ary = np.arange(6).reshape(2, 3)

df = DataFrame(ary)

print(df)

# 0 1 2

# 0 0 1 2

# 1 3 4 5

列名・行インデックスの設定

DataFrame生成時にcolumnsで列名を、indexで行インデックスを設定可能。

df = DataFrame(lst, columns=["c1", "c2", "c3"], index=["r1", "r2"])
print(df)

#     c1  c2  c3
# r1   0   1   2
# r2   3   4   5

df = DataFrame(lst, columns=["c1", "c2", "c3"], index=["r1", "r2"])

print(df)

# c1 c2 c3

# r1 0 1 2

# r2 3 4 5

列リストと辞書による

列ごとのリストやndarrayが与えられていれば、それぞれの列名をキー、リストや配列を値とした辞書を引数にしてDataFrameを生成できる。

names = ["Austin", "Bill", "Charie"]
ages = np.array([38, 25, 52])
df = DataFrame({'name': names, 'age': ages})
print(df)

#      name  age
# 0  Austin   38
# 1    Bill   25
# 2  Charie   52

names = ["Austin", "Bill", "Charie"]

ages = np.array([38, 25, 52])

df = DataFrame({'name': names, 'age': ages})

print(df)

# name age

# 0 Austin 38

# 1 Bill 25

# 2 Charie 52

DataFrame – 情報・内容の取得

2020-11-03 / tau / コメントする

概要

pandas.DataFrameの行数・列数などの数や、列名・行名・データ配列を取り出す方法。以下のデータを使う。

import numpy as np
from pandas import DataFrame

lst = [
    ["Alex", "DC", 44, 168],
    ["Bert", "NY", 18, 176],
    ["Carl", "CA", 26, 175],
    ["Daryl", "DC", 32, 182],
    ["Eddy", "CA", 58, 192]
]

df = DataFrame(lst, columns=["name", "state", "age", "height"])
df = df.set_index("name")
print(df)

#       state age height
# name                  
# Alex     DC  44    168
# Bert     NY  18    176
# Carl     CA  26    175
# Daryl    DC  32    182
# Eddy     CA  58    192

import numpy as np

from pandas import DataFrame

lst = [

["Alex", "DC", 44, 168],

["Bert", "NY", 18, 176],

["Carl", "CA", 26, 175],

["Daryl", "DC", 32, 182],

["Eddy", "CA", 58, 192]

]

df = DataFrame(lst, columns=["name", "state", "age", "height"])

df = df.set_index("name")

print(df)

# state age height

# name

# Alex DC 44 168

# Bert NY 18 176

# Carl CA 26 175

# Daryl DC 32 182

# Eddy CA 58 192

行数・列数・サイズ

df.shapeプロパティーで（行数, 列数）のタプルが帰る。2つの変数にアンパッキングして使える。列名やインデックス列は行数・列数にカウントされない。

print(df.shape)
# (5, 3)

rows, cols = df.shape
print("rows={}, cols={}".format(rows, cols))
# rows=5, cols=3

print(df.shape)

# (5, 3)

rows, cols = df.shape

print("rows={}, cols={}".format(rows, cols))

# rows=5, cols=3

行数だけを得るにはlen(df)、列数だけを得るにはlen(df.columns)。

print(len(df))
# 5

print(len(df.columns))
# 3

print(len(df))

# 5

print(len(df.columns))

# 3

df.sizeで全要素数を得られる。

print(df.size)
# 15

1 2	print(df.size) # 15

行名・インデックス・データの内容

列名～`columns`

列名はcolumnsプロパティーで得られる。Indexオブジェクトで格納されていて、リストやndarrayにも変換可能。

print(df.columns)
print(list(df.columns))
print(np.array(df.columns))

# Index(['state', 'age', 'height'], dtype='object')
# ['state', 'age', 'height']
# ['state' 'age' 'height']

print(df.columns)

print(list(df.columns))

print(np.array(df.columns))

# Index(['state', 'age', 'height'], dtype='object')

# ['state', 'age', 'height']

# ['state' 'age' 'height']

行名～`index`

列名はcolumnsプロパティーで得られる。こちらもIndexオブジェクトで格納されていて、リストやndarrayにも変換可能。

print(df.index)
print(list(df.index))
print(np.array(df.index))

# Index(['Alex', 'Bert', 'Carl', 'Daryl', 'Eddy'], dtype='object', name='name')
# ['Alex', 'Bert', 'Carl', 'Daryl', 'Eddy']
# ['Alex' 'Bert' 'Carl' 'Daryl' 'Eddy']

print(df.index)

print(list(df.index))

print(np.array(df.index))

# Index(['Alex', 'Bert', 'Carl', 'Daryl', 'Eddy'], dtype='object', name='name')

# ['Alex', 'Bert', 'Carl', 'Daryl', 'Eddy']

# ['Alex' 'Bert' 'Carl' 'Daryl' 'Eddy']

データの内容～`values`

列名・行名を除いたデータの内容のみを取り出したいときはvaluesプロパティーにアクセスする。結果はndarrayで返される。

print(df.values)

# [['DC' 44 168]
#  ['NY' 18 176]
#  ['CA' 26 175]
#  ['DC' 32 182]
#  ['CA' 58 192]]

print(df.values)

# [['DC' 44 168]

# ['NY' 18 176]

# ['CA' 26 175]

# ['DC' 32 182]

# ['CA' 58 192]]

なお、valuesの内容を変更すると元のデータが変更される点に注意。以下は元データをndarrayで与えているが、リストで与えても結果は同じ。

ary = np.array([[0, 1], [2, 3]])
df = DataFrame(ary)

print("Before:")
print(df.values)
df.values[0, 0] = "9"
print("After:")
print(df.values)

# Before:
# [[0 1]
#  [2 3]]
# After:
# [[9 1]
#  [2 3]]

ary = np.array([[0, 1], [2, 3]])

df = DataFrame(ary)

print("Before:")

print(df.values)

df.values[0, 0] = "9"

print("After:")

print(df.values)

# Before:

# [[0 1]

# [2 3]]

# After:

# [[9 1]

# [2 3]]

Figure全体のタイトル

2020-11-01 / tau / コメントする

複数グラフを含むFigure全体に1つのタイトルを付けたい場合、Figure.suptitle()を使う。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi, 100)
y_sin = np.sin(x*2)
y_cos = np.cos(x*2)

fig, ax = plt.subplots(1, 2, figsize=(12.8, 4.8))
fig.suptitle("sine and cosine curves", fontsize="15")

ax[0].plot(x, y_sin)
ax[0].set_title("sin")

ax[1].plot(x, y_cos)
ax[1].set_title("cos")

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi, 100)

y_sin = np.sin(x*2)

y_cos = np.cos(x*2)

fig, ax = plt.subplots(1, 2, figsize=(12.8, 4.8))

fig.suptitle("sine and cosine curves", fontsize="15")

ax[0].plot(x, y_sin)

ax[0].set_title("sin")

ax[1].plot(x, y_cos)

ax[1].set_title("cos")

plt.show()

Axesで軸を反転させる

2020-11-01 / tau / コメントする

軸の反転には、invert_xaxis()、invert_yaxis()を使う。

軸が反転されているかどうかの確認には、xaxis_inverted()、yaxis_inverted()を使う。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 1)
y = x**2

fig, axs = plt.subplots(2, 2, figsize=(6.4, 6.8))

for ax in axs.flatten():
    ax.plot(x, y)
    ax.set_aspect('equal')
    ax.set_xlim(0, 1)
    ax.set_ylim(0, 1)

axs[1, 0].invert_xaxis()
axs[1, 1].invert_xaxis()

axs[0, 1].invert_yaxis()
axs[1, 1].invert_yaxis()

axs[1, 0].set_title("x inverted")
axs[0, 1].set_title("y inverted")
axs[1, 1].set_title("x,y inverted")

for ax in axs.flatten():
    print(ax.xaxis_inverted(), ax.yaxis_inverted())

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(0, 1)

y = x**2

fig, axs = plt.subplots(2, 2, figsize=(6.4, 6.8))

for ax in axs.flatten():

ax.plot(x, y)

ax.set_aspect('equal')

ax.set_xlim(0, 1)

ax.set_ylim(0, 1)

axs[1, 0].invert_xaxis()

axs[1, 1].invert_xaxis()

axs[0, 1].invert_yaxis()

axs[1, 1].invert_yaxis()

axs[1, 0].set_title("x inverted")

axs[0, 1].set_title("y inverted")

axs[1, 1].set_title("x,y inverted")

for ax in axs.flatten():

print(ax.xaxis_inverted(), ax.yaxis_inverted())

plt.show()

実行結果

False False
False True
True False
True True

False False

False True

True False

True True

バグの素～間違いやすいところ

2020-10-15 / tau / コメントする

リストの初期化

問題

以下の処理を意図する。

2次元リストを準備し、そのリストに1列追加する
追加の際、各行を2行ずつに繰り返し、追加した列には全行を通したカウンター値を記録

Before:
[['A', 'X'], ['B', 'Y'], ['C', 'Z']]
After:
[['A', 'X', 1], ['A', 'X', 2], ['B', 'Y', 3], ['B', 'Y', 4], ['C', 'Z', 5], ['C', 'Z', 6]]

Before:

[['A', 'X'], ['B', 'Y'], ['C', 'Z']]

After:

[['A', 'X', 1], ['A', 'X', 2], ['B', 'Y', 3], ['B', 'Y', 4], ['C', 'Z', 5], ['C', 'Z', 6]]

これを意図したコードで以下のように意図しない結果となった。

source_list = [
    ["A", "X"],
    ["B", "Y"],
    ["C", "Z"]
]

print("Before:")
print(source_list)

new_list = []

counter = 1
for i in range(len(source_list)):
    new_row = source_list[i]
    new_row.append(counter)
    counter += 1
    new_list.append(new_row)

    new_row = source_list[i]
    new_row.append(counter)
    counter += 1
    new_list.append(new_row)

print("After:")
print(new_list)

# Before:
# [['A', 'X'], ['B', 'Y'], ['C', 'Z']]
# After:
# [['A', 'X', 1, 2], ['A', 'X', 1, 2], ['B', 'Y', 3, 4], ['B', 'Y', 3, 4], ['C', 'Z', 5, 6], ['C', 'Z', 5, 6]]

source_list = [

["A", "X"],

["B", "Y"],

["C", "Z"]

]

print("Before:")

print(source_list)

new_list = []

counter = 1

for i in range(len(source_list)):

new_row = source_list[i]

new_row.append(counter)

counter += 1

new_list.append(new_row)

new_row = source_list[i]

new_row.append(counter)

counter += 1

new_list.append(new_row)

print("After:")

print(new_list)

# Before:

# [['A', 'X'], ['B', 'Y'], ['C', 'Z']]

# After:

# [['A', 'X', 1, 2], ['A', 'X', 1, 2], ['B', 'Y', 3, 4], ['B', 'Y', 3, 4], ['C', 'Z', 5, 6], ['C', 'Z', 5, 6]]

原因

原因は14行目、19行目で複製すべきリストnew_rowを単純に代入しているためで、変数代入時に元のリストオブジェクトは複製されず重複して参照されるだけとなり、1つの変更が元のオブジェクトを通して全体に波及してしまう。

具体的にリストのi行目の処理を追うと以下の通り。

1回目のnew_row = source_list[i]で元リストのi行目が1次元リストとして共有される
そのリストの最後尾にカウンター値が追加され、カウンターがインクリメントされる
- この時点で1次元リストの最後尾にカウンター値が追加され、new_row、source_list[i]のいずれにも参照されている
新しいリストに1次元リストが行として追加される
- この時点で、source_list[i]、new_row、new_list[2*i]が共通の1次元リストを参照している
2回目のnew_row = source_list[i]で元リストのi行目が共有される（実はこの処理は1番目の繰り返しであり意味がない）
そのリストの最後尾にカウンター値が追加され、カウンターがインクリメントされる
- この時点で、先に最後尾にカウンター値追加済みの1次元リストの最後尾に更にカウンター値が追加され、new_row、source_list[i]のいずれにも参照されている
新しいリストに1次元リストが行として追加される
- この時点で、source_list[i]、new_row、new_list[2*i+1]が共通の1次元リストを参照している

この結果、source_listも以下のように変更される。

[['A', 'X', 1, 2], ['B', 'Y', 3, 4], ['C', 'Z', 5, 6]]

1	[['A', 'X', 1, 2], ['B', 'Y', 3, 4], ['C', 'Z', 5, 6]]

解決

この原因である重複参照を解消するため、元リスト各行の（参照を）代入するのではなく、copy()メソッドで新しいインスタンスを生成することで、想定した結果を得る。

source_list = [
    ["A", "X"],
    ["B", "Y"],
    ["C", "Z"]
]

print("Before:")
print(source_list)

new_list = []

counter = 1
for i in range(len(source_list)):
    new_row = source_list[i].copy()
    new_row.append(counter)
    counter += 1
    new_list.append(new_row)

    new_row = source_list[i].copy()
    new_row.append(counter)
    counter += 1
    new_list.append(new_row)

print("After:")
print(new_list)

# Before:
# [['A', 'X'], ['B', 'Y'], ['C', 'Z']]
# After:
# [['A', 'X', 1], ['A', 'X', 2], ['B', 'Y', 3], ['B', 'Y', 4], ['C', 'Z', 5], ['C', 'Z', 6]]

source_list = [

["A", "X"],

["B", "Y"],

["C", "Z"]

]

print("Before:")

print(source_list)

new_list = []

counter = 1

for i in range(len(source_list)):

new_row = source_list[i].copy()

new_row.append(counter)

counter += 1

new_list.append(new_row)

new_row = source_list[i].copy()

new_row.append(counter)

counter += 1

new_list.append(new_row)

print("After:")

print(new_list)

# Before:

# [['A', 'X'], ['B', 'Y'], ['C', 'Z']]

# After:

# [['A', 'X', 1], ['A', 'X', 2], ['B', 'Y', 3], ['B', 'Y', 4], ['C', 'Z', 5], ['C', 'Z', 6]]

結論

リストを代入するときに参照・複製を意識し、基本はcopy()で複製。

DataFrameのスピード～行の追加

2020-10-14 / tau / コメントする

概要

pandas.DataFrameで数千行のデータの組み換えをやろうとしたときにかなり時間がかかったので、簡単な例で実行時間を確認してみた。

結論から言うと、他の様々なサイトで言及されているように、「行単位の追加はかなり時間がかかるが、列単位の追加は圧倒的に早い」ということになる。また、先にリストなどでデータを構成しておいてからDataFrameを生成する方法も高速なことが分かった。

問題設定

次のように、3つの列を持つ行データを1万個、DataFrameに追加していく例を考える。

import time
import numpy as np
import pandas as pd

col_list = ['one', 'two', 'three']
row_to_add = [1, 2, 3]

start_time = time.time()

・・・それぞれの処理・・・

end_time = time.time()
print("erapse time {} sec".format(end_time - start_time))

import time

import numpy as np

import pandas as pd

col_list = ['one', 'two', 'three']

row_to_add = [1, 2, 3]

start_time = time.time()

・・・それぞれの処理・・・

end_time = time.time()

print("erapse time {} sec".format(end_time - start_time))

appendメソッド

appendメソッドは2つのDataFrameを結合するメソッドで、行の追加方法としてもよく紹介されている。実行結果は以下の通りで約7秒（3回繰り返して同程度）。

df = pd.DataFrame(columns=col_list)
for i in range(10000):
    df_to_add = pd.DataFrame([row_to_add], columns=col_list)
    df = df.append(df_to_add)

# erapse time 6.999355792999268 sec

df = pd.DataFrame(columns=col_list)

for i in range(10000):

df_to_add = pd.DataFrame([row_to_add], columns=col_list)

df = df.append(df_to_add)

# erapse time 6.999355792999268 sec

appendでリストをDataFrameにする際、リストをそのまま渡すと列と解釈されるので、2次元化して行であることを明示している。また列名を指定しないと新たな列として4～6列目に行が加えられていくので、加えるDataFrameでも列名を指定している。

リストをそのまま渡して列として生成し、行インデックスに列名を渡してDataFrameを生成してから'.T'で転置している例なども見られた。

なお、この場合のDataFrameの各要素は整数型となる。

     one two three
0      1   2     3
1      1   2     3
2      1   2     3
3      1   2     3
4      1   2     3
...   ..  ..   ...
9995   1   2     3
9996   1   2     3
9997   1   2     3
9998   1   2     3
9999   1   2     3

one two three

0 1 2 3

1 1 2 3

2 1 2 3

3 1 2 3

4 1 2 3

... .. .. ...

9995 1 2 3

9996 1 2 3

9997 1 2 3

9998 1 2 3

9999 1 2 3

locプロパティーはインデックス指定に注意

DataFrameのlocプロパティーは、スライスによって複数行・列の要素の参照・代入ができる。これを利用して、空のDataFrameに1行ずつ追加していく。実行時間は7秒台。

この場合のDataFrameの各要素も整数になる。

df = pd.DataFrame(columns=col_list)
for i in range(10000):
    df.loc[i, :] = row_to_add

# erapse time 7.583117246627808 sec

df = pd.DataFrame(columns=col_list)

for i in range(10000):

df.loc[i, :] = row_to_add

# erapse time 7.583117246627808 sec

興味深いのことに、loc[i:, ]ではなくてloc[i]で指定すると実行時間が倍以上、20秒近くになる。

df = pd.DataFrame(columns=col_list)
for i in range(10000):
    df.loc[i] = row_to_add

# erapse time 19.00727939605713 sec

df = pd.DataFrame(columns=col_list)

for i in range(10000):

df.loc[i] = row_to_add

# erapse time 19.00727939605713 sec

なお、locの代わりにilocを使うと"IndexError: iloc cannot enlarge its target object"とエラーになる。

DataFrameの領域を確保した場合

リストで確保した場合

予めデータのサイズがわかっている場合に、ダミーデータで埋めたリストで領域を確保してみる。領域を一気に確保して値を入れていくだけなので実行速度は速い。実行時間は0.7秒程度で、appendやlocで1行ずつ追加していくのに比べて1/10。

df = pd.DataFrame([[0] * 3] * 10000, columns=col_list)
for i in range(10000):
    df.loc[i, :] = row_to_add

# erapse time 0.6972208023071289 sec

df = pd.DataFrame([[0] * 3] * 10000, columns=col_list)

for i in range(10000):

df.loc[i, :] = row_to_add

# erapse time 0.6972208023071289 sec

ここでloc[i, :]をloc[i]とすると、実行時間は0.5秒程度と少し早くなる。これは1行ずつ追加する場合と逆の傾向だが、この場合はその差は追加の場合に比べて小さい。

なお、この方法では領域が既に確保されているのでilocに変更しても同じ結果となる。

ndarrayで確保した場合

リストではなくndarrayで領域を確保してみると、実行速度はリストの場合と同程度。

df = pd.DataFrame(np.empty((10000, 3)), columns=col_list)
for i in range(10000):
    df.loc[i, :] = row_to_add

# erapse time 0.6625535488128662 sec

df = pd.DataFrame(np.empty((10000, 3)), columns=col_list)

for i in range(10000):

df.loc[i, :] = row_to_add

# erapse time 0.6625535488128662 sec

ただし、この場合各要素は実数となる。整数が必要ならndarrayのコンストラクターでdtype='int'を指定する。

      one  two  three
0     1.0  2.0    3.0
1     1.0  2.0    3.0
2     1.0  2.0    3.0
3     1.0  2.0    3.0
4     1.0  2.0    3.0
...   ...  ...    ...
9995  1.0  2.0    3.0
9996  1.0  2.0    3.0
9997  1.0  2.0    3.0
9998  1.0  2.0    3.0
9999  1.0  2.0    3.0

one two three

0 1.0 2.0 3.0

1 1.0 2.0 3.0

2 1.0 2.0 3.0

3 1.0 2.0 3.0

4 1.0 2.0 3.0

... ... ... ...

9995 1.0 2.0 3.0

9996 1.0 2.0 3.0

9997 1.0 2.0 3.0

9998 1.0 2.0 3.0

9999 1.0 2.0 3.0

ここでndarrayのdtypeを整数で指定すると実行時間が以下のような傾向となった。

int8, int16→4秒台
int32, int64→0.6秒台

ワード境界の中に値を埋め込んでいくのに時間がかかっていると考えられる。

列ごとのリストを加える方法はかなり速い

列ごとの辞書でDataFrameを生成する方法

列ごとのリストを作っておいて、それらから全体のデータを辞書として準備し、DataFrameを生成する方法。

これは更に速く、実行時間は0.015秒前後。loc[i, :]で行ごとに加えていく方法の1/1000の時間で済むことになる。

one = []
two = []
three = []
for i in range(10000):
    one += [1]
    two += [2]
    three += [3]
all = [one, two, three]
df = pd.DataFrame(
    data={'one':one, 'two':two, 'three':three}, columns=col_list)

# erapse time 0.014957666397094727 sec

one = []

two = []

three = []

for i in range(10000):

one += [1]

two += [2]

three += [3]

all = [one, two, three]

df = pd.DataFrame(

data={'one':one, 'two':two, 'three':three}, columns=col_list)

# erapse time 0.014957666397094727 sec

ただし辞書のキーで列名を指定するところがやや煩雑か。

列単位でリストを加えていく方法

列ごとのリストを、順次DataFrameに加えていく方法。

この場合もかなり速いが、上の方法では実行時間が一定しているのに対して、こちらは0.015～0.03秒と少しばらついて、ほんの僅かだが遅め。

one = []
two = []
three = []
for i in range(10000):
    one += [1]
    two += [2]
    three += [3]
df = pd.DataFrame(columns=col_list)
df['one'] = one
df['two'] = two
df['three'] = three

# erapse time 0.020946025848388672 sec

one = []

two = []

three = []

for i in range(10000):

one += [1]

two += [2]

three += [3]

df = pd.DataFrame(columns=col_list)

df['one'] = one

df['two'] = two

df['three'] = three

# erapse time 0.020946025848388672 sec

列ごとのndarrayを加える方法

空のndarrayを準備して要素を加えていき、これを列単位でDataFrameに加える方法。

実行時間は0.25秒程度でリストの時の10倍の時間がかかっている。別途ndarrayの要素追加時部分だけの時間を計測すると、この部分だけで0.2秒台で、配列の要素追加のところで時間がかかっている。

one = np.empty(0, dtype=int)
two = np.empty(0)
three = np.empty(0)
for i in range(10000):
    one = np.append(one, [1])
    two = np.append(two, [2])
    three = np.append(three, [3])
df = pd.DataFrame(columns=col_list)
df['one'] = one
df['two'] = two
df['three'] = three
end_time = time.time()

# erapse time 0.24968528747558594 sec

one = np.empty(0, dtype=int)

two = np.empty(0)

three = np.empty(0)

for i in range(10000):

one = np.append(one, [1])

two = np.append(two, [2])

three = np.append(three, [3])

df = pd.DataFrame(columns=col_list)

df['one'] = one

df['two'] = two

df['three'] = three

end_time = time.time()

# erapse time 0.24968528747558594 sec

2次元リストから生成する方法がベスト

リストなどを列ごとに加えるのではなく、2次元のリストを構成しておいて、それを使ってDataFrameを生成する方法。

実行時間は0.01～0.02秒程度で、最も早い部類に入る。順次行を追加するという発想にコードも近く、速度・可読性ともに最適のようである。

list_data = []
for i in range(10000):
    list_data.append(row_to_add)
df = pd.DataFrame(list_data, columns=col_list)

# erapse time 0.011972188949584961 sec

list_data = []

for i in range(10000):

list_data.append(row_to_add)

df = pd.DataFrame(list_data, columns=col_list)

# erapse time 0.011972188949584961 sec

既存のDataFrameに追加する場合

既にデータがあるDataFrameに新たな行を追加する場合を考える。これまでの例で、どうやらリストの形で操作するのが速そうで、DataFrameからリストへの変換がそれなりに速いのなら、その方法が最もよさそうだと予想できる。

以下のコードはこのことを確認したもの。3つのパートに分かれていて、最初がこれまでと同じDataFrameの生成、次がDataFrameからリストへの変換、最後がリストへの追加と追加後のDataFrameの生成となっている。

DataFrameからリストへの変換は、to_numpy()メソッドでndarrayが得られるので（DataFrameのvaluesでもndarrayは非推奨）、それをtolist()メソッドでリストに変換している。

import time
import pandas as pd

start_time = time.time()
# First, prepare the original dataset

col_list = ('one', 'two', 'three')
list_data = []
initial_row = [1, 2, 3]

for i in range(10000):
    list_data.append(initial_row)

df = pd.DataFrame(list_data, columns=col_list)

time_to_create = time.time()
print(df)

# Second, prepare the list to add new data
list_data = df.to_numpy().tolist()
time_to_prepare_list = time.time()

# Finally, add new data to list and generate the new DataFrame
row_to_add = [10, 20, 30]

for i in range(10000):
    list_data.append(row_to_add)

df = pd.DataFrame(list_data, columns=col_list)

time_to_append = time.time()
print(df)

print("time to create :{} sec".format(time_to_create - start_time))
print("time to prepare:{} sec".format(time_to_prepare_list - time_to_create))
print("time to append :{} sec".format(time_to_append - time_to_prepare_list))

# time to create :0.0070116519927978516 sec
# time to prepare:0.006953001022338867 sec
# time to append :0.012996912002563477 sec

import time

import pandas as pd

start_time = time.time()

# First, prepare the original dataset

col_list = ('one', 'two', 'three')

list_data = []

initial_row = [1, 2, 3]

for i in range(10000):

list_data.append(initial_row)

df = pd.DataFrame(list_data, columns=col_list)

time_to_create = time.time()

print(df)

# Second, prepare the list to add new data

list_data = df.to_numpy().tolist()

time_to_prepare_list = time.time()

# Finally, add new data to list and generate the new DataFrame

row_to_add = [10, 20, 30]

for i in range(10000):

list_data.append(row_to_add)

df = pd.DataFrame(list_data, columns=col_list)

time_to_append = time.time()

print(df)

print("time to create :{} sec".format(time_to_create - start_time))

print("time to prepare:{} sec".format(time_to_prepare_list - time_to_create))

print("time to append :{} sec".format(time_to_append - time_to_prepare_list))

# time to create :0.0070116519927978516 sec

# time to prepare:0.006953001022338867 sec

# time to append :0.012996912002563477 sec

結果はかなり高速で、DataFrameのままでlocで追加するよりもはるかに速い。

まとめ

今回のケースの場合、1万行の追加でlocを使うと7秒で1行当たり0.0007秒。100行まとめて追加すると0.07秒で、この時点でリストに変換して追加した方が速くなる。

数少ない行を低頻度で追加するのでなければ、DataFrameにまとまった行を追加したり、既にあるDataFrameの構造を変換するには、一旦リストに変換してからデータを追加し、DataFrameに変換し直した方が速いと言える。

Python3 – zip関数

2020-10-14 / tau / コメントする

概要

組み込み関数zip()は、引数のコレクションやイテレーターの要素を組み合わせた値を返すイテレーター。ジッパーの左右の小さな金具が交互に合わさって一つになるイメージ。

使い方

zip()の引数に、1つにしたい複数のコレクションを与える。戻り値はイテレーター。

list1 = ['Tokyo', 'Aichi', 'Osaka']
list2 = [13, 23, 27]

print(zip(list1, list2))
# <zip object at 0x0000015B8AB51640>

print(list(zip(list1, list2)))
# [('Tokyo', 13), ('Aichi', 23), ('Osaka', 27)]

list1 = ['Tokyo', 'Aichi', 'Osaka']

list2 = [13, 23, 27]

print(zip(list1, list2))

# <zip object at 0x0000015B8AB51640>

print(list(zip(list1, list2)))

# [('Tokyo', 13), ('Aichi', 23), ('Osaka', 27)]

イテレーターなのでforループなどに使える。

for item1, item2 in zip(list1, list2):
    print(item1, item2)

# Tokyo 13
# Aichi 23
# Osaka 27

for item1, item2 in zip(list1, list2):

print(item1, item2)

# Tokyo 13

# Aichi 23

# Osaka 27

引数はコレクションのほかイテレーターも可能。

for item1, item2 in zip(range(1, 7, 2),  range(2, 8, 2)):
    print(item1, item2)

# 1 2
# 3 4
# 5 6

for item1, item2 in zip(range(1, 7, 2), range(2, 8, 2)):

print(item1, item2)

# 1 2

# 3 4

# 5 6

引数が3つ以上でも可能。

list1 = [1, 4, 7]
list2 = [2, 5, 8]
list3 = [3, 6, 9]

for item1, item2, item3 in zip(list1, list2, list3):
    print(item1, item2, item3)

# 1 2 3
# 4 5 6
# 7 8 9

list1 = [1, 4, 7]

list2 = [2, 5, 8]

list3 = [3, 6, 9]

for item1, item2, item3 in zip(list1, list2, list3):

print(item1, item2, item3)

# 1 2 3

# 4 5 6

# 7 8 9

リスト化した時の表現

zip()をリスト化した時の結果list(zip())を確認しておく。1つにまとめられた内容が、それぞれタプルとなっている。

list1 = ['Tokyo', 'Aichi', 'Osaka']
list2 = [13, 23, 27]
print(list(zip(list1, list2)))
# [('Tokyo', 13), ('Aichi', 23), ('Osaka', 27)]

list1 = [1, 4, 7]
list2 = [2, 5, 8]
list3 = [3, 6, 9]
print(list(zip(list1, list2, list3)))
# [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

list1 = ['Tokyo', 'Aichi', 'Osaka']

list2 = [13, 23, 27]

print(list(zip(list1, list2)))

# [('Tokyo', 13), ('Aichi', 23), ('Osaka', 27)]

list1 = [1, 4, 7]

list2 = [2, 5, 8]

list3 = [3, 6, 9]

print(list(zip(list1, list2, list3)))

# [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

引数の長さが違うとき

引数のコレクションやイテレーターの長さが異なるときは、短いものに合わされて、他のの残りの内容は無視される。

list1 = [1, 2, 3]
list2 = [10, 20, 30, 40, 50]

print(list(zip(list1, list2)))

# [(1, 10), (2, 20), (3, 30)]

list1 = [1, 2, 3]

list2 = [10, 20, 30, 40, 50]

print(list(zip(list1, list2)))

# [(1, 10), (2, 20), (3, 30)]

itertools.zip_longest()を使うと、最も長いものに合わされて、残りが指定された値で埋められる。

直接関係ないこと～zipper

“zipper”という言葉はAmerican Englishで、グッドリッチ社の商標登録だった言葉がいわゆるファスナーを指す名詞になったようだ。British Englishではzipが名詞としてファスナーの意味となる。

動詞のzipはzipperから「（ファスナーで）締める」という意味を持つ。そもそもzipという動詞には、素早く動く、飛んでいくといった意味があるらしい(informal to go somewhere or do something very quickly ~ LONGMAN)。が、日本語サイトの英和辞書では後者の訳が先に出ているが、LONGMAN/Camblidge/Oxfordなどのオンライン辞書では前者のファスナー関係の訳が先に来ている。日本語サイトがnativeの感覚と異っているのがわかる。

概要

列の参照

DataFrameで列名を直接指定

1つの列を指定

ファンシー・インデックスによる複数列の指定

locによる列の指定

1つの列の指定

スライスによる連続した列の指定

ファンシーインデックスによる複数列の指定

列の追加

DataFrameで直接列名を指定して追加

locでスライス指定して追加

assignメソッドによる追加

insertメソッドによる途中への追加

列の更新

DataFrameで列名を直接指定

1つの列を指定

ファンシーインデックスによる複数列の指定

locによる列名・スライスの指定

1つの列の指定

スライスによる連続した列の指定

ファンシーインデックスによる複数列の指定

列の削除

例題のデータ

1列の削除

複数列の削除

連続した列の削除

要素の操作

at/iat～単独要素の参照・変更

at～インデックス指定

iat～行・列番号指定

loc/iloc～単独要素・スライスの参照・変更

loc～インデックス指定／終端含む

iloc～行・列番号指定／終端含まず

概要

配列は不適

リストはOK

列の辞書もOK

リスト・配列からの生成

リストからの生成

ndarrayからの生成

列名・行インデックスの設定

列リストと辞書による

概要

行数・列数・サイズ

行名・インデックス・データの内容

列名～columns

行名～index

データの内容～values

リストの初期化

問題

原因

解決

結論

概要

問題設定

appendメソッド

locプロパティーはインデックス指定に注意

DataFrameの領域を確保した場合

リストで確保した場合

ndarrayで確保した場合

列ごとのリストを加える方法はかなり速い

列ごとの辞書でDataFrameを生成する方法

列単位でリストを加えていく方法

列ごとのndarrayを加える方法

2次元リストから生成する方法がベスト

既存のDataFrameに追加する場合

まとめ

概要

使い方

リスト化した時の表現

引数の長さが違うとき

直接関係ないこと～zipper

`loc`による列の指定

`DataFrame`で直接列名を指定して追加

`loc`でスライス指定して追加

`assign`メソッドによる追加

`insert`メソッドによる途中への追加

`DataFrame`で列名を直接指定

`loc`による列名・スライスの指定

`at/iat`～単独要素の参照・変更

`at`～インデックス指定

`iat`～行・列番号指定

`loc/iloc`～単独要素・スライスの参照・変更

`loc`～インデックス指定／終端含む

`iloc`～行・列番号指定／終端含まず

列名～`columns`

行名～`index`

データの内容～`values`