NumPyの入門【基礎から解説】

こんにちわ。

pythonには色々なパッケージライブラリがありますが、今回はpythonのパッケージライブラリの一つである NumPy について解説していきます。

Numpy は一言でいうと「配列」を行うためのライブラリです。

配列はリストにおいても出てくる重要な動作です。

まずはリストにおける配列とnumpyにおける配列の違いから学習していきましょう。

　本記事の学習内容

Numpyの配列の特徴を知る
Numpyで配列を作成する
Nmupyで配列を使用する

それでは早速見ていきましょう。

Numpyの配列の特徴

Numpyの特徴

Numpyは以下の特徴があります。

　Numpy の特徴

Numpyは処理能力が高い
Numpyは汎用性が高い
Numpyは1種類のデータのみしか収納できない
Numpyは一度配列を決めると、配列の「型」「要素」が固定される

Numpyは以上の様な特徴がありますが、Numpyはディープラーニングや機械学習においては数式処理で超必須のライブラリです。

なるべく習得できる様に頑張っていきましょう。

Numpyをimportする

Numpyを使用するためには次の一行を実行すれば可能です。

import numpy as np

これは配列を使用する際にはしょっちゅう使いますので、呪文の様に覚えておきましょう。

Numpy をimportすると以下の記載の仕方でメソッドを使う事ができます。

np.メソッド名()

# 例えば以下の様なメソッドがあります。

np.array()

np.arange()

np.linspace()

np.empty()

np.zeros()

np.onex()

np.random.rand()

たったこれだけです。

非常にカンタンです。

ではさっそく、Numpyで配列を作成してみましょう。

`array()` を使用する。

配列に有用なNumpyのメソッドをいくつか紹介します。

まず、配列の基本的なメソッドとして np.array はおさえておきましょう。

sanfu = np.array([1, 2, 3])
print(type(sanfu))
print(sanfu)
print(sanfu.dtype)

出力結果はこの様になります。

<class 'numpy.ndarray'>
[1 2 3]
int64

sanfuの型は numpy.ndarray になります。

また、.dtype は以下のサイトがまとまっているので参照しましょう。

NumPyの多次元配列ndarrayには、データ型を表現するdtypeというプロパティがあります。

このdtypeを指定することで、要素のデータ型を指定して確保するメモリ量を調節することができます。

» NumPyにおける要素のデータ型dtypeの種類と指定方法

ndarray とは N-dimensional array、N次元配列の事をいいます。

ndarray について詳しくは
»【Qiita】NumPy配列ndarrayまとめ　をご参照ください。

一般的にNumpyの配列の事を ndarray というのだな、くらいの理解で良いです。

またNumPy では通常、整数値は int64 、すなわち64 ビットサイズとして扱われているので、そういうモノだとしてとらえてください。

他にも色々とNumpyを使用して試していきましょう。

# 入力
s = np.array([3, 4.8, 12])
print(s)
print(s.dtype)

# 出力結果
[ 3.   4.8 12. ]
float64

# 入力
a = np.array([4 + 5j, 6 + 7j, 8 + 9j])
print(a)
print(a.dtype)

# 出力
[4.+5.j 6.+7.j 8.+9.j]
complex128

j は複素数のことでした。

#  入力
n = np.array([False, True])
print(n)
print(n.dtype)

# 出力
[False  True]
bool

ここで出てきた bool とは、真や偽を表す変数の型のことです。

# 入力
f = np.array(list("Sanfujinkainotechou"))
print(f)
print(f.dtype)

# 出力
['S' 'a' 'n' 'f' 'u' 'j' 'i' 'n' 'k' 'a' 'i' 'n' 'o' 't' 'e' 'c' 'h' 'o'
 'u']
<U1

以上色々と調べてみましたが、 np.array() の使い方について慣れましょう。

数値と文字列についての復習は以下の記事を参照にしてください。

: 【Python】数値と文字列について【初心者向け】
続きを見る

Numpyで整数、浮動小数点を使用する場合

通常データ型は浮動少数点であれば float64、整数値でも int64 であり64bit 消費してしまいます。

そのため、使用するデータの量を節約するために次の方法があります。

Numpyにおいてarray() を使用して配列を作る際に dtype = np.データ型 を用いるとそのデータ型にまで消費するbit数を節約する事ができます。

# 入力
x = np.array([10000, 20000, 30000], dtype = np.int32)
print(x)
print(x.dtype)

# 出力
[10000 20000 30000]
int32

整数であれば本来 64bit ですが、このように処理する事で32bitにまで圧縮する事ができます。

配列に有用なNumpyのメソッド

`np.arange()`

Pythonで連番を作る際の方法の一つとしてrange関数があります。

以下の様に使用する事で連番を作成する事ができます。

# 　入力
[x for x in range(1,21)]

# 出力
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

Numpyのメソッドにも、この様なrange関数と同様の機能があります。
実際に np.aarange() を使用してみましょう。

range() のように連続する整数値で ndarray を作りたい場合は np.arange() メソッドを使います。

# 入力
x = np.arange(31)
print(x)

y = np.arange(5, 26)
print(y)

z = np.arange(4, 35, 3)
print(z)

# 出力
[ 0  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]
[ 5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25]
[ 4  7 10 13 16 19 22 25 28 31 34]

`np.linspace()`

「$x$ 以上 $y$ 以下の数値を $z$ 分割」できるメソッドとして np.linspace() があります。

表記の仕方は np.linspace(x, y, z) とします。

# 入力
x = np.linspace(0, 27, 10)
print(x)

# 出力
[ 0.  3.  6.  9. 12. 15. 18. 21. 24. 27.]

これは0から27までの整数を10分割するので、実質的には $27÷9=3$ の間隔で整数が並ぶことになります。

`np.empty()`

要素を初期化せずに新しい配列を生成する関数に np.empty() というメソッドがあります。

このメソッドを使用する際には「ひとまず () の引数分の数をもつ配列を用意して、のちほど要素を代入したい」時に使います。

以下のサイトがまとまっているので参照にしてください。
» Samurai Blog【NumPy入門 np.empty】要素を初期化せずに新しい配列を作る。

実際に使用してみましょう。

# 入力
emp = np.empty(10)
print(emp)

# 出力
[ 0.  3.  6.  9. 12. 15. 18. 21. 24. 27.]

この出力の箇所は何が出てくるかわからないので、毎回異なる数字が出て来ます。

ドラクエのパルプンテみたいなメソッドですね。

`np.zeros()`

np.zeros() は配列の全要素を0で初期化する関数です。

配列を先に作っておきたいのだけれど、ついでに確実に初期化して要素を0にしておきたいときに使用します。

以下のサイトが詳しくまとめていますので参照にしてください。
» Samurai Blog【NumPy入門 np.zeros】0で初期化した配列を作るzeros関数の作り方。

では実際に使ってみましょう。

# 入力
k = np.zeros(10)
print(k)

# 出力
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

`np.ones()`

np.ones() は配列の全要素を1で初期化する事ができます。

np.zeros() と同様に配列を先に作っておきたいのだけれど、ついでに確実に初期化して要素を1にしておきたいときに使用します。

以下のサイトが詳しくまとめていますので参照にしてください。
» Samurai Blog【NumPy入門 np.ones】配列の全要素を1で初期化するones関数の使い方。

実際に使用してみましょう。

# 入力
l = np.ones(10)
print(l)

# 出力
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

`np.random.rand()`

np.random.rand() を使用する事で、ランダムな数値を出力する事が出来ます。

()の引数に要素の数を代入して使用出来ます。

出力される数値は、0以上1未満のランダムな少数点を含む数値になります。

実際に使用してみましょう。

# 入力
r = np.random.rand(10)
print(r)

# 出力
[0.00257539 0.1722596  0.61172187 0.00990091 0.60897311 0.31859115
 0.62533835 0.4227511  0.76508794 0.40823221]

全て0以上1未満の少数点になりましたね。

このメソッドは乱数を作成する際に使用されます。

そのため、その他にも色々な乱数を作成するメソッドもあります。
以下のサイトがまとまっているので、参照にして下さい。
» 【note.nkmk.me】NumPy, randomで様々な種類の乱数の配列を作成

`tolist()`

NumPy配列ndarrayとPython標準のリスト型listは相互に変換する事が出来ます。

以下にtolist()の特徴についてまとめておきます。
リスト型listをNumPy配列ndarrayに変換: numpy.array()
NumPy配列ndarrayをリスト型listに変換: tolist()
元のオブジェクトはそのままで新たな型のオブジェクトが生成される。
以下のサイトがまとまっているので、参照にして下さい。
>> 【note.nkmk.me】NumPy 配列ndarrayとPython標準のリストを交互に変換

以下のように、NumPy配列ndarrayのメソッドtolist()は、リスト型のオブジェクトを返す事が出来ます。

元のndarrayの次元数に応じて、ネストしたリストを取得する事が出来ます。各実際に1次元で使用してみましょう。

# 入力1
x = np.arange(5)
print(x)

# 出力1
[0 1 2 3 4]

# 入力2
y = x.tolist()
print(y)

# 出力2
[0, 1, 2, 3, 4]

この様に tolist() でリストを返す事が出来ます。

Numpyで多次元配列の作り方

これから、Numpyを用いて多次元配列に作り方を作成します。

Numpyの ndarray でも多次元配列のものを作成できます。

np.array() メソッドの引数に多次元のリスト・タプルを指定し代入してください。

実際に2次元配列のものを作成してみましょう。

2次元配列の作り方

実際に np.array() を使用して2次元配列のリストを作成してみましょう。

# 入力
x = np.array([[4, 5, 6], [9, 10, 11]])
print(x)

# 出力
[[ 4  5  6]
 [ 9 10 11]]

この様に2次元に変わりました。

1次元配列→多次元配列への変換の仕方

次に多次元配列のリストを作成してみましょう。

多次元リストを作成する際には、reshape() というインスタンスメソッドを仕様します。

インスタンスメソッドの説明については、以下の記事で説明しています。

# 入力
x = np.arange(1, 101)
y = x.reshape(5, 20)
print(x)
print(y)

# 出力

[  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  71  72
  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99 100]
[[  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  71  72  73  74  75  76  77  78
   79  80]
 [ 81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98
   99 100]]

x = np.arange() で 1から100までの配列を作成しています。

次に、この配列から reshape(5, 20) で「要素数が20個の配列を5個もつ配列」を2次元の形式で生成しました。

すなわち、reshape(x, y) を使用する事で、縦 $x$ 行・横 $y$ 列の二次元の配列を作る事が出来ます。

今回は2次元配列を作成しましたが、引数を3つに設定すれば3次元の配列のリストが作成できます。

もちろん3次元以上の配列リストも作成する事が出来ます。

多次元配列→1次元配列への変換の仕方

`flatten()`

flatten() の要点を引用してまとめておきます。

flatten() のポイントは以下の2点です。
flattenは多次元配列を一次元配列に変換する関数である
flattenは出力に新しい配列を作るので、その分だけnp.ravelより遅い
»【引用】Samurai Blog【NumPy入門 np.ndarray.flattern】多次元配列を1次元配列にしてみよう。

実際に flatten() を使ってみましょう。

# 入力

x = np.arange(1, 101).reshape(5, 20)
y = x.flatten()
print(x)
print(y)

# 出力

[[  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  71  72  73  74  75  76  77  78
   79  80]
 [ 81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98
   99 100]]
[  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  71  72
  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99 100]

`ravel()`

ravel() の要点を引用してまとめておきます。

ravel() の要点
np.ravel()は flatten()と同様に多次元配列を一次元配列に変換する関数である
np.ravel() は元の配列への参照を返すためメモリ効率がよく、高速である。
» 【引用】Samurai Blog【NumPy入門 np.ravel】多次元配列を1次元配列にするravel

# 入力① (xを2次元に直します)
x = np.arange(1, 101).reshape(5, 20)
print(x)

# 出力①
[[  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  71  72  73  74  75  76  77  78
   79  80]
 [ 81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98
   99 100]]

# 入力②
#  このこの多次元配列xを一次元配列に直します
y = x.ravel()
print(y)

[  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  71  72
  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99 100]

この様に、2次元配列を1次元配列に直す事が出来ました。

注意ポイント

flatten() は元の配列は元のままですので大丈夫です。

一方で、ravel() は元の配列が無くなるか、崩れる可能性がありますので注意が必要です。

しかしその分、ravel() の処理速度が高速というメリットがあります。

NumPyを使ってみる

Numpyに収納されている要素の参照と更新

実際に、NumPyを使ってみましょう。

ここで、ndarray は一度サイズを決めてしまうと変更出来ない特徴があります。

一方で、Numpyに収納されている要素の参照と更新が出来るのは以下の理由です。

Numpyによって既にある配列に新たな要素を追加した理、すでに要素を削除した配列を新しく作り直すことが出来るためです。

ndarray では「スライス」による参照が出来ます。

また、更新も出来ますし、配列の一部を取り出して新しい配列を作ることも出来ます。

これはリストやタプルと同様の機能です。タプルについては以下の記事を参照してください。

: 【Python】タプルの使い方【基本から応用まで】
続きを見る

2次元配列でためしてみましょう。

2次元配列の書き方は 配列名[縦][横] 、 配列名[縦, 横] 両方ともに可能です。

#  入力
x = np.arange(1, 101).reshape(10, 10)
print(x[1:11, 1:11]) # まずは全ての行列を表示してみます。

# 出力
[[ 12  13  14  15  16  17  18  19  20]
 [ 22  23  24  25  26  27  28  29  30]
 [ 32  33  34  35  36  37  38  39  40]
 [ 42  43  44  45  46  47  48  49  50]
 [ 52  53  54  55  56  57  58  59  60]
 [ 62  63  64  65  66  67  68  69  70]
 [ 72  73  74  75  76  77  78  79  80]
 [ 82  83  84  85  86  87  88  89  90]
 [ 92  93  94  95  96  97  98  99 100]]

ここで、スライスする部分を少し工夫していきましょう。

# 入力
x = np.arange(1, 101).reshape(10, 10)
print(x[0, 0])
print(x[1, 1])
print(x[2, 2])
print(x[1:2, 1:2])
print(x[2:4, 2:4])
print(x[1:11:2, 1:11:2])
print(x[:4, :4])
print(x[8:, 8:])
print(x[::3, ::3]) #3つ飛ばしで表示
print(x[:, :]) # 全ての行列を表示する事と同じ意味を持ちます。

# 出力
1
12
23

[[12]]

[[23 24]
 [33 34]]

[[ 12  14  16  18  20]
 [ 32  34  36  38  40]
 [ 52  54  56  58  60]
 [ 72  74  76  78  80]
 [ 92  94  96  98 100]]

[[ 1  2  3  4]
 [11 12 13 14]
 [21 22 23 24]
 [31 32 33 34]]

[[ 89  90]
 [ 99 100]]

[[  1   4   7  10]
 [ 31  34  37  40]
 [ 61  64  67  70]
 [ 91  94  97 100]]

[[  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]
 [ 71  72  73  74  75  76  77  78  79  80]
 [ 81  82  83  84  85  86  87  88  89  90]
 [ 91  92  93  94  95  96  97  98  99 100]]

少し多くなりましたが、一つ一つご自身で入力していくと法則も非常に簡単なのが分かります。

Numpyに収納されている要素の新規追加

NumPy で作成した要素に他の要素を追加するためには、 np.append() を使用します。

np.append() の記載は以下の様に記載します。

np.arange(追加したい要素の配列, (追加したいデータのリスト・またはタプル))

実際に np.append() を用いてみましょう。

# 入力①
x = np.arange(1, 30)
x = np.append(x, 30)
print(x)

# 出力②
[ 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]

# 入力②
x = np.append(x, (31,32,33,34,35))
print(x)

# 出力②
[ 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]

また、appned についての詳しい記事は以下に記載していますので、参考までにどうぞ。

: 【Python】appendの使い方のまとめ【基本から応用まで】
続きを見る

このうち、特定の場所に新しく要素を追加するときは np.insert() を使います。以下の様に使用します。

np.insert(追加したい要素の配列, 追加したい場所,(追加したいデータのリスト・またはタプル))

実際に np.insert() を使用してみましょう。

# 入力①
y = np.arange(1, 11)
y = np.insert(y, 2, 7)
print(y)

# 出力①
[ 1  2  7  3  4  5  6  7  8  9 10]

# 入力②
y = np.arange(1, 11)
y = np.insert(y, 4, (100, 103))
print(y)

# 出力②
[  1   2   3   4 100 103   5   6   7   8   9  10]

多次元配列でも insert() を利用する事が出来ます。。

その際、引数が1つ増えます。

ここで、引数 () 内の書き方にはルールがあります。

引数(①, ②, ③, ④)に沿って解説していきます。

引数のポイント

①には要素を追加したい元の配列を記載
②は要素を追加したい場所(行)を記載
③には追加する要素（単体データ・リスト・タプル形式)を記載
④が0の時には③は行に挿入、1の時には列に挿入される[/box]以上のルールのもとで作成していきましょう。

このルールに基づいて実際に試してみましょう。

import numpy as np

x =  [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],[0, 0, 0, 0]]
y = [2, 3, 4, 5]

# 入力①
# 上から2行目(1+1行目)に y を追加
z = np.insert(x, 1, y, 0)
print(z)

# 出力①
[[0 0 0 0]
 [2 3 4 5]
 [0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]

# 入力②
# 上から5行目(4+1行目)に y を追加
w = np.insert(x, 4, y , 0)
print(w)

# 出力②
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]
 [2 3 4 5]]

# 入力③
# 左から3列目(2+1列目)に y を列で追加
a = np.insert(x, 2, y, 1)
print(a)

# 出力③
[[0 0 2 0 0]
 [0 0 3 0 0]
 [0 0 4 0 0]
 [0 0 5 0 0]]

# 入力④
# 左から4列目(3+1列目)に y を列で追加
b = np.insert(x, 3, y, 1)
print(b)

# 出力④
[[0 0 0 2 0]
 [0 0 0 3 0]
 [0 0 0 4 0]
 [0 0 0 5 0]]

引数に記載されている内容のルールさえ把握すれば難しくないので、ルールを押さえておきましょう。

Numpyに収納されている要素の削除

Numpyで要素を削除する際には np.delete() を使います。

引数 () の記載する方法です。

（要素を削除したい配列, 削除したい位置）の様に記載してください。

実際にこのルールにのっとって試してみましょう。

# 入力
x = np.arange(1, 11)
x = np.delete(x, 4) # 削除する位置が'4'ですので、左から4+1番目の数字が削除されます。
print(x)

# 出力
[ 1  2  3  4  6  7  8  9 10]

多次元配列の際には insert と似た様なルールがあります。

np.delate() の引数(①, ②, ③) の記載のルールです。

引数(①, ②, ③)に沿って解説していきます。

引数のポイント

①には要素を追加したい元の配列を記載
②は要素を削除したい場所(行)を記載
③が0の時には②の要素は行から削除、1の時には列から削除される

このルールに基づいて実際に試してみましょう。

# 入力①
# 3行目(2+1列目)を削除
x = np.arange(1, 101).reshape(10, 10)
x = np.delete(x, 2, 0)
print(x)

# 出力①
[[  1   2   3   4   5   6   7   8   9  10]
 [ 11  12  13  14  15  16  17  18  19  20]
 [ 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]
 [ 71  72  73  74  75  76  77  78  79  80]
 [ 81  82  83  84  85  86  87  88  89  90]
 [ 91  92  93  94  95  96  97  98  99 100]]


#  入力②
# 4列目(3+1列目)を削除
y = np.arange(1, 26).reshape(5, 5)
z = np.delete(y, 3, 1)
print(z)

# 出力②
[[ 1  2  3  5]
 [ 6  7  8 10]
 [11 12 13 15]
 [16 17 18 20]
 [21 22 23 25]]

削除の方法についても引数の記載のルールさえ押さえておけば簡単ですので、色々と試してみてください。

NumPyで作成した配列行列としての使い方

四則演算

ndarray のメリットとして、Numpyに記載している配列は「行列」のように扱うことができます。

そのため、四則演算を行うことも簡単にできます。

実際に色々試してみましょう。

# 入力
x = np.arange(1, 21)
print(x)
print(x + 1)
print(x - 1)
print(x * 3)
print(x / 3)
print(x % 5)

# 出力
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]
[ 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21]
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[ 3  6  9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 57 60]
[0.33333333 0.66666667 1.         1.33333333 1.66666667 2.
 2.33333333 2.66666667 3.         3.33333333 3.66666667 4.
 4.33333333 4.66666667 5.         5.33333333 5.66666667 6.
 6.33333333 6.66666667]
[1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0]

また次に、「配列」「行列」同士の四則演算についても試してみましょう。

# 入力
# 配列同士の四則演算
x = np.arange(1, 31).reshape(5, 6)
y = np.arange(11, 41).reshape(5, 6)
print(y + x)
print(y - x)

# 出力
[[12 14 16 18 20 22]
 [24 26 28 30 32 34]
 [36 38 40 42 44 46]
 [48 50 52 54 56 58]
 [60 62 64 66 68 70]]

[[10 10 10 10 10 10]
 [10 10 10 10 10 10]
 [10 10 10 10 10 10]
 [10 10 10 10 10 10]
 [10 10 10 10 10 10]]

この様にreshapeする必要はありますが、行列同士の四則演算もカンタンにできます。

ユニバーサル関数

NumPy に搭載されている関数の機能にユニバーサル関数というものがあります。

Numpyの「行列」「配列」すなわち ndarray の全要素に対して、要素ごとに計算処理を行い、計算して得られた結果を ndarray で返し新しく作成した配列、関数をユニバーサル関数と呼びます。

それでは色々なユニバーサル関数を試してみましょう。

# 入力①
x = np.arange(1, 11)
print(x)
print(x / 3)

# 出力①
[ 1  2  3  4  5  6  7  8  9 10]

[0.33333333 0.66666667 1.         1.33333333 1.66666667 2.
 2.33333333 2.66666667 3.         3.33333333]


# 入力②
# np.floor() は切り捨てを表す
print(np.array(np.floor(x / 3), dtype=np.int64))

# 出力②
[0 0 1 1 1 2 2 2 3 3]


# 入力③
# np.ceil() は切り上げを表す
print(np.array(np.ceil(x / 3), dtype=np.int64))

# 出力③
[1 1 1 2 2 2 3 3 3 4]


# 入力④
# np.round() は四捨五入を表す
print(np.array(np.round(x / 3), dtype=np.int64))

# 出力④
[0 1 1 1 2 2 2 3 3 3]

その他にも色々なユニバーサル関数があるので、試してみてください。

» Universal function

まとめ|Numpy入門の基礎導入編

NumPyはpythonを扱う上で、特に「配列」「行列」をあつかう上で非常に重要なライブラリです。

色々なメソッドが出てきますし、要素の追加、挿入、削除の際には少しややこしい引数の記載の仕方のルールもあります。

これらは一度手を動かすと全く難しくないので、色々と試してみましょう。