putsはオブジェクトの内容を表示する。文の実行ごとに改行する。
|
1 2 3 4 5 6 7 8 9 |
puts("Ruby") puts("Diamond") puts(["one", "two", 3]) # Ruby # Diamond # one # two # 3 |
printはオブジェクトの内容を表示する。改行はしない。
|
1 2 3 4 5 |
print("Ruby") print("Diamond") print(["one", "two", 3]) # RubyDiamond["one", "two", 3] |
pはオブジェクトの形式がわかるように表示する。文の実行ごとに改行する。
|
1 2 3 4 5 6 7 |
p("Ruby") p('Diamond') p(["one", "two", 3]) # "Ruby" # "Diamond" # ["one", "two", 3] |
文字で表現するとわかり難いが、要するに次のようなことを想定している。たとえば次のような1次元の配列があるとする。
|
1 2 3 4 5 6 7 8 9 10 |
import numpy as np np.random.seed(0) targets = np.random.randint(0, 5, 20) print(targets) # [4 0 3 3 3 1 3 2 4 0 0 4 2 1 0 1 1 0 1 4] print(np.bincount(targets)) # [5 5 2 4 4] |
この配列には20個の要素があり、0～4の数値がそれぞれ5個、5個、2個、2個、4個、4個、順不同で含まれている。
この配列において、各数値の数を最大でも3個以内となるように切り落としたい、というのが目標。
たとえば、機械学習の教師データの数がターゲットごとにばらついている場合、各ターゲットのデータ数をある程度の数以下に抑えたいときが想定される。
上の例で仮に早く出現した準から3つまでを残して後は捨てるとすれば、以下のような配列になる。
内容：4 0 3 3 3 1 3 2 4 0 0 4 2 1 0 1 1 0 1 4
個数：1 1 1 2 3 1 4 1 2 2 3 3 2 2 4 3 4 5 5 4
なお、単に1つの配列の要素を切り落とすだけでなく、これと対応する配列が別にあって、その要素についても同時に切り落とすことも想定する。これは、機械学習のターゲット配列でデータを制限するのに、これに紐づけられた画像データなどを格納した配列も同時に操作するイメージ。
targetsの20個のデータのうちid=0について考える。targetsの要素のうち値が0のものは5個あり、それらのインデックスは(1, 9, 10, 14, 17)。同様にid=1についても5個あり、インデックスは(5, 13, 15, 16, 18)。
このようにしてid=0～4についてインデックスを書き出すと以下の通りになる。
0：1, 9, 10, 14, 17
1：5, 13, 15, 16, 18
2：7, 12
3：2, 3, 4, 6
4：0, 8, 11, 19
各idに対応する配列はnumpy.where()関数を用いて以下のように得られる。
|
1 2 3 4 5 6 7 8 9 |
for id in range(5): array = np.where(targets == id)[0] print("{}:{}".format(id, array)) # 0:[ 1 9 10 14 17] # 1:[ 5 13 15 16 18] # 2:[ 7 12] # 3:[2 3 4 6] # 4:[ 0 8 11 19] |
上の例では、ループのidを0～4と変化させていくのにrange(5)を使っている。ところが一般的には、番号が連続して存在しているとは限らず、またその上限もわからない。
そこで、targetsに出てくる要素を重なりなく、かつ全て使うためにnumpy.unique()関数を使っている。unique()関数は引数の配列の要素の重複を除き、昇順・辞書順に並べてくれる。この引数にtargetsを渡して、要素の重なりを除けば、targets中の要素を重なりなく1つずつ参照できる。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
print(np.unique(targets)) # [0 1 2 3 4] for id in np.unique(targets): array = np.where(targets == id)[0] print("{}:{}".format(id, array)) # [ 1 9 10 14 17] # [ 5 13 15 16 18] # [ 7 12] # [2 3 4 6] # [ 0 8 11 19] |
次に、すべてのターゲットのデータ数が3個以下になるようにすることを考える。
これらのデータで各idの個数を3個以下にするのに、出現順位の早いものから3個を選び出すことを考える。
0：1, 9, 10, 14, 17
1：5, 13, 15, 16, 18
2：7, 12
3：2, 3, 4, 6
4：0, 8, 11, 19
各配列の最初の3個を取り出すには、各idに対応する配列の先頭から3個目までをスライスで取り出せばよい。
|
1 2 3 4 5 6 7 8 9 |
for id in np.unique(targets): array = np.where(targets == id)[0][:3] print("{}:{}".format(id, array)) # 0:[ 1 9 10] # 1:[ 5 13 15] # 2:[ 7 12] # 3:[2 3 4] # 4:[ 0 8 11] |
これで値の最大3個までとするのに取り出すべきtargets中のインデックスが得られた。
targets配列の要素の個数を制限するには、上で絞り込まれたインデックスに対応する要素を残し、それ以外の要素を切り捨てる。そのためには、残すべきインデックス位置の値がTrue、その他のインデックス位置の値がFalseであるbool配列をつくり、これをtargetsの引数とすればよい。
この配列を例えばmaskという名前とすると、targetsと同じサイズですべての要素がFalseである配列としてmaskを準備し、先ほどの切り落とすべきインデックスの位置のみTrueにするとよい。
以下では、まず全要素がFalseでtargetsと同じサイズのbool配列を準備し、各idに対して3つ目までの要素の位置をTrue(1)としている。
ループの1回目で1、9、10番目がTrueになり、2回目で5、13、15番目がTrueに代わっていき、ループを重ねるごとに、取り出すべき要素の位置がTrueになっていることが確認できる。
なおbool配列の初期化では、Falseが数値の0と等価なため、numpy.zeros()関数を使っている。同じ理由で、numpy.where()でTrueをセットするときに、数値の1をセットしている。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
mask = np.zeros(targets.size, dtype=np.bool) print(mask) # [False False False False False False False False False False False False # False False False False False False False False] for target in np.unique(targets): mask[np.where(targets == target)[0][:3]] = 1 print(mask) # [False True False False False False False False False True True False # False False False False False False False False] # [False True False False False True False False False True True False # False True False True False False False False] # [False True False False False True False True False True True False # True True False True False False False False] # [False True True True True True False True False True True False # True True False True False False False False] # [ True True True True True True False True True True True True # True True False True False False False False] |
最後に、このbool配列をtargetsに適用して、取り出すべき要素の配列を得る。
|
1 2 3 4 5 |
print(targets[mask]) # [4 0 3 3 3 1 2 4 0 0 4 2 1 1] print(np.bincount(targets[mask])) # [3 3 2 3 3] |
mask配列は、targetsと同じサイズを持つ次元の配列に繰り返し適用できるので、たとえば機械学習でtargetsの各要素に紐づけられた画像データなどを格納した配列などについても、targetsと整合させながら必要な分だけ切出すことができる。
numpy.bincount()関数の仕様
引数で与えた整数型配列中の同じ値をカウントして、各値ごとの個数を要素とする配列を返す。
|
1 2 3 4 5 6 |
import numpy as np a = np.array([0, 1, 1, 2, 2, 2, 3, 3]) print(np.bincount(a)) # [1 2 3 2] |
上の結果の意味は、0が1個、1が2個、2が3個、3が2個。
引数の配列中、0～最大値までの整数値に対する数をカウントする。値が存在しない場合の個数は0。
|
1 2 3 4 |
b = np.array([1, 3, 3, 5, 5, 5]) print(np.bincount(b)) # [0 1 0 2 0 3] |
上の例では、0～5までの個数がカウントされ、0, 2, 4は配列中に存在しないので0となっている。
引数の配列中の要素は昇順である必要はない。
|
1 2 3 4 |
c = np.array([2, 2, 3, 3, 3, 1]) print(np.bincount(c)) # [0 1 2 3] |
weightsの意味引数にweightsを指定する場合。
weightsの配列を与える。|
1 2 3 4 5 |
w = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6]) d = np.array([1, 2, 4, 2, 4, 4]) print(np.bincount(d, weights=w)) # [0. 0.1 0.6 0. 1.4] |
上の例では以下のように動作している。
weightsの値は0.1weightsの第1要素0.2と第3要素0.4を加えて0.6weightsの第2要素0.3、第4要素0.5、第5要素0.6を加えて1.4
matplotlib.pyplot.imshow()は画像表示用のメソッドで、表示対象として、画像ファイルや画像情報を格納した配列を指定する。
pyplotやsubplotで直接実行するほか、Axesオブジェクトのメソッドとしても実行できる。
ピクセルデータのレンジのデフォルト設定と与えるデータのレンジによって予期しない結果になることもあり、vmin、vmaxを明示的に指定した方がよい。
以下のコードは、JPEGファイルを読み込んで表示する。
ここではpyplot.subplotのメソッドとしてimshow()を実行している。画像が1つの場合、pyplot.imshow()でもよい。
1つは画像ファイルをそのまま引数にし、もう1つは画像ファイルを配列の形にしてから引数に渡している。画像の配列の形については後述。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
import numpy as np import matplotlib.pyplot as plt from PIL import Image image = Image.open("./coffeemill.jpg") image_array = np.asarray(image) plt.subplot(121).imshow(image) plt.subplot(122).imshow(image_array) plt.show() print(image_array.shape) # (871, 653, 3) print(image_array) [[[171 147 111] [167 143 107] [170 147 113] ... [ 93 82 86] [ 92 81 87] [ 93 83 91]] [[170 146 110] [167 143 107] [170 147 113] ... [ 92 81 87] [ 85 76 81] [ 77 67 75]] ..... [[ 36 23 15] [ 37 24 16] [ 41 26 21] ... [248 196 123] [249 197 124] [247 195 122]]] |
imshow()は配列を引数にとることができる。
以下の例では、カラーマップを指定して2×2=4要素の2次元配列を表示している。最小値0がカラーマップbwrの青に、最大値255が赤に対応し、その間の数値の大きさに応じたカラーマップ上の色が選択されている（デフォルトのcmapはvirいdis）。
なお、この例ではpyplotから直接imshow()を実行している。
|
1 2 3 4 5 6 7 8 9 10 11 |
import numpy as np import matplotlib.pyplot as plt im_array = np.array([ [0, 85], [170, 255] ]) plt.imshow(im_array, cmap='bwr') plt.show() |
imshow()に配列を渡して描画させるとき、数値のレンジに留意する必要がある。
デフォルトでは、imshow()は渡された配列の中の最小値と最大値をカラーマップの下限値と上限値に対応させ、線形にマッピングする。
なお、この例ではarray-likeとして2次元のリストを渡していて、Axesからimshow()を呼び出している。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import numpy as np import matplotlib.pyplot as plt images = [] images.append([[0, 0.5, 1]]) images.append([[0, 127, 255]]) images.append([[-1, 0, 1]]) images.append([[1000, 1000.5, 1001]]) print(images) fig, axs = plt.subplots(2, 2) for image, ax in zip(images, axs.flatten()): ax.imshow(image, cmap='bwr') plt.show() |
4つの配列はそれぞれ最小値と最大値が異なり、かつその中央の値を持つ。値は異なるが全て最小値がカラーマップbwrの下限値に対応する青、最大値が上限値に対応する赤、中央値は白となっている（特段フランス国旗を意図したものではない）。
imshow()の引数でvminとvmaxを設定すると、配列の値に関わらず、vminとvmiaxをカラーマップの下限値と上限値に対応させる。
以下の例では最小値0、最大値1の2要素の配列を、vminとvmaxを変えてカラーマップbwrで描画させている。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import numpy as np import matplotlib.pyplot as plt image = [[0, 1]] fig, axs = plt.subplots(2, 2) axs[0, 0].imshow(image, cmap='bwr') axs[0, 0].set_title("Default") axs[0, 1].imshow(image, cmap='bwr', vmin=0, vmax=2) axs[0, 1].set_title("vmin=0, vmax=2") axs[1, 0].imshow(image, cmap='bwr', vmin=-1, vmax=2) axs[1, 0].set_title("vmin=-1, vmax=2") axs[1, 1].imshow(image, cmap='bwr', vmin=0.2, vmax=0.8) axs[1, 1].set_title("vmin=0.2, vmax=0.8") plt.show() |
左上はデフォルトなので、最小値0がカラーマップ下限値に対応した青に、最大値1が上限値に対応した赤になっている。
右上はvmin=0で配列の最小値0と同じだが、vmax=2としている。このため配列の0はカラーマップ下限の青で、配列の1はカラーマップ中央の白になっている。
左下はvmin=-1も設定されているので、配列の0、1はカラーマップの左から1/3、2/3に相当する色となっている。
右下はvminとvmaxが配列の最小値と最大値の範囲より内側にある。このため、配列の最小値・最大値はそれぞれカラーマップの下限・上限に対応する青・赤となっている。
array-likeの次元が3次元になると、RGB/RGBA形式だと認識される。
R, G, B, Aの値は、配列のdtypeがint形式の時には0～255、floatの時には0～1の範囲が想定される。
以下の例の内容。
3次元配列のピクセルの並び替えは、泥臭くforループで回しているが、もっとエレガントな方法があるかもしれない（もとから(3, rows, cols)の形にしてくれればよかったのに）。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
# --- --B -G- -GB # R-- R-B RG- RGB import numpy as np import matplotlib.pyplot as plt image_org = np.array([ [ [ 0, 0, 0, 0], [255, 255, 255, 255] ], [ [ 0, 0, 255, 255], [ 0, 0, 255, 255] ], [ [ 0, 255, 0, 255], [ 0, 255, 0, 255] ] ]) row = image_org.shape[1] col = image_org.shape[2] image_int1 = np.empty((row, col, 3), dtype=int) image_int2 = np.empty((row, col, 3), dtype=int) image_float1 = np.empty((row, col, 3), dtype=float) image_float2 = np.empty((row, col, 3), dtype=float) for m in range(row): for n in range(col): for rgb in range(3): image_int1[m, n, rgb] = image_org[rgb, m, n] image_int2[m, n, rgb] = image_org[rgb, m, n] /255 #-> all the pixels become BLACK image_float1[m, n, rgb] = image_org[rgb, m, n] image_float2[m, n, rgb] = image_org[rgb, m, n] / 255 #- >works, but # "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers)." fig, axs = plt.subplots(2, 2) axs[0, 0].imshow(image_int1) axs[0, 0].set_title("dtype=int, 0~255") axs[0, 1].imshow(image_int2) axs[0, 1].set_title("dtype=int, 0.0~1.0") axs[1, 0].imshow(image_float1) axs[1, 0].set_title("dtype=float, 0.0~255.0") axs[1, 1].imshow(image_float2) axs[1, 1].set_title("dtype=float, 0.0~1.0") plt.show() print("original image shape :{}".format(image_org.shape)) print("rearranged image shape:{}".format(image_int1.shape)) print("rearranged image:\n{}".format(image_int1)) # Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). # original image shape :(3, 2, 4) # rearranged image shape:(2, 4, 3) # rearranged image: # [[[ 0 0 0] # [ 0 0 255] # [ 0 255 0] # [ 0 255 255]] # # [[255 0 0] # [255 0 255] # [255 255 0] # [255 255 255]]] |
imshow()に渡す配列のdtypeがint型の時は、ピクセルデータのレンジが0～255になる。
配列のdtypeがfloatの時は、ピクセルデータの想定レンジは0.0～1.0になる。
imshow()のデフォルトのレンジ0～255に変更されているようである（特にメッセージは出ない）並べ替えた後の配列は、直感的にはわかりにくい形になっている。
グレースケールの場合は、cmap='gray'を指定する。vmin、vmaxは省略しても同じ結果となるが念のため。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import numpy as np import matplotlib.pyplot as plt row_L = np.arange(0, 256, 8, dtype=int) row_R = np.arange(256, 0, -8) row = np.append(row_L, row_R) n_size = 256 // 8 image_array = np.empty((n_size, n_size), dtype=int) for r in range(n_size): image_array[r, :] = row[:n_size] row = np.roll(row, -1) plt.imshow(image_array, vmin=0, vmax=255, cmap='gray') plt.show() |
DataFrameのget_dummies()メソッドは、属性データ（カテゴリーデータ）をone-hot-encodingの形に変換してくれる。
Scikit-learnにもOneHotEncoderがあるが、get_dumies()はデータの切り貼りをせずにダイレクトに属性変数だけをone-hotの形にしてくれるので便利。
get_dumies()の引数にDataFrameを指定すると、文字列で属性指定されたデータが自動で認識されてon-hotの形に変換される。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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に分解してくれる。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
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引数で指定する。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
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引数でリスト指定する。
|
1 2 3 4 5 6 7 8 |
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引数で文字列を指定すると、属性名がその文字列で置き換えられる。ただし複数の属性列が全て同じ文字列になる。
|
1 2 3 4 5 6 7 8 |
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を変えて指定したい場合はリストで指定。
|
1 2 3 4 5 6 7 8 |
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の規模、格納されているデータの概要や基礎統計量を概観する各種の手順。Scikit-learnのBoston housingデータセットを例にする。
sizeプロパティーで全データ数、shapeプロパティーで行数と列数を確認。
|
1 2 3 4 5 6 7 8 9 10 11 |
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行分が得られる。引数で抜き出す行数を指定。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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の概要に関する概略情報を出力する。直接標準出力にプリントする点に注意。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
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が含まれる場合の出力は以下のようになる。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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()メソッドは、各列のデータについて、個数や平均といった基本的な統計量を計算する。
|
1 2 3 4 5 6 7 8 9 10 11 |
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で割った不偏分散。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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()メソッド。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
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()メソッドを使う。このメソッドは、ユニークな値の数をカウントして集計する。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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つの属性のユニークな組み合わせ」の数が集計される。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
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 |
平均はmean()メソッドで計算。
|
1 2 3 4 5 6 7 8 9 10 |
import numpy as np x = np.array([1, 1, 2, 3, 5, 8, 13, 21, 34, 55]) n = x.size s = x.sum() m = x.mean() print(m, s / n) # 14.3 14.3 |
分散はvar()メソッド、標準偏差はstd()メソッドで計算。デフォルトでは標本分散と標本標準偏差。
|
1 2 3 4 5 6 7 8 |
v = x.var() sv = x.std() print(v, np.sum((x - m)**2) / n) # 285.01000000000005 285.01000000000005 print(sv, np.sqrt(v)) # 16.88223918797504 16.88223918797504 |
分散の算出では、引数ddof (delta degrees of freedom)で指定した引数をデータ数nから引いた数で偏差の二乗和を割る。デフォルトではddof=0なので標本分散、標本標準偏差になるが、ddof=1を指定すると、不偏分散、標準偏差の不偏推定量が計算される。
|
1 2 3 4 5 6 7 8 |
u = x.var(ddof=1) su = x.std(ddof=1) print(u, np.sum((x - m)**2) / (n - 1)) # 316.6777777777778 316.6777777777778 print(su, np.sqrt(u)) # 17.795442612584207 17.795442612584207 |
平均はmean()メソッドで計算。引数axis=0/1で列方向／行方向の計算方向を指定。計算結果は1次元配列で、要素数は列方向の平均なら行数、行方向の平均なら列数と同じになる。
|
1 2 3 4 5 6 7 8 |
X = np.array([1, 1, 2, 3, 5, 8, 13, 21, 34, 55]).reshape(-1, 2) n = X.shape[0] s = X.sum(axis=0) m = X.mean(axis=0) print(m, s / n) # [11. 17.6] [11. 17.6] |
分散はvar()メソッド、標準偏差はstd()メソッドで計算。デフォルトでは標本分散、標本標準偏差を計算。デフォルトでは標本分散、標本標準偏差。
|
1 2 3 4 |
v = X.var(axis=0) print(v, np.sum((X - m)**2, axis=0) / n) # [150. 398.24] [150. 398.24] |
引数ddof=1を指定すると、データ数nからddof=1を引いた数で偏差の二乗和が割られ、不偏分散、標準偏差の不偏推定量が計算される。
|
1 2 3 4 |
u = X.var(axis=0, ddof=1) print(u, np.sum((X - m)**2, axis=0) / (n - 1)) # [187.5 497.8] [187.5 497.8] |
cov()メソッドで二つのデータの共分散行列を計算する。結果は2次元配列で得られ、対角要素は各データの分散、対角要素以外の要素は行数・列数に対応する共分散。
デフォルトでは引数bias=Falseとなっていて、偏差の積和をn−1で割った不偏推定量が計算される。
|
1 2 3 4 5 6 7 |
print(np.cov(X[:, 0], X[:, 1])) # [[187.5 305.5] # [305.5 497.8]] Xd = X - m print(np.sum(Xd[:, 0] * Xd[:, 1]) / (n - 1)) # 305.5 |
bias=Trueを指定すると、偏差の積和を割る数がnとなり、標本に対する分散・共分散が計算される。
|
1 2 3 4 5 6 |
print(np.cov(X[:, 0], X[:, 1], bias=True)) # [[150. 244.4 ] # [244.4 398.24]] print(np.sum(Xd[:, 0] * Xd[:, 1]) / n) # 244.4 |
2次元のndarrayやDataFrameで、行単位や列単位での合計を計算したり、それを使って行単位／列単位の率を計算する方法。
2次元のndarrayの場合は、
sum()メソッドの引数にaxisを指定
axis=0、行和ならaxis=1DataFrameの場合、まず合計を求めるには、
sum()メソッドの引数にaxisを指定
axis=0、行和ならaxis=1Seriesオブジェクトで得られるその上で率の計算には2通りある。1つ目はSeriesオブジェクトの内容をndarrayとして取り出して計算する方法で、
Series.valuesで列和／行和の配列を取り出し、ndarrayの場合と同じ方法で計算するもう1つの方法はSeriesオブジェクトのままでdiv()メソッドにaxisを指定する方法で、
div(列和Series, axis=1)div(列和Series, axis=0)ndarrayの場合まず確認のために、以下の配列を準備する。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
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次元配列に加えると、配列の各行に対して行ベクトルが加えらえる。
|
1 2 3 4 5 |
print(a + vrow) # [[ 2 4 6] # [ 5 7 9] # [ 8 10 12]] |
列ベクトルを2次元配列に加えると、配列の各列に対して列ベクトルが加えられる。
|
1 2 3 4 5 |
print(a + vcol) # [[ 2 3 4] # [ 6 7 8] # [10 11 12]] |
つまり、ndarrayの2次元配列に行または列のベクトルを加えると、加える方のベクトルの形状に合わせて各行／列に演算が実行される。これは他のオペレーターについても同じ。
この演算は直感的にも分かりやすく、列ごと／行ごとの小計に対する比率の計算も思い浮かべることができる。
ndarrayの各列／行に沿った合計を計算する。合計計算はndarrayのsum()メソッドを使うが、引数を省略すると全要素の和となる。引数にaxis=0を指定すると列方向に処理がされ（つまり配列の各列の要素が列方向に足され）、axis=1を指定すると行方向に処理がされる（つまり配列の各行の要素が行方向に足される）。
以下の例は、最初に使った2次元配列の列方向の和（の行ベクトル）と行方向の和（の列ベクトル）を計算している。
|
1 2 3 4 5 6 7 8 9 10 |
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になる）。
|
1 2 3 4 5 6 7 8 9 10 |
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次元の列ベクトルになっている。
|
1 2 3 4 5 6 7 8 9 10 |
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の例と同じものを流用。
|
1 2 3 4 5 6 7 8 9 10 |
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次元配列の時と同じように、ベクトルが行／列によって自動的に加えられる方向が決められる。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
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オブジェクトで結果が得られるため、その挙動を確認しておく。
|
1 2 3 4 5 6 7 |
sr = pd.Series(np.arange(1, 4)) print(sr) 0 1 1 2 2 3 dtype: int32 |
Seriesを単純にDataFrameと演算子で結ぶと、行ベクトルとして扱われる。
|
1 2 3 4 5 6 |
print(df + sr) # 0 1 2 # 0 2 4 6 # 1 5 7 9 # 2 8 10 12 |
Seriesは行・列の概念を持たないが、演算の方向を明示するのに以下の方法をとる。
axisで演算の方向を指定する|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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を指定して計算する。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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として取り出せる。
列和に対しては、それを行ベクトルのまま除算すれば、各列の要素を行ベクトルの対応する要素で割った値となる。
|
1 2 3 4 5 6 |
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列の列ベクトルに変換して除算すれば、各行の要素を列ベクトルの対応する要素で割った値となる。
|
1 2 3 4 5 6 |
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)。
|
1 2 3 4 5 6 |
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)。
|
1 2 3 4 5 6 |
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を使う方法はややこしい（少なくとも私には）。
各計算方法の実行速度には、あまり大きな差は出なかった。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
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を使った場合に僅かに時間がかかっている。
|
1 2 3 4 5 6 |
0.4757249355316162 0.4577751159667969 0.524827241897583 0.5440847873687744 0.5674364566802979 0.5242717266082764 |
なお、この計算はpandasのバージョン1.1.4で実行したが、upgrade前のバージョン0では、3つ目と5つ目、DataFrameで行単位の演算を行うときに20秒台と2桁長い時間がかかっていた。
配列などのメソッドの引数で指定するaxis=0/1について確認。
axis=0は配列やDataFrameを列単位で捉えて、その列の中で処理を行いながら、すべての列に対して処理が行われる
SerieseオブジェクトがDataFrameの処理の対象となる場合は列として扱われ、DataFrameの各列を処理しながらすべての列に適用されるaxis=1は配列やDataFrameを行単位で捉えて、その行の中で処理を行いながら、すべての行に対して処理が行われる。
SerieseオブジェクトがDataFrameの処理の対象となる場合は行として扱われ、DataFrameの各行を処理しながらすべての行に適用されるndarrayの場合まずndarrayの2次元配列で確認する。
|
1 2 3 4 5 |
ary = np.arange(1, 7).reshape(2, 3) print(ary) # [[1 2 3] # [4 5 6]] |
max()メソッドaxis=0は列単位で各列の最大値を探し、それらを要素とする配列（要素数＝列数の1次元配列）axis=1は行単位で各行の最大値を探し、それらを要素とする配列（要素数＝行数の1次元配列）|
1 2 3 4 5 |
print(ary.max(axis=0)) # [4 5 6] print(ary.max(axis=1)) # [3 6] |
sum()メソッドaxis=0は列単位で各列の合計を要素とする配列（要素数＝列数の1次元配列）axis=1は行単位で各行の合計を要素とする配列（要素数＝行数の1次元配列）|
1 2 3 4 5 |
print(ary.sum(axis=0)) # [5 7 9] print(ary.sum(axis=1)) # [ 6 15] |
repeat()メソッドaxis=0は列単位で各列の要素が指定回数繰り返されるaxis=1は行単位で各行の要素が指定回数繰り返される|
1 2 3 4 5 6 7 8 9 10 11 |
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次元の配列でも同じ結果になる。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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オブジェクトの各行の要素との和を計算する|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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オブジェクトの各行を指定した関数に渡す|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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次元配列に対してaxis引数を使う場合、行ベクトルとしてaxis=1に反応しそうだが、実際にはaxis=0で各要素に対する処理が行われる。axis=1を指定すると、たとえば以下のようなエラーになる。
|
1 |
ary.min(axis=1)->numpy.AxisError: axis 1 is out of bounds for array of dimension 1 |
元々多次元配列を意図した引数なので、1次元配列に使うのはナンセンスだろう（axis=0を行単位の処理にしておけば自然ではあったかもしれないが）。
1行の配列（1つの1次元配列を要素に持つ2次元配列：行ベクトル）に対するaxisの効果を、sumメソッドで見てみる。
|
1 2 3 4 5 6 7 8 9 |
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列の配列（列ベクトル）に対するaxisの効果を、sumメソッドで見てみる。
|
1 2 3 4 5 6 7 8 9 10 11 |
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次元配列（行ベクトル）で返される。