DataFrame – get_dummies – One-hot

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

概要

DataFrameのget_dummies()メソッドは、属性データ（カテゴリーデータ）をone-hot-encodingの形に変換してくれる。

Scikit-learnにもOneHotEncoderがあるが、get_dumies()はデータの切り貼りをせずにダイレクトに属性変数だけをone-hotの形にしてくれるので便利。

基本

get_dumies()の引数にDataFrameを指定すると、文字列で属性指定されたデータが自動で認識されてon-hotの形に変換される。

import pandas as pd

data = [
    ["male", 1200],
    ["male", 1000],
    ["male", 800],
    ["female", 1500],
    ["female", 800]
]

df = pd.DataFrame(data, columns=["gender", "price"])
print(df)
#    gender  price
# 0    male   1200
# 1    male   1000
# 2    male    800
# 3  female   1500
# 4  female    800

print(pd.get_dummies(df))
#    price  gender_female  gender_male
# 0   1200              0            1
# 1   1000              0            1
# 2    800              0            1
# 3   1500              1            0
# 4    800              1            0

import pandas as pd

data = [

["male", 1200],

["male", 1000],

["male", 800],

["female", 1500],

["female", 800]

]

df = pd.DataFrame(data, columns=["gender", "price"])

print(df)

# gender price

# 0 male 1200

# 1 male 1000

# 2 male 800

# 3 female 1500

# 4 female 800

print(pd.get_dummies(df))

# price gender_female gender_male

# 0 1200 0 1

# 1 1000 0 1

# 2 800 0 1

# 3 1500 1 0

# 4 800 1 0

分解された列名は、"元の列名_属性名"となり、それぞれに対応する属性の列のみが1、その他の列は0となる。列の並びは、属性名の辞書順。数値データの列は無視される。

属性データが複数列の場合

文字列の属性データが複数列ある場合も、自動的にone-hotに分解してくれる。

data = [
    ["male", "Tokyo", 10000],
    ["male", "Tokyo", 70000],
    ["female", "Tokyo", 80000],
    ["male", "Nagoya", 7000],
    ["female", "Nagoya", 8000],
    ["female", "Nagoya", 6000],
    ["male", "Osaka", 9000],
    ["female", "Osaka", 79000],
]

df = pd.DataFrame(data, columns=["gender", "city", "price"])
print(df)
#    gender    city  price
# 0    male   Tokyo  10000
# 1    male   Tokyo  70000
# 2  female   Tokyo  80000
# 3    male  Nagoya   7000
# 4  female  Nagoya   8000
# 5  female  Nagoya   6000
# 6    male   Osaka   9000
7  female   Osaka  79000

print(pd.get_dummies(df))
#    price  gender_female  gender_male  city_Nagoya  city_Osaka  city_Tokyo
# 0  10000              0            1            0           0           1
# 1  70000              0            1            0           0           1
# 2  80000              1            0            0           0           1
# 3   7000              0            1            1           0           0
# 4   8000              1            0            1           0           0
# 5   6000              1            0            1           0           0
# 6   9000              0            1            0           1           0
# 7  79000              1            0            0           1           0

data = [

["male", "Tokyo", 10000],

["male", "Tokyo", 70000],

["female", "Tokyo", 80000],

["male", "Nagoya", 7000],

["female", "Nagoya", 8000],

["female", "Nagoya", 6000],

["male", "Osaka", 9000],

["female", "Osaka", 79000],

]

df = pd.DataFrame(data, columns=["gender", "city", "price"])

print(df)

# gender city price

# 0 male Tokyo 10000

# 1 male Tokyo 70000

# 2 female Tokyo 80000

# 3 male Nagoya 7000

# 4 female Nagoya 8000

# 5 female Nagoya 6000

# 6 male Osaka 9000

7 female Osaka 79000

print(pd.get_dummies(df))

# price gender_female gender_male city_Nagoya city_Osaka city_Tokyo

# 0 10000 0 1 0 0 1

# 1 70000 0 1 0 0 1

# 2 80000 1 0 0 0 1

# 3 7000 0 1 1 0 0

# 4 8000 1 0 1 0 0

# 5 6000 1 0 1 0 0

# 6 9000 0 1 0 1 0

# 7 79000 1 0 0 1 0

属性が数値表現の場合

属性値が文字列ではなく数値表現の場合、get_dummies()の引数に単にDataFrameを渡すだけでは変換してくれない（通常の数量データとして認識される）。

そこで、変換したい列をcolumns引数で指定する。

data = [
    [1, 10, 100],
    [1, 20, 100],
    [2, 10, 200],
    [1, 20, 200],
    [1, 30, 100],
]

df = pd.DataFrame(data, columns=["id1", "id2", "value"])
print(df)
#    id1  id2  value
# 0    1   10    100
# 1    1   20    100
# 2    2   10    200
# 3    1   20    200
# 4    1   30    100

print(pd.get_dummies(df, columns=["id1"]))
#    id2  value  id1_1  id1_2
# 0   10    100      1      0
# 1   20    100      1      0
# 2   10    200      0      1
# 3   20    200      1      0
# 4   30    100      1      0

data = [

[1, 10, 100],

[1, 20, 100],

[2, 10, 200],

[1, 20, 200],

[1, 30, 100],

]

df = pd.DataFrame(data, columns=["id1", "id2", "value"])

print(df)

# id1 id2 value

# 0 1 10 100

# 1 1 20 100

# 2 2 10 200

# 3 1 20 200

# 4 1 30 100

print(pd.get_dummies(df, columns=["id1"]))

# id2 value id1_1 id1_2

# 0 10 100 1 0

# 1 20 100 1 0

# 2 10 200 0 1

# 3 20 200 1 0

# 4 30 100 1 0

複数の属性データの列がある場合、columns引数でリスト指定する。

print(pd.get_dummies(df, columns=["id1", "id2"]))

#    value  id1_1  id1_2  id2_10  id2_20  id2_30
# 0    100      1      0       1       0       0
# 1    100      1      0       0       1       0
# 2    200      0      1       1       0       0
# 3    200      1      0       0       1       0
# 4    100      1      0       0       0       1

print(pd.get_dummies(df, columns=["id1", "id2"]))

# value id1_1 id1_2 id2_10 id2_20 id2_30

# 0 100 1 0 1 0 0

# 1 100 1 0 0 1 0

# 2 200 0 1 1 0 0

# 3 200 1 0 0 1 0

# 4 100 1 0 0 0 1

属性名の指定

prefix引数で文字列を指定すると、属性名がその文字列で置き換えられる。ただし複数の属性列が全て同じ文字列になる。

print(pd.get_dummies(df, columns=["id1", "id2"], prefix="attr"))

#    value  attr_1  attr_2  attr_10  attr_20  attr_30
# 0    100       1       0        1        0        0
# 1    100       1       0        0        1        0
# 2    200       0       1        1        0        0
# 3    200       1       0        0        1        0
# 4    100       1       0        0        0        1

print(pd.get_dummies(df, columns=["id1", "id2"], prefix="attr"))

# value attr_1 attr_2 attr_10 attr_20 attr_30

# 0 100 1 0 1 0 0

# 1 100 1 0 0 1 0

# 2 200 0 1 1 0 0

# 3 200 1 0 0 1 0

# 4 100 1 0 0 0 1

属性列ごとにprefixを変えて指定したい場合はリストで指定。

print(pd.get_dummies(df, columns=["id1", "id2"], prefix=["attr", "cat"]))

#    value  attr_1  attr_2  cat_10  cat_20  cat_30
# 0    100       1       0       1       0       0
# 1    100       1       0       0       1       0
# 2    200       0       1       1       0       0
# 3    200       1       0       0       1       0
# 4    100       1       0       0       0       1

print(pd.get_dummies(df, columns=["id1", "id2"], prefix=["attr", "cat"]))

# value attr_1 attr_2 cat_10 cat_20 cat_30

# 0 100 1 0 1 0 0

# 1 100 1 0 0 1 0

# 2 200 0 1 1 0 0

# 3 200 1 0 0 1 0

# 4 100 1 0 0 0 1

DataFrame – データの概観

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

概要

DataFrameの規模、格納されているデータの概要や基礎統計量を概観する各種の手順。Scikit-learnのBoston housingデータセットを例にする。

DataFrameの規模・形状

sizeプロパティーで全データ数、shapeプロパティーで行数と列数を確認。

import pandas as pd
from sklearn.datasets import load_boston

ds = load_boston()
df = pd.DataFrame(ds.data, columns=ds.feature_names)

print(df.size)
# 6578

print(df.shape)
# (506, 13)

import pandas as pd

from sklearn.datasets import load_boston

ds = load_boston()

df = pd.DataFrame(ds.data, columns=ds.feature_names)

print(df.size)

# 6578

print(df.shape)

# (506, 13)

データの先頭部分と末尾部分

head()メソッド／tail()メソッドで先頭／末尾の5行分が得られる。引数で抜き出す行数を指定。

print(df.head())
#       CRIM    ZN  INDUS  CHAS    NOX  ...  RAD    TAX  PTRATIO       B  LSTAT
# 0  0.00632  18.0   2.31   0.0  0.538  ...  1.0  296.0     15.3  396.90   4.98
# 1  0.02731   0.0   7.07   0.0  0.469  ...  2.0  242.0     17.8  396.90   9.14
# 2  0.02729   0.0   7.07   0.0  0.469  ...  2.0  242.0     17.8  392.83   4.03
# 3  0.03237   0.0   2.18   0.0  0.458  ...  3.0  222.0     18.7  394.63   2.94
# 4  0.06905   0.0   2.18   0.0  0.458  ...  3.0  222.0     18.7  396.90   5.33
# 
# [5 rows x 13 columns]

print(df.tail(3))
#         CRIM   ZN  INDUS  CHAS    NOX  ...  RAD    TAX  PTRATIO       B  LSTAT
# 503  0.06076  0.0  11.93   0.0  0.573  ...  1.0  273.0     21.0  396.90   5.64
# 504  0.10959  0.0  11.93   0.0  0.573  ...  1.0  273.0     21.0  393.45   6.48
# 505  0.04741  0.0  11.93   0.0  0.573  ...  1.0  273.0     21.0  396.90   7.88
# 
# [3 rows x 13 columns]

print(df.head())

# CRIM ZN INDUS CHAS NOX ... RAD TAX PTRATIO B LSTAT

# 0 0.00632 18.0 2.31 0.0 0.538 ... 1.0 296.0 15.3 396.90 4.98

# 1 0.02731 0.0 7.07 0.0 0.469 ... 2.0 242.0 17.8 396.90 9.14

# 2 0.02729 0.0 7.07 0.0 0.469 ... 2.0 242.0 17.8 392.83 4.03

# 3 0.03237 0.0 2.18 0.0 0.458 ... 3.0 222.0 18.7 394.63 2.94

# 4 0.06905 0.0 2.18 0.0 0.458 ... 3.0 222.0 18.7 396.90 5.33

# [5 rows x 13 columns]

print(df.tail(3))

# CRIM ZN INDUS CHAS NOX ... RAD TAX PTRATIO B LSTAT

# 503 0.06076 0.0 11.93 0.0 0.573 ... 1.0 273.0 21.0 396.90 5.64

# 504 0.10959 0.0 11.93 0.0 0.573 ... 1.0 273.0 21.0 393.45 6.48

# 505 0.04741 0.0 11.93 0.0 0.573 ... 1.0 273.0 21.0 396.90 7.88

# [3 rows x 13 columns]

`info()`～各列の基本情報の表示

info()メソッドは、DataFrameの概要に関する概略情報を出力する。直接標準出力にプリントする点に注意。

df.info()

# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 506 entries, 0 to 505
# Data columns (total 13 columns):
#  #   Column   Non-Null Count  Dtype  
# ---  ------   --------------  -----  
#  0   CRIM     506 non-null    float64
#  1   ZN       506 non-null    float64
#  2   INDUS    506 non-null    float64
#  3   CHAS     506 non-null    float64
#  4   NOX      506 non-null    float64
#  5   RM       506 non-null    float64
#  6   AGE      506 non-null    float64
#  7   DIS      506 non-null    float64
#  8   RAD      506 non-null    float64
#  9   TAX      506 non-null    float64
#  10  PTRATIO  506 non-null    float64
#  11  B        506 non-null    float64
#  12  LSTAT    506 non-null    float64
# dtypes: float64(13)
# memory usage: 51.5 KB

df.info()

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

# RangeIndex: 506 entries, 0 to 505

# Data columns (total 13 columns):

# # Column Non-Null Count Dtype

# --- ------ -------------- -----

# 0 CRIM 506 non-null float64

# 1 ZN 506 non-null float64

# 2 INDUS 506 non-null float64

# 3 CHAS 506 non-null float64

# 4 NOX 506 non-null float64

# 5 RM 506 non-null float64

# 6 AGE 506 non-null float64

# 7 DIS 506 non-null float64

# 8 RAD 506 non-null float64

# 9 TAX 506 non-null float64

# 10 PTRATIO 506 non-null float64

# 11 B 506 non-null float64

# 12 LSTAT 506 non-null float64

# dtypes: float64(13)

# memory usage: 51.5 KB

たとえば一部にNaNが含まれる場合の出力は以下のようになる。

import numpy as np
df1 = pd.DataFrame(np.arange(15).reshape(-1, 3), columns=["a", "b", "c"])
df1.loc[1, "b"] = np.nan
df1.loc[3, "c"] = np.nan

df1.info()

# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 5 entries, 0 to 4
# Data columns (total 3 columns):
#  #   Column  Non-Null Count  Dtype  
# ---  ------  --------------  -----  
#  0   a       5 non-null      int32  
#  1   b       4 non-null      float64
#  2   c       4 non-null      float64
# dtypes: float64(2), int32(1)
# memory usage: 228.0 bytes

import numpy as np

df1 = pd.DataFrame(np.arange(15).reshape(-1, 3), columns=["a", "b", "c"])

df1.loc[1, "b"] = np.nan

df1.loc[3, "c"] = np.nan

df1.info()

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

# RangeIndex: 5 entries, 0 to 4

# Data columns (total 3 columns):

# # Column Non-Null Count Dtype

# --- ------ -------------- -----

# 0 a 5 non-null int32

# 1 b 4 non-null float64

# 2 c 4 non-null float64

# dtypes: float64(2), int32(1)

# memory usage: 228.0 bytes

`dscribe()`～基本的な統計量

describe()メソッドは、各列のデータについて、個数や平均といった基本的な統計量を計算する。

print(df.describe())

#              CRIM          ZN       INDUS  ...     PTRATIO           B       LSTAT
# count  506.000000  506.000000  506.000000  ...  506.000000  506.000000  506.000000
# mean     3.613524   11.363636   11.136779  ...   18.455534  356.674032   12.653063
# std      8.601545   23.322453    6.860353  ...    2.164946   91.294864    7.141062
# min      0.006320    0.000000    0.460000  ...   12.600000    0.320000    1.730000
# 25%      0.082045    0.000000    5.190000  ...   17.400000  375.377500    6.950000
# 50%      0.256510    0.000000    9.690000  ...   19.050000  391.440000   11.360000
# 75%      3.677083   12.500000   18.100000  ...   20.200000  396.225000   16.955000
# max     88.976200  100.000000   27.740000  ...   22.000000  396.900000   37.970000

print(df.describe())

# CRIM ZN INDUS ... PTRATIO B LSTAT

# count 506.000000 506.000000 506.000000 ... 506.000000 506.000000 506.000000

# mean 3.613524 11.363636 11.136779 ... 18.455534 356.674032 12.653063

# std 8.601545 23.322453 6.860353 ... 2.164946 91.294864 7.141062

# min 0.006320 0.000000 0.460000 ... 12.600000 0.320000 1.730000

# 25% 0.082045 0.000000 5.190000 ... 17.400000 375.377500 6.950000

# 50% 0.256510 0.000000 9.690000 ... 19.050000 391.440000 11.360000

# 75% 3.677083 12.500000 18.100000 ... 20.200000 396.225000 16.955000

# max 88.976200 100.000000 27.740000 ... 22.000000 396.900000 37.970000

特定の列の統計量を見たいときは列を指定。

なおstd（標準偏差）については、ddof=1を指定した結果と同じであり、n−1で割った不偏分散。

print(df["CRIM"].describe())
# count    506.000000
# mean       3.613524
# std        8.601545
# min        0.006320
# 25%        0.082045
# 50%        0.256510
# 75%        3.677083
# max       88.976200
# Name: CRIM, dtype: float64

print(df["CRIM"].std(ddof=1))
# 8.60154510533249

print(df["CRIM"].describe())

# count 506.000000

# mean 3.613524

# std 8.601545

# min 0.006320

# 25% 0.082045

# 50% 0.256510

# 75% 3.677083

# max 88.976200

# Name: CRIM, dtype: float64

print(df["CRIM"].std(ddof=1))

# 8.60154510533249

全ての列を見たいときには、set_option()メソッドの引数でdisplay.max_columnsパラメーターを指定する。初期値に戻すときはreset_option()メソッド。

pd.set_option('display.max_columns', 100)
print(df.describe())
pd.reset_option('display.max_columns')

#              CRIM          ZN       INDUS        CHAS         NOX          RM  \
# count  506.000000  506.000000  506.000000  506.000000  506.000000  506.000000   
# mean     3.613524   11.363636   11.136779    0.069170    0.554695    6.284634   
# std      8.601545   23.322453    6.860353    0.253994    0.115878    0.702617   
# min      0.006320    0.000000    0.460000    0.000000    0.385000    3.561000   
# 25%      0.082045    0.000000    5.190000    0.000000    0.449000    5.885500   
# 50%      0.256510    0.000000    9.690000    0.000000    0.538000    6.208500   
# 75%      3.677083   12.500000   18.100000    0.000000    0.624000    6.623500   
# max     88.976200  100.000000   27.740000    1.000000    0.871000    8.780000   
# 
#               AGE         DIS         RAD         TAX     PTRATIO           B  \
# count  506.000000  506.000000  506.000000  506.000000  506.000000  506.000000   
# mean    68.574901    3.795043    9.549407  408.237154   18.455534  356.674032   
# std     28.148861    2.105710    8.707259  168.537116    2.164946   91.294864   
# min      2.900000    1.129600    1.000000  187.000000   12.600000    0.320000   
# 25%     45.025000    2.100175    4.000000  279.000000   17.400000  375.377500   
# 50%     77.500000    3.207450    5.000000  330.000000   19.050000  391.440000   
# 75%     94.075000    5.188425   24.000000  666.000000   20.200000  396.225000   
# max    100.000000   12.126500   24.000000  711.000000   22.000000  396.900000   
# 
#             LSTAT  
# count  506.000000  
# mean    12.653063  
# std      7.141062  
# min      1.730000  
# 25%      6.950000  
# 50%     11.360000
# 75%     16.955000
# max     37.970000

pd.set_option('display.max_columns', 100)

print(df.describe())

pd.reset_option('display.max_columns')

# CRIM ZN INDUS CHAS NOX RM \

# count 506.000000 506.000000 506.000000 506.000000 506.000000 506.000000

# mean 3.613524 11.363636 11.136779 0.069170 0.554695 6.284634

# std 8.601545 23.322453 6.860353 0.253994 0.115878 0.702617

# min 0.006320 0.000000 0.460000 0.000000 0.385000 3.561000

# 25% 0.082045 0.000000 5.190000 0.000000 0.449000 5.885500

# 50% 0.256510 0.000000 9.690000 0.000000 0.538000 6.208500

# 75% 3.677083 12.500000 18.100000 0.000000 0.624000 6.623500

# max 88.976200 100.000000 27.740000 1.000000 0.871000 8.780000

# AGE DIS RAD TAX PTRATIO B \

# count 506.000000 506.000000 506.000000 506.000000 506.000000 506.000000

# mean 68.574901 3.795043 9.549407 408.237154 18.455534 356.674032

# std 28.148861 2.105710 8.707259 168.537116 2.164946 91.294864

# min 2.900000 1.129600 1.000000 187.000000 12.600000 0.320000

# 25% 45.025000 2.100175 4.000000 279.000000 17.400000 375.377500

# 50% 77.500000 3.207450 5.000000 330.000000 19.050000 391.440000

# 75% 94.075000 5.188425 24.000000 666.000000 20.200000 396.225000

# max 100.000000 12.126500 24.000000 711.000000 22.000000 396.900000

# LSTAT

# count 506.000000

# mean 12.653063

# std 7.141062

# min 1.730000

# 25% 6.950000

# 50% 11.360000

# 75% 16.955000

# max 37.970000

属性変数のカウント

属性変数の属性値のカウントには、value_counts()メソッドを使う。このメソッドは、ユニークな値の数をカウントして集計する。

print(df["CHAS"].value_counts())
# 0.0    471
# 1.0     35
# Name: CHAS, dtype: int64

print(df["RAD"].value_counts())
# 24.0    132
# 5.0     115
# 4.0     110
# 3.0      38
# 6.0      26
# 8.0      24
# 2.0      24
# 1.0      20
# 7.0      17
# Name: RAD, dtype: int64

print(df["CHAS"].value_counts())

# 0.0 471

# 1.0 35

# Name: CHAS, dtype: int64

print(df["RAD"].value_counts())

# 24.0 132

# 5.0 115

# 4.0 110

# 3.0 38

# 6.0 26

# 8.0 24

# 2.0 24

# 1.0 20

# 7.0 17

# Name: RAD, dtype: int64

2つの属性変数をファンシーインデックスで指定すると、「2つの属性のユニークな組み合わせ」の数が集計される。

print(df[["CHAS", "RAD"]].value_counts())

# CHAS  RAD 
# 0.0   24.0    124
#       5.0     104
#       4.0     102
#       3.0      36
#       6.0      26
#       2.0      24
#       8.0      19
#       1.0      19
#       7.0      17
# 1.0   5.0      11
#       24.0      8
#       4.0       8
#       8.0       5
#       3.0       2
#       1.0       1
# dtype: int64

print(df[["CHAS", "RAD"]].value_counts())

# CHAS RAD

# 0.0 24.0 124

# 5.0 104

# 4.0 102

# 3.0 36

# 6.0 26

# 2.0 24

# 8.0 19

# 1.0 19

# 7.0 17

# 1.0 5.0 11

# 24.0 8

# 4.0 8

# 8.0 5

# 3.0 2

# 1.0 1

# dtype: int64

Python – 行・列単位の合計・率の計算

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

概要

2次元のndarrayやDataFrameで、行単位や列単位での合計を計算したり、それを使って行単位／列単位の率を計算する方法。

2次元のndarrayの場合は、

合計はsum()メソッドの引数にaxisを指定
- 列和ならaxis=0、行和ならaxis=1
- 結果は1次元配列で得られる
率の計算はこれらの合計の配列を使うが、列和に対する各列要素の率なら1次元配列の行ベクトルのまま、行和に対する各行要素の率なら2次元の列ベクトルに変換して除算

DataFrameの場合、まず合計を求めるには、

合計はsum()メソッドの引数にaxisを指定
- 列和ならaxis=0、行和ならaxis=1
- 結果はSeriesオブジェクトで得られる

その上で率の計算には2通りある。1つ目はSeriesオブジェクトの内容をndarrayとして取り出して計算する方法で、

Series.valuesで列和／行和の配列を取り出し、ndarrayの場合と同じ方法で計算する

もう1つの方法はSeriesオブジェクトのままでdiv()メソッドにaxisを指定する方法で、

列和に対する各列要素の率を計算するには、div(列和Series, axis=1)
行和に対する各行要素の率を計算するには、div(列和Series, axis=0)

`ndarray`の場合

確認

まず確認のために、以下の配列を準備する。

import numpy as np

a = np.arange(1, 10).reshape(3, 3)
vrow = np.arange(1, 4)
vcol = np.arange(1, 4).reshape(-1, 1)

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

print(vrow)
# [1 2 3]

print(vcol)
# [[1]
#  [2]
#  [3]]
# ]

import numpy as np

a = np.arange(1, 10).reshape(3, 3)

vrow = np.arange(1, 4)

vcol = np.arange(1, 4).reshape(-1, 1)

print(a)

# [[1 2 3]

# [4 5 6]

# [7 8 9]]

print(vrow)

# [1 2 3]

print(vcol)

# [[1]

# [2]

# [3]]

# ]

行ベクトルを2次元配列に加えると、配列の各行に対して行ベクトルが加えらえる。

print(a + vrow)

# [[ 2  4  6]
#  [ 5  7  9]
#  [ 8 10 12]]

print(a + vrow)

# [[ 2 4 6]

# [ 5 7 9]

# [ 8 10 12]]

列ベクトルを2次元配列に加えると、配列の各列に対して列ベクトルが加えられる。

print(a + vcol)

# [[ 2  3  4]
#  [ 6  7  8]
#  [10 11 12]]

print(a + vcol)

# [[ 2 3 4]

# [ 6 7 8]

# [10 11 12]]

つまり、ndarrayの2次元配列に行または列のベクトルを加えると、加える方のベクトルの形状に合わせて各行／列に演算が実行される。これは他のオペレーターについても同じ。

この演算は直感的にも分かりやすく、列ごと／行ごとの小計に対する比率の計算も思い浮かべることができる。

合計

ndarrayの各列／行に沿った合計を計算する。合計計算はndarrayのsum()メソッドを使うが、引数を省略すると全要素の和となる。引数にaxis=0を指定すると列方向に処理がされ（つまり配列の各列の要素が列方向に足され）、axis=1を指定すると行方向に処理がされる（つまり配列の各行の要素が行方向に足される）。

以下の例は、最初に使った2次元配列の列方向の和（の行ベクトル）と行方向の和（の列ベクトル）を計算している。

sums_along_cols = a.sum(axis=0)
sums_along_rows = a.sum(axis=1).reshape(-1, 1)

print(sums_along_cols)
# [12 15 18]

print(sums_along_rows)
# [[ 6]
#  [15]
#  [24]]

sums_along_cols = a.sum(axis=0)

sums_along_rows = a.sum(axis=1).reshape(-1, 1)

print(sums_along_cols)

# [12 15 18]

print(sums_along_rows)

# [[ 6]

# [15]

# [24]]

率の計算

2次元配列を行合計ベクトルで割ると、各行の要素が合計ベクトルの各要素で割られる（各列の行要素の合計は1になる）。

print(a / sums_along_cols)

# [[0.08333333 0.13333333 0.16666667]
#  [0.33333333 0.33333333 0.33333333]
#  [0.58333333 0.53333333 0.5       ]]

# NOTE
# 1/12 2/15 3/18
# 4/12 5/15 6/18
# 7/12 8/15 9/18

print(a / sums_along_cols)

# [[0.08333333 0.13333333 0.16666667]

# [0.33333333 0.33333333 0.33333333]

# [0.58333333 0.53333333 0.5 ]]

# NOTE

# 1/12 2/15 3/18

# 4/12 5/15 6/18

# 7/12 8/15 9/18

また、2次元配列を列合計ベクトルで割ると、各列の要素が合計ベクトルの各要素で割られる。繰り返しになるが、この場合の合計ベクトルは2次元の列ベクトルになっている。

print(a / sums_along_rows)

# [[0.16666667 0.33333333 0.5       ]
#  [0.26666667 0.33333333 0.4       ]
#  [0.29166667 0.33333333 0.375     ]]

# NOTE
#  1/6  2/6  3/6
# 4/15 5/15 6/15
# 7/24 8/24 9/24

print(a / sums_along_rows)

# [[0.16666667 0.33333333 0.5 ]

# [0.26666667 0.33333333 0.4 ]

# [0.29166667 0.33333333 0.375 ]]

# NOTE

# 1/6 2/6 3/6

# 4/15 5/15 6/15

# 7/24 8/24 9/24

以下の図のように、この

`DataFrame`の場合

確認

まず確認のために、以下のDataFrameとSeriesを準備する。2次元配列はndarrayの例と同じものを流用。

import pandas as pd

df = pd.DataFrame(a)
sr = pd.Series(np.arange(1, 4))

print(df)
#    0  1  2
# 0  1  2  3
# 1  4  5  6
# 2  7  8  9

import pandas as pd

df = pd.DataFrame(a)

sr = pd.Series(np.arange(1, 4))

print(df)

# 0 1 2

# 0 1 2 3

# 1 4 5 6

# 2 7 8 9

合計ベクトルが`ndarray`の場合

演算をほどこすベクトルがndarrayの場合、2次元配列の時と同じように、ベクトルが行／列によって自動的に加えられる方向が決められる。

vrow = np.arange(1, 4)
vcol = np.arange(1, 4).reshape(-1, 1)

print(vrow)
# [1 2 3]

print(vcol)
# [[1]
#  [2]
#  [3]]

print(df + vrow)
#    0   1   2
# 0  2   4   6
# 1  5   7   9
# 2  8  10  12

print(df + vcol)
#     0   1   2
# 0   2   3   4
# 1   6   7   8
# 2  10  11  12

vrow = np.arange(1, 4)

vcol = np.arange(1, 4).reshape(-1, 1)

print(vrow)

# [1 2 3]

print(vcol)

# [[1]

# [2]

# [3]]

print(df + vrow)

# 0 1 2

# 0 2 4 6

# 1 5 7 9

# 2 8 10 12

print(df + vcol)

# 0 1 2

# 0 2 3 4

# 1 6 7 8

# 2 10 11 12

合計ベクトルが`Series`の場合

DataFrameのsum()メソッドで行や列の合計を計算するとSeriesオブジェクトで結果が得られるため、その挙動を確認しておく。

sr = pd.Series(np.arange(1, 4))
print(sr)

0    1
1    2
2    3
dtype: int32

sr = pd.Series(np.arange(1, 4))

print(sr)

0 1

1 2

2 3

dtype: int32

Seriesを単純にDataFrameと演算子で結ぶと、行ベクトルとして扱われる。

print(df + sr)

#    0   1   2
# 0  2   4   6
# 1  5   7   9
# 2  8  10  12

print(df + sr)

# 0 1 2

# 0 2 4 6

# 1 5 7 9

# 2 8 10 12

Seriesは行・列の概念を持たないが、演算の方向を明示するのに以下の方法をとる。

演算子の代わりに演算メソッドを使う
演算メソッドの引数axisで演算の方向を指定する

print(df.add(sr, axis=0))

#     0   1   2
# 0   2   3   4
# 1   6   7   8
# 2  10  11  12

print(df.add(sr, axis=1))

#    0   1   2
# 0  2   4   6
# 1  5   7   9
# 2  8  10  12

print(df.add(sr, axis=0))

# 0 1 2

# 0 2 3 4

# 1 6 7 8

# 2 10 11 12

print(df.add(sr, axis=1))

# 0 1 2

# 0 2 4 6

# 1 5 7 9

# 2 8 10 12

演算子に対応するメソッドは、add、sub、mul、div、mod、powが準備されている。

合計

列／行ごとの合計は、ndarrayと同じくDataFrameのsum()メソッドで引数axisを指定して計算する。

sums_along_cols = df.sum(axis=0)
sums_along_rows = df.sum(axis=1)

print(sums_along_cols)
# 0    12
# 1    15
# 2    18
# dtype: int64

print(sums_along_rows)
# 0     6
# 1    15
# 2    24
# dtype: int64

sums_along_cols = df.sum(axis=0)

sums_along_rows = df.sum(axis=1)

print(sums_along_cols)

# 0 12

# 1 15

# 2 18

# dtype: int64

print(sums_along_rows)

# 0 6

# 1 15

# 2 24

# dtype: int64

率の計算

`Series`を`ndarray`で取り出して計算する方法

Seriesのvaluesプロパティーでその内容をndarrayとして取り出せる。

列和に対しては、それを行ベクトルのまま除算すれば、各列の要素を行ベクトルの対応する要素で割った値となる。

print(df / sums_along_cols.values)

#           0         1         2
# 0  0.083333  0.133333  0.166667
# 1  0.333333  0.333333  0.333333
# 2  0.583333  0.533333  0.500000

print(df / sums_along_cols.values)

# 0 1 2

# 0 0.083333 0.133333 0.166667

# 1 0.333333 0.333333 0.333333

# 2 0.583333 0.533333 0.500000

行和に対しては、ndarrayを1列の列ベクトルに変換して除算すれば、各行の要素を列ベクトルの対応する要素で割った値となる。

print(df / sums_along_rows.values.reshape(-1, 1))

#           0         1      2
# 0  0.166667  0.333333  0.500
# 1  0.266667  0.333333  0.400
# 2  0.291667  0.333333  0.375

print(df / sums_along_rows.values.reshape(-1, 1))

# 0 1 2

# 0 0.166667 0.333333 0.500

# 1 0.266667 0.333333 0.400

# 2 0.291667 0.333333 0.375

`Series`のままで計算する方法

合計Seriesをそのまま使って除算する場合はDataFrameのdiv()メソッドを使いaxisを指定するが、axisの指定の仕方に注意が必要。

列和で除算する場合は、その各要素が各行の各要素に対応するため、列和を行ベクトルとみて各行に除算を適用する(axis=1)。

print(df.div(sums_along_cols, axis=1))

#           0         1         2
# 0  0.083333  0.133333  0.166667
# 1  0.333333  0.333333  0.333333
# 2  0.583333  0.533333  0.500000

print(df.div(sums_along_cols, axis=1))

# 0 1 2

# 0 0.083333 0.133333 0.166667

# 1 0.333333 0.333333 0.333333

# 2 0.583333 0.533333 0.500000

分かりにくいので図示すると以下のようになる。まず合計を求めるのにsum()メソッドでaxis=0として列和を求める。この合計で各要素を割るのに1列目の要素は合計の1つ目の要素、2列目の要素は合計の2つ目の要素・・・で割る必要があるので、div()メソッドでaxis=1とする。こうすると合計のSeriesは行ベクトルとみなされて、それが各行の要素に適用される。

行和で除算する場合は、その各要素が各列の各要素に対応するため、行和を列ベクトルとみて各列に除算を適用する(axis=0)。

print(df.div(sums_along_rows, axis=0))

#           0         1      2
# 0  0.166667  0.333333  0.500
# 1  0.266667  0.333333  0.400
# 2  0.291667  0.333333  0.375

print(df.div(sums_along_rows, axis=0))

# 0 1 2

# 0 0.166667 0.333333 0.500

# 1 0.266667 0.333333 0.400

# 2 0.291667 0.333333 0.375

これも分かりにくいので以下のように図示する。合計を求めるのにsum()メソッドでaxis=1として行和を求める。この合計で各要素を割るのに1行目の要素は合計の1つ目の要素、2行目の要素は合計の2つ目の要素・・・で割る必要があるので、div()メソッドでaxis=1とする。こうすると合計のSeriesは列ベクトルとみなされて、それが各列の要素に適用される。

このように、div()のような演算子メソッドでaxisを使う方法はややこしい（少なくとも私には）。

実行速度

各計算方法の実行速度には、あまり大きな差は出なかった。

import numpy as np
import pandas as pd
import time

counter = 100

a = np.arange(1000000).reshape(1000, 1000)
df = pd.DataFrame(a)

sum_of_cols = df.sum(axis=0)
sum_of_rows = df.sum(axis=1)

t0 = time.time()

for n in range(counter):
    df.values / sum_of_cols.values
t_array_c = time.time()
print(t_array_c - t0)

for n in range(counter):
    df.values / sum_of_rows.values.reshape(-1, 1)
t_array_r = time.time()
print(t_array_r - t_array_c)

for n in range(counter):
    df / sum_of_cols.values
t_df_array_c = time.time()
print(t_df_array_c - t_array_r)

for n in range(counter):
    df / sum_of_rows.values.reshape(-1, 1)
t_df_array_r = time.time()
print(t_df_array_r - t_df_array_c)

for n in range(counter):
    df.div(sum_of_cols, axis=1)
t_df_div_c = time.time()
print(t_df_div_c - t_df_array_r)

for n in range(counter):
    df.div(sum_of_rows, axis=0)
t_df_div_r = time.time()
print(t_df_div_r - t_df_div_c)

import numpy as np

import pandas as pd

import time

counter = 100

a = np.arange(1000000).reshape(1000, 1000)

df = pd.DataFrame(a)

sum_of_cols = df.sum(axis=0)

sum_of_rows = df.sum(axis=1)

t0 = time.time()

for n in range(counter):

df.values / sum_of_cols.values

t_array_c = time.time()

print(t_array_c - t0)

for n in range(counter):

df.values / sum_of_rows.values.reshape(-1, 1)

t_array_r = time.time()

print(t_array_r - t_array_c)

for n in range(counter):

df / sum_of_cols.values

t_df_array_c = time.time()

print(t_df_array_c - t_array_r)

for n in range(counter):

df / sum_of_rows.values.reshape(-1, 1)

t_df_array_r = time.time()

print(t_df_array_r - t_df_array_c)

for n in range(counter):

df.div(sum_of_cols, axis=1)

t_df_div_c = time.time()

print(t_df_div_c - t_df_array_r)

for n in range(counter):

df.div(sum_of_rows, axis=0)

t_df_div_r = time.time()

print(t_df_div_r - t_df_div_c)

実行時間は以下の通りで、各計算手法の間に差はない。敢えて言えば、DataFrameを使った場合に僅かに時間がかかっている。

0.4757249355316162
0.4577751159667969
0.524827241897583
0.5440847873687744
0.5674364566802979
0.5242717266082764

0.4757249355316162

0.4577751159667969

0.524827241897583

0.5440847873687744

0.5674364566802979

0.5242717266082764

なお、この計算はpandasのバージョン1.1.4で実行したが、upgrade前のバージョン0では、3つ目と5つ目、DataFrameで行単位の演算を行うときに20秒台と2桁長い時間がかかっていた。

axisの方向

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

概要

配列などのメソッドの引数で指定するaxis=0/1について確認。

axis=0は配列やDataFrameを列単位で捉えて、その列の中で処理を行いながら、すべての列に対して処理が行われる
- SerieseオブジェクトがDataFrameの処理の対象となる場合は列として扱われ、DataFrameの各列を処理しながらすべての列に適用される
axis=1は配列やDataFrameを行単位で捉えて、その行の中で処理を行いながら、すべての行に対して処理が行われる。
- SerieseオブジェクトがDataFrameの処理の対象となる場合は行として扱われ、DataFrameの各行を処理しながらすべての行に適用される

`ndarray`の場合

まずndarrayの2次元配列で確認する。

ary = np.arange(1, 7).reshape(2, 3)
print(ary)

# [[1 2 3]
#  [4 5 6]]

ary = np.arange(1, 7).reshape(2, 3)

print(ary)

# [[1 2 3]

# [4 5 6]]

`max()`メソッド

axis=0は列単位で各列の最大値を探し、それらを要素とする配列（要素数＝列数の1次元配列）
axis=1は行単位で各行の最大値を探し、それらを要素とする配列（要素数＝行数の1次元配列）

print(ary.max(axis=0))
# [4 5 6]

print(ary.max(axis=1))
# [3 6]

print(ary.max(axis=0))

# [4 5 6]

print(ary.max(axis=1))

# [3 6]

`sum()`メソッド

axis=0は列単位で各列の合計を要素とする配列（要素数＝列数の1次元配列）
axis=1は行単位で各行の合計を要素とする配列（要素数＝行数の1次元配列）

print(ary.sum(axis=0))
# [5 7 9]

print(ary.sum(axis=1))
# [ 6 15]

print(ary.sum(axis=0))

# [5 7 9]

print(ary.sum(axis=1))

# [ 6 15]

`repeat()`メソッド

axis=0は列単位で各列の要素が指定回数繰り返される
axis=1は行単位で各行の要素が指定回数繰り返される

print(ary.repeat(2, axis=0))

# [[1 2 3]
#  [1 2 3]
#  [4 5 6]
#  [4 5 6]]

print(ary.repeat(2, axis=1))

# [[1 1 2 2 3 3]
#  [4 4 5 5 6 6]]

print(ary.repeat(2, axis=0))

# [[1 2 3]

# [1 2 3]

# [4 5 6]

# [4 5 6]]

print(ary.repeat(2, axis=1))

# [[1 1 2 2 3 3]

# [4 4 5 5 6 6]]

図による理解

sum()メソッドを例に、axis=0/1に対する挙動を図にすると、以下のようになる。

`DataFrame`の場合

以下のDataFrameとSeriesオブジェクトで確認する。Seriesオブジェクトは行として扱われ、array_like、1次元の配列でも同じ結果になる。

df = pd.DataFrame(np.arnge(1, 9).reshape(3, 3))
sr = pd.Series(np.arange(1, 3))

print(df)

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

print(sr)

# 0    1
# 1    2
# 2    3
# dtype: int32

df = pd.DataFrame(np.arnge(1, 9).reshape(3, 3))

sr = pd.Series(np.arange(1, 3))

print(df)

# 0 1 2

# 0 1 2 3

# 1 4 5 6

# 2 7 8 9

print(sr)

# 0 1

# 1 2

# 2 3

# dtype: int32

`min()`メソッドなど

min、max、sumなどのメソッドの考え方はndarrayと同じ挙動。

`add()`などの演算メソッド

DataFrameには演算子による演算の代替となるメソッドがある（add、sub、mul、div、mod、pow）。addメソッドを例にとると、以下のように引数を指定。

add(array_like, axis=0/1)

axis=0はarray_likeを列とみなして、DataFrameオブジェクトの各列の要素との和を計算する
axis=1はarray_likeを行とみなして、DataFrameオブジェクトの各行の要素との和を計算する

print(df.add(sr, axis=0))

#     0   1   2
# 0   2   3   4
# 1   6   7   8
# 2  10  11  12

print(df.add(sr, axis=1))

#    0   1   2
# 0  2   4   6
# 1  5   7   9
# 2  8  10  12

print(df.add(sr, axis=0))

# 0 1 2

# 0 2 3 4

# 1 6 7 8

# 2 10 11 12

print(df.add(sr, axis=1))

# 0 1 2

# 0 2 4 6

# 1 5 7 9

# 2 8 10 12

`apply()`メソッド

applyメソッドは、行または列を指定した関数に渡す。

axis=0はDataFrameオブジェクトの各列を指定した関数に渡す
axis=1はDataFrameオブジェクトの各行を指定した関数に渡す

print(df.apply(lambda x: sum(x) / 3, axis=0))

# 0    4.0
# 1    5.0
# 2    6.0
# dtype: float64

print(df.apply(lambda x: sum(x) / 3, axis=1))

# 0    2.0
# 1    5.0
# 2    8.0
# dtype: float64

print(df.apply(lambda x: sum(x) / 3, axis=0))

# 0 4.0

# 1 5.0

# 2 6.0

# dtype: float64

print(df.apply(lambda x: sum(x) / 3, axis=1))

# 0 2.0

# 1 5.0

# 2 8.0

# dtype: float64

演算メソッドの図による理解

演算メソッドは少し挙動が違うので図で整理しておく。1次元のarray_likeオブジェクトがaxisの指定によって列／行としてみなされる点に注意。

補足

1次元配列の場合

1次元配列に対してaxis引数を使う場合、行ベクトルとしてaxis=1に反応しそうだが、実際にはaxis=0で各要素に対する処理が行われる。axis=1を指定すると、たとえば以下のようなエラーになる。

ary.min(axis=1)->numpy.AxisError: axis 1 is out of bounds for array of dimension 1

1	ary.min(axis=1)->numpy.AxisError: axis 1 is out of bounds for array of dimension 1

元々多次元配列を意図した引数なので、1次元配列に使うのはナンセンスだろう（axis=0を行単位の処理にしておけば自然ではあったかもしれないが）。

1行の2次元配列の場合

1行の配列（1つの1次元配列を要素に持つ2次元配列：行ベクトル）に対するaxisの効果を、sumメソッドで見てみる。

ary = np.arange(1, 4).reshape(1, -1)
print(ary)
# [[1 2 3]]

print(ary.sum(axis=0))
# [1 2 3]

print(ary.sum(axis=1))
# [6]

ary = np.arange(1, 4).reshape(1, -1)

print(ary)

# [[1 2 3]]

print(ary.sum(axis=0))

# [1 2 3]

print(ary.sum(axis=1))

# [6]

axis=0の場合は各要素が1要素の列ベクトルとみなされ、3つの列（要素）ごとに処理される。その結果は3つの要素を持つ1次元配列（行ベクトル）となる。

axis=1の場合は行ベクトル全体が1つの行とみなされ、それらの要素に対して処理がされる。その結果は1つの数値となるが、1つの要素を持つ1次元配列で返される。

1列の2次元配列の場合

1列の配列（列ベクトル）に対するaxisの効果を、sumメソッドで見てみる。

ary = np.arange(1, 4).reshape(-1, 1)
print(ary)
# [[1]
#  [2]
#  [3]]

print(ary.sum(axis=0))
# [6]

print(ary.sum(axis=1))
# [1 2 3]

ary = np.arange(1, 4).reshape(-1, 1)

print(ary)

# [[1]

# [2]

# [3]]

print(ary.sum(axis=0))

# [6]

print(ary.sum(axis=1))

# [1 2 3]

axis=0の場合は3つの要素を持つ1つの列に対して処理される。その結果は1つの数値となるが、1つの要素を持つ1次元配列で返される。

axis=1の場合は列の各要素が1要素の行とみなされ、3つの行（要素）ごとに処理される。その結果は3つの要素を持つ列ベクトルだが、3つの要素を持つ1次元配列（行ベクトル）で返される。

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

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に変換し直した方が速いと言える。

概要

基本

属性データが複数列の場合

属性が数値表現の場合

属性名の指定

概要

DataFrameの規模・形状

データの先頭部分と末尾部分

info()～各列の基本情報の表示

dscribe()～基本的な統計量

属性変数のカウント

概要

ndarrayの場合

確認

合計

率の計算

DataFrameの場合

確認

合計ベクトルがndarrayの場合

合計ベクトルがSeriesの場合

合計

率の計算

Seriesをndarrayで取り出して計算する方法

Seriesのままで計算する方法

実行速度

概要

ndarrayの場合

max()メソッド

sum()メソッド

repeat()メソッド

図による理解

DataFrameの場合

min()メソッドなど

add()などの演算メソッド

apply()メソッド

演算メソッドの図による理解

補足

1次元配列の場合

1行の2次元配列の場合

1列の2次元配列の場合

概要

列の参照

DataFrameで列名を直接指定

1つの列を指定

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

locによる列の指定

1つの列の指定

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

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

列の追加

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

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

assignメソッドによる追加

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

列の更新

DataFrameで列名を直接指定

1つの列を指定

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

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

1つの列の指定

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

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

列の削除

例題のデータ

1列の削除

複数列の削除

連続した列の削除

要素の操作

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

at～インデックス指定

iat～行・列番号指定

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

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

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

概要

配列は不適

リストはOK

列の辞書もOK

リスト・配列からの生成

リストからの生成

`info()`～各列の基本情報の表示

`dscribe()`～基本的な統計量

`ndarray`の場合

`DataFrame`の場合

合計ベクトルが`ndarray`の場合

合計ベクトルが`Series`の場合

`Series`を`ndarray`で取り出して計算する方法

`Series`のままで計算する方法

`ndarray`の場合

`max()`メソッド

`sum()`メソッド

`repeat()`メソッド

`DataFrame`の場合

`min()`メソッドなど

`add()`などの演算メソッド

`apply()`メソッド

`loc`による列の指定

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

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

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

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

`DataFrame`で列名を直接指定

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

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

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

`iat`～行・列番号指定

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

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

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

列名～`columns`

行名～`index`

データの内容～`values`