データ処理/分析時などで数値計算を効率的に行う際に多用されるPythonライブラリNumPyについてまとめた記事になります。
- NumPyの基本的な使い方を知りたい人
- NumPyの便利なメソッドを使いたい人
- NumPyのメソッドによる具体的な手法を知りたい人
上記の悩みを解決しながら、NumPyのインストールから使い方まで解説します。
また、NumPyの具体的な手法でarange/arrayなどに関する解説を中心に記載しています。
NumPyとは
NumPy（Numerical Python）は、Pythonで数値計算を効率的に行うライブラリです。
多次元配列の操作に優れており、科学技術計算やデータ分析で利用されます。
以下は、matplotlibの主な特徴になります。
- 高速な数値計算
- 多次元配列のサポート
- 豊富な数学関数
- 他ライブラリとの連携
- 高パフォーマンスによる高速処理
- 使いやすさ
近年、機械学習/AI分野において、以下の理由からNumPyは必須ライブラリになっています。
- 膨大な数値計算を高速に行う必要があるため
- AI/機械学習を実装する便利な関数が多く存在するため
NumPyのインストール
NumPyを利用するためには、ローカルPC上にインストールする必要があります。
以下は、NumPyのインストール方法になります。
- Anaconda（Pythonパッケージ）の一括インストール
- NumPy単体のインストール
また、全く環境構築ができていない場合を考え、以下の構築ステップを記載します。
Pythonの公式サイトからインストーラーをダウンロードします。
各OSに合わせたインストーラーを起動することでPythonを自身のPCにインストールできます。
Pythonの詳細なインストール手順や設定を画像で知りたい人は「【Python】ダウンロードとインストール方法から開発環境構築まで解説！」を一読ください。
基本的に、Pythonをインストールした時点で付属モジュールとしてpipもインストールしています。
pipモジュールを利用することでNumPyのインストールが可能になります。
pip --version上記のコードにて、pipモジュールのバージョンを確認できます。
NumPyをインストールする場合は、以下のコマンドをターミナルあるいはコマンドプロンプトで実行します。
Pythonパッケージ管理ツールpipを利用することでインストールできます。
pip install numpyJupyter Notebookをお使いの方は、起動したNotebookのセルに、先頭に!マークをつけて実行することでインストールすることが出来ます。
!pip install numpyまた、データ分析環境でよく利用されるJupyter NotebookあるいはJupyter Labの記事も一読ください。
オンライン環境でPythonを扱いたい人は「【Python】Google Colaboratoryとは？料金から使い方まで網羅的に解説！」を一読ください。
NumPyの基本的な使い方
ここでは、NumPyの基本的な使い方として代表的なメソッド（関数）を解説します。
以下は、Numpyの代表的なメソッドになります。
- numpy.arange()
- numpy.array()
- numpy.dot()
- numpy.where()
- numpy.zeros()
すでに何かしらの計算結果データをお持ちの人は、ぜひ利用してみてください。
データをお持ちでない人もサンプルデータを用意しているため、サンプルコードを確認してください。
numpy.arange()
numpy.arange()は、指定した範囲で等間隔の値を持つNumPy配列を生成する関数です。
Pythonの組み込み関数range()に似てますが、浮動小数点のステップ値にも対応します。
範囲はstartからstopまで（stop は含まれません）で、stepにより間隔を指定します。
主に繰り返し処理や配列初期化/数値シミュレーションの範囲設定などに利用されます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| start | 必須または0 | 開始値（1つだけ指定した場合はstart=0, stop=値と解釈） |
| stop | 必須 | 終了値（この値は含まれない） |
| step | 1 | 値の間隔（負の値も可） |
| dtype | None | 配列のデータ型（明示指定しない限り自動推定） |
| like | None | 新しい配列が参照する配列（NumPy1.20以降、拡張目的で使用） |
start, stopの基本例
実行内容は、3から始まり10未満（10は含まず）までの整数値を含むNumPy配列を生成しています。
import numpy as np
a = np.arange(3, 10)
print(a)[3 4 5 6 7 8 9]stepの指定（負のステップも可能）
実行内容は、10から始まり3より大きい範囲まで2ずつ減少する数列を生成しています。
import numpy as np
b = np.arange(10, 3, -2)
print(b)[10 8 6 4]dtypeの指定（浮動小数点）
実行内容は、1から5未満まで0.5間隔で、32ビット浮動小数点として配列を生成しています。
import numpy as np
c = np.arange(1, 5, 0.5, dtype=np.float32)
print(c)[1. 1.5 2. 2.5 3. 3.5 4. 4.5]like引数の使用（NumPy拡張用途）
実行内容は、xと同じ型の配列オブジェクトとして[0 1 2 3 4]を生成しています。（通常使用では不要）
import numpy as np
x = np.array([1, 2, 3])
d = np.arange(0, 5, like=x)
print(d)[0 1 2 3 4]numpy.array()
numpyp.array()は、Pythonのリスト/タプル/配列状のオブジェクトをNumPy配列（ndarray）に変換する関数です。
多次元配列を作成でき、NumPyの強力な数値演算機能を利用する基盤になります。
必要に応じて、要素型（dtype）や次元数/コピー有無/順序などを細かく制御できます。
配列の初期化やデータ構造の変換に使われる関数の1つです。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| object | なし（必須） | リストやタプル、他の配列など配列化対象のオブジェクト |
| dtype | None | 要素のデータ型（例: float, int32, boolなど） |
| copy | True | True: データのコピーを作成する / False: 可能ならコピーせず参照 |
| order | None | ‘K’ メモリ順序（’C’: C順、’F’: Fortran順、’A’, ‘K’など） |
| subok | False | True: サブクラスのインスタンスを保持 / False: ndarrayに強制変換 |
| ndmin | 0 | 最小次元数を指定（例: ndmin=2で最低でも2次元にする） |
| like | None | 他の配列に“似た”オブジェクトを作成（NEP-35拡張） |
object（基本的な使い方）
リスト[1, 2, 3]をNumPy配列に変換しています。
import numpy as np
a = np.array([1, 2, 3])
print(a)[1 2 3]dtype（型を明示指定）
整数リストをfloat型配列に変換（[1.0, 2.0, 3.0]）しています。
import numpy as np
b = np.array([1, 2, 3], dtype=float)
print(b)[1.0 2.0 3.0]copy=False（コピーせず共有）
可能ならオリジナルデータを参照しコピーを抑制（ただし通常はコピーされる）しています。
import numpy as np
lst = [1, 2, 3]
c = np.array(lst, copy=False)
lst[0] = 99
print(c) # 通常は影響なし（Python list → NumPyではコピーが行われるため）order=’F’（列優先のメモリ順）
Fortran形式の列優先で内部的に配列を格納しています。
import numpy as np
d = np.array([[1, 2], [3, 4]], order='F')
print(d)[[1 2] [3 4]] #（見た目には変化なし）subok=True（サブクラス保持）
subok=Trueでサブクラスを維持（この例ではndarrayに戻る）しています。
import numpy as np
class MyArray(np.ndarray): pass
arr = np.array([1, 2, 3])
e = np.array(arr, subok=True)
print(type(e))ndmin=2（最低2次元）
1次元リストを強制的に2次元配列にします。
import numpy as np
f = np.array([1, 2, 3], ndmin=2)
print(f)
print(f.shape)[[1 2 3]] # 形状は(1, 3)like（他の配列と互換な形で作成）
likeは拡張用途です。
通常はnp.array(…)と等価な結果になります。
import numpy as np
g = np.array([1, 2, 3], like=np.array([10, 20, 30]))
print(g)numpy.dot()
numpy.dot()は、内積（ドット積）を計算する関数で、ベクトル同士/行列同士/スカラーとの掛け算などに対応します。
1次元配列同士では通常の内積、2次元配列では行列の積になります。
多次元配列（3次元以上）の場合は、最後の軸と次元が合うように計算されます。
基本的な線形代数処理の基礎となる関数です。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| a | 必須 | ドット積を計算する左側の配列 |
| b | 必須 | ドット積を計算する右側の配列 |
| out | None | 計算結果を格納する出力配列（指定しない場合、新しい配列を返す） |
a, b（1次元配列の内積）
1×4 + 2×5 + 3×6 = 32 の内積を計算します。
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
result = np.dot(a, b)
print(result)32a, b（2次元配列の行列積）
行列の掛け算を行います。
result[i][j] = a[i][0]*b[0][j] + a[i][1]*b[1][j] で計算されます。
import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
result = np.dot(a, b)
print(result)[[19 22]
[43 50]]out引数で結果を別配列に保存
numpy.dot(a, b)の計算結果をout_arrに保存（再利用メモリを節約）しています。
import numpy as np
a = np.array([1, 2])
b = np.array([3, 4])
out_arr = np.empty(1)
np.dot(a, b, out=out_arr)
print(out_arr)[11.] # （1*3 + 2*4 = 11）- np.dot()は、主に線形代数の内積表現として使われる
- NumPyでは@演算子（Python 3.5以降）やnp.matmul()/np.einsum()などもある
- 高速化やブロードキャスト目的ではnp.inner()やnp.outer()との違いに注意
numpy.where()
numpy.where()は、条件に基づいて要素のインデックスや値を取得・選択する関数です。
1つの引数を与えると、条件を満たす要素のインデックス（位置）を返します。
3つの引数（条件、True時の値、False時の値）を与えると、条件に応じて値を選択した配列を返します。
ブール条件に基づく要素の抽出や置換に便利な関数です。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| condition | 必須 | 真偽値（bool）型の配列や条件式 |
| x | 省略可 | 条件がTrueの位置に使用する値（指定時） |
| y | 省略可 | 条件がFalseの位置に使用する値（指定時） |
conditionのみ（インデックス取得）
a > 25の条件を満たす要素のインデックスを取得し、該当する値を抽出しています。
import numpy as np
a = np.array([10, 20, 30, 40, 50])
index = np.where(a > 25)
print(index)
print(a[index])(array([2, 3, 4]),)
[30 40 50]condition, x, y（条件で値を選択）
偶数なら”even”、奇数なら”odd”を選んで文字列配列を作成しています。
import numpy as np
b = np.array([1, 2, 3, 4, 5])
result = np.where(b % 2 == 0, "even", "odd")
print(result)['odd' 'even' 'odd' 'even' 'odd']x, yに配列指定（値置き換え）
0以下の要素を0に置き換えています。（c > 0がTrueのときはそのまま、Falseのときは0）
import numpy as np
c = np.array([-1, 0, 1, 2])
result = np.where(c > 0, c, 0)
print(result)[0 0 1 2]- np.where(condition)のように、引数1つで呼ぶと「インデックス配列」を返す
- np.where(condition, x, y)のように、引数3つで呼ぶと「条件分岐付きの新しい配列」を返す
- ブロードキャスト対応のため、x/yはスカラーでも配列でもOK
numpy.zeros()
numpy.zeros()は、指定した形状と型の要素がすべて0の新しい配列を作成する関数です。
多次元のゼロ初期化された配列（ベクトルや行列など）を生成できます。
配列の形はタプルや整数で指定し、dtypeにより要素のデータ型も選べます。
数値計算の初期化やテンプレート作成において使われます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| shape | 必須 | 作成する配列の形（整数またはタプル） |
| dtype | float64 | 配列要素のデータ型（例：int, float, boolなど） |
| order | ‘C’ | 配列のメモリ順序。’C’は行優先、’F’は列優先 |
shapeのみ指定（基本的な使い方）
2行3列のゼロ行列を作成しています。（デフォルトfloat64）
import numpy as np
a = np.zeros((2, 3))
print(a)[[0. 0. 0.]
[0. 0. 0.]]dtypeを指定して整数配列
要素型を整数に指定し、3要素のゼロ配列を作成しています。
import numpy as np
b = np.zeros((3,), dtype=int)
print(b)[0 0 0]orderを指定（列優先の配列）
列優先（Fortranスタイル）でメモリに格納される2×2ゼロ行列を作成しています。
import numpy as np
c = np.zeros((2, 2), order='F')
print(c)[[0. 0.]
[0. 0.]]- np.zeros_like()を使うと既存配列と同じ形でゼロ配列を作れる
- zeros()で作成した配列は数値演算や初期化時のベースで利用できる
- 多次元行列（例：3次元テンソルなど）にも簡単に対応（例：np.zeros((2, 3, 4))）
NumPyのその他メソッドと引数
numpyライブラリにはその他の多くのメソッドが存在します。
また、各メソッドに対して多くの引数があるため、改めて各メソッドと引数をまとめます。
| メソッド | 説明 |
|---|---|
| np.ones | 指定サイズの1埋め配列生成 |
| np.linspace | 等間隔値をnum点生成 |
| np.reshape | 配列を形状変更 |
| np.transpose | 転置または次元並び替え |
| np.add / np.subtract / np.multiply / np.divide / np.sqrt / np.power | 要素演算（加算・指数など） |
| np.sum / np.prod / np.mean / np.std / np.min / np.max | 集計・統計量計算 |
| np.save / np.load / np.savetxt / np.loadtxt | バイナリ・テキスト形式の読み書き |
| np.all / np.any | 論理判定（全/いずれか） |
numpy.ones()
numpy.ones()は、指定した形状・データ型で全要素が1の新しい配列を生成する関数です。
shapeにより多次元の構造にし、dtypeにより要素の型を設定できます。
初期化された配列が全て1であるため、機械学習や統計処理の初期値設定に使われます。
orderにより行優先（C）または列優先（Fortran）での配置も可能です。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| shape | 必須 | 作成する配列の形（整数またはタプル） |
| dtype | float64 | 配列要素のデータ型（例：int, float, boolなど） |
| order | ‘C’ | 配列のメモリ順序。’C’は行優先、’F’は列優先 |
shapeのみ指定（基本的な使い方）
2行3列のすべての要素が1の行列を作成します。（デフォルトfloat64型）
import numpy as np
a = np.ones((2, 3))
print(a)[[1. 1. 1.]
[1. 1. 1.]]dtypeを指定して整数型にする
要素を整数型に指定し、1次元・4要素の配列[1 1 1 1]を作成します。
import numpy as np
b = np.ones((4,), dtype=int)
print(b)[1 1 1 1]orderを指定して列優先配列にする
2×2の配列を列優先順（Fortranスタイル）で生成しています。（表示は同じでも内部構造が異なる）
import numpy as np
c = np.ones((2, 2), order='F')
print(c)[[1. 1.]
[1. 1.]]- np.ones_like(a)を使えば既存配列と同じ形で1の配列を作成できる
- 学習用初期重み/バイアスベクトル/行列初期化の用途で使用
- np.full()を使うと任意の値で埋められた配列も作成できる（例：全て7など）
numpy.linspace()
numpy.linspace()は、指定した範囲の数値を等間隔に分割した配列を生成する関数です。
startからstopまでを等間隔でnum個に分けた値を返します。
数値の補間/グラフのx軸の目盛作成/数値解析などで使われます。
オプションでendpoint（終了値の含有）やdtype/retstepなども指定可能です。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| start | 必須 | 配列の開始値 |
| stop | 必須 | 配列の終了値 |
| num | 50 | 生成する要素数 |
| endpoint | True | stopを配列に含めるかどうか |
| retstep | False | 間隔（ステップサイズ）も返すか |
| dtype | None | 結果のデータ型を指定 |
| axis | 0 | 配列をどの軸に並べるか（多次元に拡張する際に使用） |
startとstopの基本的な使用
0から10までを5分割（両端含む）した配列を生成しています。
import numpy as np
a = np.linspace(0, 10, 5)
print(a)[ 0. 2.5 5. 7.5 10. ]endpoint=False（終了値を含めない）
0から10未満を5分割し、10は含めないよう処理しています。
import numpy as np
b = np.linspace(0, 10, 5, endpoint=False)
print(b)[0. 2. 4. 6. 8.]retstep=True（ステップ幅も取得）
0～1を5分割した値とそのステップ幅（0.25）を同時に取得しています。
import numpy as np
c, step = np.linspace(0, 1, 5, retstep=True)
print("配列:", c)
print("ステップ幅:", step)配列: [0. 0.25 0.5 0.75 1. ]
ステップ幅: 0.25dtype=int（型指定）
整数型として配列を生成しています。（小数点以下切り捨てにより同じ値が並ぶこともある）
import numpy as np
d = np.linspace(1, 5, 5, dtype=int)
print(d)[1 2 3 4 5]axis=1（多次元での並べ方）
reshapeと組み合わせてaxis指定の挙動に類似した使い方が可能です。
import numpy as np
e = np.linspace(0, 1, 5).reshape(1, -1)
f = np.linspace(0, 1, 5).reshape(-1, 1)
print("axis=1 相当:\n", e)
print("axis=0 相当:\n", f)- linspace()はarange()と似ていますが、分割数ベースで指定するのが特徴
- グラフ目盛や信号処理の周波数領域、物理シミュレーションなどの用途で使用
- retstep=Trueによって生成間隔を簡単に確認できて検証時も便利
numpy.reshape()
numpy.reshape()は、既存のNumPy配列の形状（次元数・サイズ）を変更するためのメソッドです。
元のデータは変更せずに、要素数を保ったまま新しい形状に再構成できます。
行列変換・画像処理・ディープラーニングなどで多用されます。
サイズを自動計算させるには-1を指定して変形できます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| newshape | 必須 | 新しい形状（int または tuple of int）。要素数の積は元と同じでなければならない |
| order | ‘C’ | データの読み取り順序： ‘C’（行優先）、’F’（列優先）、’A’（元の順序を可能な限り維持） |
newshapeを指定して配列の形状変更
1次元配列[1, 2, 3, 4, 5, 6]を2行3列に変形しています。
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
b = a.reshape((2, 3))
print(b)[[1 2 3]
[4 5 6]]-1を使ってサイズを自動計算
列を2列に固定し、行数を自動計算しています。（3行2列）
import numpy as np
c = a.reshape((-1, 2))
print(c)[[1 2]
[3 4]
[5 6]]order=’F’（列優先のメモリ順）
列優先（Fortranスタイル）で再構成しています。
import numpy as np
d = a.reshape((2, 3), order='F')
print(d)[[1 3 5]
[2 4 6]]order=’A’（元の順序に準拠）
元の配列がC順序であればC順序、F順序であればF順序を維持します。
import numpy as np
e = a.reshape((2, 3), order='A')
print(e)[[1 2 3]
[4 5 6]]- reshape()は、元のデータの要素数と同じ総数になる必要がある
- データコピーはせず、メモリビューを返すため高速（条件により異なる）
- np.reshape(a, newshape)の関数形式でも利用
numpy.transpose()
numpy.transpose()は、NumPy配列の軸（次元）を並べ替えるメソッドです。
2次元配列の場合は、行と列を入れ替える操作（転置）になります。
多次元配列では任意の軸順に変更でき、テンソルの軸変換などに活用されます。
データの並べ替えはビューとして返され、元データは変更されません。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| axes | None | 転置後の軸の順番（タプルやリスト）。指定がない場合は全軸を逆順にする |
axesを指定しない（2次元転置）
3行2列の行列を転置して、2行3列に変更（行と列を入れ替え）しています。
import numpy as np
a = np.array([[1, 2], [3, 4], [5, 6]])
b = a.transpose()
print(b)[[1 3 5]
[2 4 6]]axesを指定して明示的に転置（同上）
明示的に(1, 0)を指定して行列を転置（列→行, 行→列）しています。
c = a.transpose((1, 0))
print(c)[[1 3 5]
[2 4 6]]3次元配列の軸を入れ替える例
形状 (2, 3, 4) を (3, 2, 4) に変更しています。（第1軸と第2軸を入れ替え）
d = np.arange(24).reshape(2, 3, 4)
e = d.transpose((1, 0, 2))
print(e.shape)(3, 2, 4)- transpose()は元配列と同じデータを使ったビューを返すためメモリ効率が良い
- 多次元配列の軸変換にはnp.moveaxis()やnp.swapaxes()との使い分けも可能
numpy.add()
numpy.add()は、要素単位での加算を行うNumPyの汎用関数（ufunc）です。
スカラーや配列（ブロードキャスト可能な形状）同士を加算でき、配列演算の基本となります。
通常の+演算子の代わりに使える関数形式で、追加の制御（出力先の配列など）も可能です。
outやwhereなどのキーワード引数を使えば、部分的な加算処理も柔軟に行えます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| x1 | 必須 | 最初の入力配列（またはスカラー） |
| x2 | 必須 | 2番目の入力配列（またはスカラー） |
| out | None | 結果を格納する配列（ブロードキャスト互換である必要あり） |
| where | True | 演算を適用する位置を示すブール配列 |
| dtype | None | 結果配列のデータ型を指定 |
| casting | ‘same_kind’ | 型キャストのルール（例：’no’, ‘unsafe’, ‘safe’） |
| order | ‘K’ | 出力配列のメモリ順序（’C’, ‘F’, ‘A’, ‘K’） |
| subok | True | サブクラス型の配列を出力として許可するか |
| signature | None | 高度なufuncの型指定（基本使用しない） |
| extobj | None | 高度なオプション（省略可） |
基本的な加算（x1, x2）
対応する要素同士を加算。
import numpy as np
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
c = np.add(a, b)
print(c)[11 22 33]outを使って結果を別の配列に格納
結果をresult配列に格納（[11 22 33]）
result = np.empty_like(a)
np.add(a, b, out=result)
print(result)whereを使って特定の要素だけ加算
加算する場所をマスクで指定（2番目の要素は加算されない）
mask = np.array([True, False, True])
d = np.add(a, b, where=mask)
print(d)[11 2 33]dtypeを指定して結果型を変更
結果をfloat32型で返す。
e = np.add(a, b, dtype=np.float32)
print(e)[11. 22. 33.]（dtype: float32）- np.add(x1, x2)は、x1+x2と等価だが、outやwhere などを使う場合は関数形式が便利
- 高度な引数（signature, extobj）は通常の用途では不要
- 演算速度やメモリ制御が必要な場面ではoutを使ってメモリ再利用が推奨
numpy.subtract()
np.subtract()は、要素単位の減算演算を行うNumPyの汎用関数（ufunc）です。
2つのスカラーまたは配列の差（x1 – x2）を返します。
ブロードキャストも可能で、サイズの異なる配列同士でも形状が整えば演算できます。
加算（np.add）と同様、outやwhereを指定して部分的に制御した演算も可能です。
通常の-演算子と等価ですが、より高度な使い方が可能です。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| x1 | 必須 | 最初の入力（被減数：左側） |
| x2 | 必須 | 2番目の入力（減数：右側） |
| out | None | 出力先の配列（省略時は新しく作成） |
| where | True | 条件に一致する要素のみ演算を適用 |
| dtype | None | 結果のデータ型を明示的に指定 |
| casting | ‘same_kind’ | 型キャストのルール（例: ‘no’, ‘safe’） |
| order | ‘K’ | 出力配列のメモリ順序（例: ‘C’, ‘F’） |
| subok | True | サブクラス型の配列を出力として許可するか |
| signature | None | 高度なufunc型指定（通常使用しない） |
| extobj | None | 高度な制御のためのオプション（通常使用しない） |
基本的な減算（x1, x2）
配列aとbの要素ごとの差を計算。
import numpy as np
a = np.array([10, 20, 30])
b = np.array([1, 2, 3])
c = np.subtract(a, b)
print(c)[ 9 18 27]outを使用（結果を指定の配列に格納）
結果をresult配列に格納（メモリ再利用）。
result = np.empty_like(a)
np.subtract(a, b, out=result)
print(result)[ 9 18 27]whereを使用（条件に合う要素のみ減算）
whereで指定された要素位置のみ計算、その他はx1の値を維持。
mask = np.array([True, False, True])
d = np.subtract(a, b, where=mask)
print(d)[ 9 20 27]dtypeを使用（結果の型を明示）
結果をfloat32型として計算。
e = np.subtract(a, b, dtype=np.float32)
print(e)[ 9. 18. 27.]（dtype: float32）- np.subtract(x1, x2)はx1-x2とまったく同じ結果を返す
- np.subtract()のメリットは、out,where,dtypeを使った演算制御の柔軟性
- ブロードキャスト対応なのでスカラーとの演算や多次元配列との組み合わせにも対応
numpy.multiply()
np.multiply()は、要素単位の掛け算（積）を行うNumPyの汎用関数（ufunc）です。
2つの配列やスカラーに対して、x1 * x2と同じ結果を返します。
outやwhere/dtypeなどの追加引数により、部分的な演算や出力型の制御も可能です。
ブロードキャストに対応しているため、形状が異なる配列同士の計算も柔軟に行えます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| x1 | 必須 | 最初の入力（左辺の因数） |
| x2 | 必須 | 2番目の入力（減数：右側） |
| out | None | 結果を格納する出力配列 |
| where | True | 条件に一致した位置にのみ演算を適用 |
| dtype | None | 結果のデータ型（例: np.float32） |
| casting | ‘same_kind’ | キャストの安全性（例: ‘no’, ‘safe’） |
| order | ‘K’ | 出力配列のメモリ順序（例: ‘C’, ‘F’） |
| subok | True | サブクラスの配列を出力として許可するか |
| signature | None | 型署名（高度な ufunc 向け） |
| extobj | None | 高度な制御（通常は使用しない） |
基本的な掛け算（x1, x2）
[1*10, 2*20, 3*30] を計算。
import numpy as np
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
c = np.multiply(a, b)
print(c)[10 40 90]outを使用して結果を指定の配列に格納
演算結果をresultに直接格納。
メモリ再利用に便利。
result = np.empty_like(a)
np.multiply(a, b, out=result)
print(result)[10 40 90]whereを使って特定の要素のみ演算
whereにより[1*10, 2, 3*30]を計算。
Falseの位置はx1の値がそのまま残る。
mask = np.array([True, False, True])
d = np.multiply(a, b, where=mask)
print(d)[10 2 90]dtypeを指定して結果の型を変更
計算結果をfloat32型で出力。
e = np.multiply(a, b, dtype=np.float32)
print(e)[10. 40. 90.]- np.multiply()は、*演算子と同じく要素ごとの積を返す
- np.multiply()の利点は、ブロードキャスト対応/型制御/outによるメモリ節約などの柔軟性
- 同様の形式で他の演算（divide, power, mod など）も提供可能
numpy.divide()
np.divide()は、NumPy配列やスカラー同士の要素単位の除算を行う関数です。
x1/x2と同様の結果を返しますが、追加の引数でデータ型や結果格納先の指定、演算適用条件を細かく制御できます。
ブロードキャストをサポートしているため、異なる形状の配列同士でも柔軟に演算が可能です。
ゼロ除算が発生すると、警告を出しながらinfまたはnanを返す場合があります。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| x1 | 必須 | 分子となる配列またはスカラー（左辺） |
| x2 | 必須 | 分母となる配列またはスカラー（右辺） |
| out | None | 結果を格納する出力配列（省略可） |
| where | True | Trueの要素にのみ演算を適用 |
| dtype | None | 出力配列のデータ型を指定 |
| casting | ‘same_kind’ | 型変換の安全性の指定（例: ‘no’, ‘safe’） |
| order | ‘K’ | 出力配列のメモリレイアウト（例: ‘C’, ‘F’） |
| subok | True | サブクラス型の出力を許可するか |
| signature | None | 明示的な型署名（ufunc用） |
| extobj | None | 拡張オブジェクト（高度な制御用） |
基本的な使い方（x1, x2）
[10/2, 20/4, 30/5] → [5.0, 5.0, 6.0] を要素ごとに計算。
import numpy as np
a = np.array([10, 20, 30])
b = np.array([2, 4, 5])
result = np.divide(a, b)
print(result)outを指定して結果を格納
出力用に事前に確保した配列outputに計算結果を格納しています。
メモリ効率向上します。
output = np.empty_like(a, dtype=float)
np.divide(a, b, out=output)
print(output)whereを使って条件付き除算
Trueの位置だけ除算し、Falseの位置はそのまま保持（内容未定義のこともある）。
mask = np.array([True, False, True])
result = np.divide(a, b, where=mask)
print(result)dtypeを指定して浮動小数型で除算
計算結果をfloat64型に明示的に変換して出力。
result = np.divide(a, b, dtype=np.float64)
print(result)- np.divide()はスカラーにも対応し、np.divide(10, 2)のような使い方も可能
- 0除算が発生した場合、RuntimeWarningが表示され、infまたはnanが返される
- np.true_divide()も似ていますが、np.divide()の方が柔軟性のある一般的な除算
numpy.sqrt()
np.sqrt()は、配列内の各要素に対して平方根（√）を計算するNumPyのユニバーサル関数（ufunc）です。
負の値に対してはnanを返し、RuntimeWarningを発生させます（複素数として扱う場合はnp.lib.scimath.sqrt()を使用）。
スカラー/1次元配列/多次元配列全てに適用可能でブロードキャストにも対応しています。
演算結果の格納先や演算対象のマスク指定など柔軟に制御できます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| x | 必須 | 平方根を計算する対象の配列またはスカラー |
| out | None | 結果を格納する出力配列（省略可） |
| where | True | Trueの要素にのみ演算を適用 |
| dtype | None | 出力配列のデータ型を指定 |
| casting | ‘same_kind’ | 型変換の安全性の指定（例: ‘no’, ‘safe’） |
| order | ‘K’ | 出力配列のメモリレイアウト（例: ‘C’, ‘F’） |
| subok | True | サブクラス型の出力を許可するか |
| signature | None | 明示的な型署名（ufunc用） |
| extobj | None | 拡張オブジェクト（高度な制御用） |
基本的な使い方（x）
各要素の平方根 [√1, √4, √9, √16] → [1., 2., 3., 4.] を計算します。
import numpy as np
a = np.array([1, 4, 9, 16])
result = np.sqrt(a)
print(result)outを使って結果を指定の配列に格納
平方根の結果をoutput配列に格納します（メモリ効率の最適化に有効です）。
output = np.empty_like(a, dtype=float)
np.sqrt(a, out=output)
print(output)whereを使って一部の要素にのみ平方根を適用
Trueの場所のみ平方根を計算し、その他の場所は計算しない（値は未定義になる可能性があります）。
mask = np.array([True, False, True, False])
result = np.sqrt(a, where=mask)
print(result)dtypeを指定して型を明示する
計算結果をfloat64型に変換して出力。精度を上げたい場合に使用します。
result = np.sqrt(a, dtype=np.float64)
print(result)- xの要素が負数の場合、nanを返してRuntimeWarningが出力される
- 複素数の平方根を扱いたい場合はnp.lib.scimath.sqrt()を使うと安全
- np.sqrt()はufuncであり、ブロードキャストや型制御の機能を多く持つ
numpy.power()
np.power()は、NumPyのユニバーサル関数（ufunc）の一つで配列要素を指定された指数で累乗（べき乗）する関数です。
スカラー同士/配列とスカラー/配列同士でのべき乗演算に対応しており、要素ごとに演算されます。
出力先の配列指定（out）、マスク制御（where）など指定可能です。
配列のブロードキャストにも対応しており、効率的な数値演算に使われます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| x1 | 必須 | 累乗の「底」部分（配列またはスカラー） |
| x2 | 必須 | 累乗の「指数」部分（配列またはスカラー） |
| out | None | 結果を格納する出力配列（省略可） |
| where | True | Trueの要素にのみ演算を適用 |
| dtype | None | 出力配列のデータ型を指定 |
| casting | ‘same_kind’ | 型変換の安全性の指定（例: ‘no’, ‘safe’） |
| order | ‘K’ | 出力配列のメモリレイアウト（例: ‘C’, ‘F’） |
| subok | True | サブクラス型の出力を許可するか |
| signature | None | 明示的な型署名（ufunc用） |
| extobj | None | 拡張オブジェクト（高度な制御用） |
基本的な使い方（x1, x2）
a ** b を要素ごとに計算します → [2**3, 3**2, 4**1] → [8, 9, 4]
import numpy as np
a = np.array([2, 3, 4])
b = np.array([3, 2, 1])
result = np.power(a, b)
print(result)outを使って結果を指定の配列に格納
演算結果 [8, 9, 4] を事前に用意した配列outputに格納します。
output = np.empty_like(a)
np.power(a, b, out=output)
print(output)whereを使って一部の要素にのみ演算
Trueの場所のみ演算を行い、それ以外は初期値のままになります。
mask = np.array([True, False, True])
result = np.power(a, b, where=mask)
print(result)dtypeを使って出力型を明示する
演算結果をfloat64型に変換。特に大きな値や精度が必要な場合に有効です。
result = np.power(a, b, dtype=np.float64)
print(result)- x1とx2にスカラーを指定すると、単純な数値のべき乗にも使える
- 負の底に対して実数の非整数指数を指定するとnanを返す
numpy.sum()
np.sum()は、NumPy配列に含まれる要素の合計値を計算する関数です。
任意の軸（次元）を指定して合計を求めることができて配列の部分的な集計にも対応しています。
また、結果を格納する出力配列やデータ型の指定/NaNを除いた処理も可能です。
多次元配列の統計処理や前処理に用いられる関数です。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| a | 必須 | 合計を計算する入力配列 |
| axis | None | 合計を取る軸。Noneの場合、全要素を合計 |
| dtype | None | 計算中および結果のデータ型 |
| out | None | 結果を格納する配列 |
| keepdims | False | 合計後の配列形状に次元を保持するか |
| initial | 0 | 合計開始値（例：累積に初期値を加える） |
| where | True | Trueの位置のみを合計対象とする条件指定 |
基本的な使い方（配列全体の合計）
配列全体の合計 → 1 + 2 + 3 + 4 = 10
import numpy as np
arr = np.array([[1, 2], [3, 4]])
result = np.sum(arr)
print(result)axisを指定して行または列ごとの合計を取得
axis=0: 列ごと → [1+3, 2+4] = [4, 6]
axis=1: 行ごと → [1+2, 3+4] = [3, 7]
result_axis0 = np.sum(arr, axis=0)
result_axis1 = np.sum(arr, axis=1)
print(result_axis0) # 列ごとの合計
print(result_axis1) # 行ごとの合計dtypeを指定して型を明示
合計値をfloat64型として返す。
result = np.sum(arr, dtype=np.float64)
print(result)outを使って結果を別の配列に保存
合計結果10を事前に用意したoutput配列に格納する。
output = np.empty(1)
np.sum(arr, out=output)
print(output)keepdims=Trueで次元を保持
行ごとの合計 [3, 7] を2次元配列として [ [3], [7] ] で返す。
result = np.sum(arr, axis=1, keepdims=True)
print(result)initialを指定して合計開始値を設定
配列の合計に初期値10を加算 → 10 + 1 + 2 + 3 + 4 = 20
result = np.sum(arr, initial=10)
print(result)whereを使って条件を満たす要素のみ合計
マスクがTrueの要素（1と4）のみを合計 → 1 + 4 = 5
mask = np.array([[True, False], [False, True]])
result = np.sum(arr, where=mask)
print(result)- 任意の軸ごとの合計が可能
- 高速かつベクトル化された演算
- 柔軟な制御が可能（型・初期値・条件付き合計など）
numpy.prod()
np.prod()は、指定された配列内の全要素、または指定軸の要素の積（掛け算）を計算するメソッドです。
多次元配列に対してaxisを指定すれば、その軸に沿った積が求められます。
データ型の指定（dtype）や初期値（initial）を与えることで、数値の桁あふれや精度問題への対応も可能です。
条件付きで積をとる場合はwhere引数でマスクできます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| a | 必須 | 対象となる配列または数値 |
| axis | None | 積を計算する軸。省略時は全体の積 |
| dtype | None | 積の計算に使うデータ型（int64, float64など） |
| out | None | 出力を格納する配列（ブロードキャスト可能） |
| keepdims | False | 積を計算後も元の次元数を保つかどうか |
| initial | 1 | 積の初期値（0だと常に0になる） |
| where | True | 条件を満たす要素のみ積を計算 |
基本的な使い方（全要素の積）
配列 [1, 2, 3, 4] の全要素の積を計算（1×2×3×4 = 24）
import numpy as np
a = np.array([1, 2, 3, 4])
print(np.prod(a)) # 出力: 24axisを使った例（行または列単位）
列方向に積を計算（1×3, 2×4）
b = np.array([[1, 2], [3, 4]])
print(np.prod(b, axis=0)) # 出力: [3 8]dtypeの指定による精度確保
int16だとオーバーフローするが、int64により安全に計算可能。
c = np.array([1000, 1000, 1000], dtype=np.int16)
print(np.prod(c, dtype=np.int64)) # オーバーフロー回避initialによる初期値指定
10を初期値として 10×2×3 = 60
d = np.array([2, 3])
print(np.prod(d, initial=10)) # 出力: 60whereを用いた条件付き積
要素が2より大きいもののみ積に含める
e = np.array([1, 2, 3, 4])
print(np.prod(e, where=e > 2)) # 出力: 12（3×4）- 配列内の要素の積を簡単に計算できる
- 初期値（initial）や条件（where）の指定が可能
- データ型（dtype）を指定できるためオーバーフローを防げる
numpy.mean()
np.mean()は、NumPy配列の要素の算術平均（平均値）を計算するメソッドです。
多次元配列に対してaxis引数を指定することで、特定の軸に沿った平均を取得できます。
dtypeを使って型を制御したり、whereによって条件付き平均を算出可能です。
大量のデータ処理において統計値を求める際に便利な関数です。
| 引数名 | 値の例 | 説明 |
|---|---|---|
| a | array_like（例: np.array([1,2,3])） | 平均を計算する対象の配列 |
| axis | None, 0, 1, tuple | 平均を計算する軸。Noneなら全体。 |
| dtype | np.float64, np.int64など | 計算時のデータ型を指定 |
| out | ndarray（例: np.empty()） | 結果を書き込む出力配列を指定 |
| keepdims | True または False | 結果に元の次元を保持するかどうか |
| where | ブール配列（例: [True, False, True]） | 平均を計算する要素を条件で指定 |
a
配列全体の平均を計算しています。
import numpy as np
arr = np.array([1, 2, 3, 4])
result = np.mean(arr)
print(result) # 出力: 2.5axis
axis=0は列ごと、axis=1は行ごとの平均を計算します。
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
result_axis0 = np.mean(arr2d, axis=0)
result_axis1 = np.mean(arr2d, axis=1)
print(result_axis0) # [2.5 3.5 4.5]
print(result_axis1) # [2. 5.]dtype
計算時に浮動小数点型へ変換して精度を高めています。
arr = np.array([1, 2, 3], dtype=np.int32)
result = np.mean(arr, dtype=np.float64)
print(result) # 出力: 2.0（float64として処理）out
計算結果を既存の配列に書き込んでいます。
arr = np.array([1, 2, 3, 4])
out_arr = np.empty(1)
np.mean(arr, out=out_arr)
print(out_arr) # 出力: [2.5]keepdims
次元を保持して、元の形状と整合性を保つ平均値を出力します。
arr2d = np.array([[1, 2], [3, 4]])
result = np.mean(arr2d, axis=1, keepdims=True)
print(result)
# 出力:
# [[1.5]
# [3.5]]where
Trueに該当する要素だけを対象に平均値を算出します。
arr = np.array([1, 2, 3, 4])
condition = np.array([True, False, True, False])
result = np.mean(arr, where=condition)
print(result) # 出力: 2.0- 多次元配列に対応
- 型や出力の制御が可能
- 条件付き計算に対応
numpy.std()
numpy.std()は、配列内の要素の標準偏差（Standard Deviation）を計算するメソッドです。
標準偏差はデータのばらつきを示す統計指標で、平均からの偏差の平方和の平均の平方根として定義されます。
多次元配列に対してはaxisを指定して特定軸の標準偏差を求めることが可能です。
分散の自由度補正（不偏分散or母分散）もddofパラメータで調整できます。
| 引数名 | 値の例 | 説明 |
|---|---|---|
| a | 配列, リスト | 標準偏差を計算する対象の配列 |
| axis | 0, 1, -1, None | 標準偏差を計算する軸。Noneの場合は全体に対して計算 |
| dtype | np.float64など | 計算時のデータ型。精度制御に利用 |
| out | 既存配列 | 結果を代入するための配列を指定 |
| ddof | 0, 1など | 自由度調整。1の場合は不偏標準偏差（N-1）になる |
| keepdims | True, False | 結果において元の次元を保持するかどうか |
a（基本的な使用）
配列全体の標準偏差（母標準偏差, ddof=0）を計算します。
import numpy as np
data = np.array([1, 2, 3, 4, 5])
result = np.std(data)
print(result)axis（行単位での標準偏差）
各列ごとの標準偏差を計算します。結果は [1.0, 1.0]。
data = np.array([[1, 2], [3, 4]])
result = np.std(data, axis=0)
print(result)dtype（整数を浮動小数で計算）
計算時の精度をfloat64に指定して高精度な標準偏差を算出。
data = np.array([1, 2, 3], dtype=np.int32)
result = np.std(data, dtype=np.float64)
print(result)ddof（不偏標準偏差）
分母をNではなくN-1とすることで「不偏標準偏差」を計算します。
data = np.array([1, 2, 3, 4])
result = np.std(data, ddof=1)
print(result)keepdims（元の次元を保持）
行ごとの標準偏差を計算しつつ、出力形状を(2, 1)に保ちます。
data = np.array([[1, 2], [3, 4]])
result = np.std(data, axis=1, keepdims=True)
print(result)out（既存配列に代入）
出力結果を新しく生成せず、既存配列outputに格納します。
data = np.array([1, 2, 3])
output = np.empty(1)
np.std(data, out=output)
print(output)- 統計的なばらつきを簡単に計算できる
- 軸を指定して多次元配列の標準偏差が求められる
- 自由度補正（不偏・母標準偏差）を選べる
numpy.min()
numpy.min()は、指定された配列内で最小値を返す関数です。
多次元配列においてもaxisを指定することで、行や列ごとの最小値を取得できます。
また、out引数で結果を格納する出力先を指定でき、keepdimsによって元の次元構造を維持可能です。
条件付きで最小値を取得するwhere引数もあり、柔軟なデータ処理が可能です。
| 引数名 | 型 | 説明 |
|---|---|---|
| a | array_like | 最小値を計算する対象の配列。 |
| axis | int, tuple, None | 最小値を計算する軸。Noneの場合は全体から最小値を取得。 |
| out | ndarray or None | 結果を格納する配列（省略可能）。 |
| keepdims | bool | Trueにすると元の配列と同じ次元数の出力になる（次元を保持）。 |
| initial | scalar | 自由度調整。1の場合は不偏標準偏差（N-1）になる |
| where | array_like | 条件を満たす要素だけに対して最小値を計算。 |
基本的な使用（aのみ）
配列全体の最小値1を返します。
import numpy as np
arr = np.array([4, 2, 7, 1])
print(np.min(arr))axisの使用（2次元配列）
各行に対して最小値を計算 → 出力: [2, 1]
arr = np.array([[4, 2, 7], [3, 5, 1]])
print(np.min(arr, axis=1))outの使用
最小値5をresultに格納します。
arr = np.array([10, 20, 5])
result = np.empty(1)
np.min(arr, out=result)
print(result)keepdims=True
次元を保持して各行の最小値を返す → [[1], [5]]
arr = np.array([[3, 1], [7, 5]])
print(np.min(arr, axis=1, keepdims=True))initialを指定
initial=5を指定することで、最小値は5と比較され、結果は5。
arr = np.array([10, 15])
print(np.min(arr, initial=5)) # 通常より小さい初期値を指定whereを使った条件付き計算
arr > 5 に該当する値（10, 8）の中から最小値を取得 → 結果は 8
arr = np.array([10, 3, 8, 1])
cond = arr > 5
print(np.min(arr, where=cond, initial=100))- 配列内の最小値を簡単に取得できる
- 柔軟な条件指定が可能
- 次元保持や出力先指定などの高度な制御が可能
numpy.max()
numpy.max()は、NumPy配列の中から最大値を取得する関数です。
多次元配列の場合はaxisを指定することで、行方向や列方向に沿った最大値を簡単に求められます。
whereを使うことで、特定の条件を満たす要素のみから最大値を抽出可能です。
統計的な分析やデータのスケーリング処理などで広く利用されます。
| 引数名 | 型 | 説明 |
|---|---|---|
| a | np.array([…]) | 最大値を取得したい対象の配列（必須） |
| axis | 0, 1, None | 最大値を取得する軸。Noneの場合は全体から1つの最大値を返す |
| out | np.empty(…) | 結果を格納する配列（ブロードキャスト可能な形状である必要あり） |
| keepdims | True, False | Trueにすると、出力の次元数を入力と同じに保持 |
| initial | float(‘-inf’)など | 最初の比較値。これ以下の要素がなければこの値が返される |
| where | condition array | 条件を満たす要素のみを対象として最大値を求める |
axisの使用例
列方向（axis=0）に沿って最大値を取得 → [4, 5, 6] が出力されます。
import numpy as np
a = np.array([[1, 5, 3], [4, 2, 6]])
result = np.max(a, axis=0)
print(result)outの使用例
最大値3をout_arrayに格納して再利用可能にします。
a = np.array([1, 3, 2])
out_array = np.empty(1)
np.max(a, out=out_array)
print(out_array)keepdimsの使用例
行ごとの最大値を求めつつ、元の2次元構造 [ [5], [3] ] を保持します。
a = np.array([[1, 5], [2, 3]])
result = np.max(a, axis=1, keepdims=True)
print(result)initialの使用例
最大値比較の初期値を-1に設定。配列のすべての値より小さいため、-1が結果に。
a = np.array([-5, -10, -15])
result = np.max(a, initial=-1)
print(result)whereの使用例
条件 a > 3 に合致する [5, 9] の中で最大値9を返します。
a = np.array([1, 5, 2, 9])
condition = a > 3
result = np.max(a, where=condition, initial=-1)
print(result)- 多次元配列に対して軸を指定し、特定の行や列ごとの最大値を取得
- 条件指定により、特定の条件を満たす要素のみから最大値を抽出可能
- 結果の次元を保持するオプションがあり、配列の形状を保ち集約結果を得る
numpy.save()
numpy.save()は、NumPy配列をバイナリ形式（.npyファイル）で保存する関数です。
効率的に配列のデータとメタ情報（形状やデータ型など）を保存し、後で高速に読み込みが可能です。
ファイル名と保存する配列を指定するだけで使えてデータの永続化ができます。
複数の配列をまとめて保存したい場合は、numpy.savez()を利用します。
| 引数名 | 型 | 説明 |
|---|---|---|
| file | str or file-like | 保存先のファイル名（拡張子は.npyを自動的に追加）またはファイルオブジェクト |
| arr | ndarray | 保存対象のNumPy配列 |
| allow_pickle | bool | Pythonオブジェクトのピクル化を許可するか（デフォルトはTrue） |
| fix_imports | bool | Python2からの互換性のためのインポート修正を行うか（デフォルトTrue） |
| protocol | int or None | ピクル化のプロトコルバージョン（Noneはデフォルトのプロトコル） |
file（必須）
配列をarray_data.npyというファイル名で保存します。
拡張子は.npyを自動的に追加します。
import numpy as np
arr = np.array([1, 2, 3])
np.save('array_data.npy', arr)allow_pickle
Pythonオブジェクト（辞書など）を含む配列を保存する際に、allow_pickle=Trueにしてピクル化を許可します。
安全性の理由でFalseにすると例外が発生します。
import numpy as np
arr = np.array([{'a': 1}, {'b': 2}])
np.save('pickle_array.npy', arr, allow_pickle=True)fix_imports
Python2と3間の互換性を保つためにインポートの修正を行います。
通常はデフォルトのTrueで問題ありません。
import numpy as np
arr = np.array([1, 2, 3])
np.save('fixed_array.npy', arr, fix_imports=True)protocol
ピクル化で使うプロトコルのバージョンを指定します。
バージョンによってファイルサイズや互換性が異なります。
Noneでデフォルトです。
import numpy as np
arr = np.array([1, 2, 3])
np.save('protocol_array.npy', arr, protocol=4)- NumPy配列をバイナリ形式（.npyファイル）で高速かつ効率的に保存
- Pythonオブジェクトのピクル化を許可するオプションがあり、複雑なデータ構造も保存可能
- ファイル名に自動で拡張子「.npy」を追加し、ファイルの読み書き可能
numpy.load()
numpy.load()は、NumPyのバイナリ形式（.npyまたは.npz）で保存された配列データを読み込む関数です。
高速に配列を復元でき、保存時のデータ型や形状も保持されます。
圧縮されたアーカイブ（.npz）もサポートし、複数配列の同時読み込みが可能です。
また、allow_pickleオプションでPythonオブジェクトの読み込みも制御できます。
| 引数名 | デフォルト値 | 説明 |
|---|---|---|
| file | なし | 読み込むファイル名（文字列）またはファイルオブジェクト。 .npyまたは.npzファイルを指定。 |
| mmap_mode | None | メモリマップモード。’r’, ‘r+’, ‘w+’, ‘c’のいずれか。 指定するとファイルをメモリマップで開く。 |
| allow_pickle | False | ピクル化されたオブジェクトの読み込みを許可するかどうか。 セキュリティ上の理由でデフォルトはFalse。 |
| fix_imports | True | Python2のpickleとの互換性を保つかどうか。 Python3でのみ有効。 |
| encoding | ‘ASCII’ | ピクル読み込み時のエンコーディング。 デフォルトはASCII。 |
import numpy as np
# 配列を保存
arr = np.array([1, 2, 3, 4])
np.save('sample.npy', arr)| 引数名 | サンプルコード | 説明 |
|---|---|---|
| file | data = np.load(‘sample.npy’) | ファイル名を指定して、保存済みのNumPy配列を読み込む。 |
| mmap_mode | data = np.load(‘sample.npy’, mmap_mode=’r’) | ファイルを読み取り専用でメモリマップし、大きなファイルを効率的に扱う。 |
| allow_pickle | — | ピクル化されたPythonオブジェクトを含む配列を保存し、許可して読み込む。 |
| fix_imports | data = np.load(‘sample.npy’, fix_imports=True) | Python2で保存されたpickleデータとの互換性を保持しつつ読み込む。 |
| encoding | data = np.load(‘sample.npy’, encoding=’latin1′) | ピクル読み込み時のエンコーディングをASCII以外（例：latin1）に指定する。 |
- NumPyのバイナリファイル（.npyや.npz）から高速に配列データを読み込み可能
- mmap_mode引数でメモリマップを利用し、大きなファイルでも効率的に部分的に読み込める
- allow_pickleオプションを使うことで、Pythonオブジェクトを含む配列の読み込みを制御
numpy.savetxt()
numpy.savetxt()は、NumPy配列のデータをテキストファイルに保存する関数です。
データをCSVやスペース区切りなどのテキスト形式で書き出すことができ、フォーマット指定や区切り文字の設定が可能です。
主に数値データの保存に使われ、ファイルの読み込みや他プログラムとのデータ連携に便利です。
| 引数名 | 値の例 | 説明 |
|---|---|---|
| fname | ‘data.txt’ | 保存するファイル名（文字列）またはファイルオブジェクト |
| X | numpy配列 | 保存するNumPy配列 |
| fmt | ‘%0.18e’, ‘%d’, ‘%.2f’ | ファイルに保存する際のフォーマット指定（デフォルトは科学的記数法の文字列） |
| delimiter | ‘ ‘, ‘,’, ‘\t’ | 区切り文字。デフォルトはスペース |
| newline | ‘\n’ | 行の区切り文字。デフォルトは改行 |
| header | ” | ファイルの先頭に追加する文字列 |
| footer | ” | ファイルの末尾に追加する文字列 |
| comments | ‘#’ | ヘッダーやフッターの前に付けるコメント文字列（デフォルトは’#’） |
| encoding | None, ‘utf-8’など | ファイルのエンコーディング。デフォルトは環境依存 |
fname（ファイル名指定）
配列arrをテキストファイルoutput.txtに保存する。
import numpy as np
arr = np.array([1, 2, 3, 4])
np.savetxt('output.txt', arr)fmt（フォーマット指定）
小数点以下2桁の浮動小数点形式で保存する。
arr = np.array([1.23456, 2.34567, 3.45678])
np.savetxt('output_fmt.txt', arr, fmt='%.2f')delimiter（区切り文字指定）
配列をカンマ区切りのCSV形式で保存する。
arr = np.array([[1, 2], [3, 4]])
np.savetxt('output_csv.txt', arr, delimiter=',')headerとfooter（ヘッダーとフッターの追加）
ファイルの先頭と末尾に指定文字列を追加する。
arr = np.array([10, 20, 30])
np.savetxt('output_header.txt', arr, header='# This is header', footer='# This is footer')comments（コメント文字の変更）
ヘッダーの前に//を付けてコメントにする。
arr = np.array([10, 20, 30])
np.savetxt('output_comments.txt', arr, header='Header', comments='// ')encoding（エンコーディング指定）
UTF-8エンコードでファイルを保存する（日本語などを含む場合に有効）。
arr = np.array([100, 200, 300])
np.savetxt('output_utf8.txt', arr, encoding='utf-8')- テキストファイル形式で保存
- 柔軟なフォーマット指定
- 高速かつシンプル
numpy.loadtxt()
numpy.loadtxt()は、テキストファイルやファイルのようなオブジェクトからデータを読み込み、NumPy配列として返します。
主に数値データを含むCSVやスペース区切りのファイルから効率的に読み込む際に使われます。
区切り文字やスキップ行数などを指定でき、柔軟にデータのフォーマットに対応可能です。
| 引数名 | 型・値の例 | 説明 |
|---|---|---|
| fname | str, file-like object | 読み込むファイルのパスやファイルオブジェクト |
| dtype | data-type | 読み込むデータの型（例: float, int） |
| comments | str | コメント行の先頭文字（デフォルトは#） |
| delimiter | str | 区切り文字（例: ‘,’, ‘ ‘など。デフォルトは任意の空白） |
| converters | dict | 列ごとに適用する変換関数の辞書（例: {0: func}） |
| skiprows | int | スキップする行数（ファイルの先頭から） |
| usecols | intまたはリスト | 読み込む列のインデックス（例: 0、[0,2]） |
| unpack | bool | 真の場合、列ごとに分解して返す（Trueは複数変数へのアンパック） |
| ndmin | int | 最低次元数（戻り値の配列の次元数を指定） |
| encoding | str | ファイルの文字コード（例: ‘utf-8’） |
| max_rows | int | 読み込む最大行数 |
fname
ファイル名を指定してファイルを読み込みます。
import numpy as np
data = np.loadtxt('data.txt')
print(data)dtype
読み込んだデータの型を整数型に指定します。
data = np.loadtxt('data.txt', dtype=int)
print(data)comments
;で始まる行をコメントとして無視します。
data = np.loadtxt('data_with_comments.txt', comments=';')
print(data)delimiter
カンマ区切りのCSVファイルを読み込みます。
data = np.loadtxt('data.csv', delimiter=',')
print(data)converters
1列目の値を読み込む際に10倍する変換をかけています。
def convert_func(s):
return float(s.decode('utf-8')) * 10
data = np.loadtxt('data.txt', converters={0: convert_func})
print(data)skiprows
先頭2行をスキップしてデータを読み込みます。
data = np.loadtxt('data.txt', skiprows=2)
print(data)usecols
0列目と2列目のみ読み込みます。
data = np.loadtxt('data.txt', usecols=[0, 2])
print(data)unpack
複数列をそれぞれ別の変数として受け取ります。
x, y = np.loadtxt('data.txt', unpack=True)
print(x)
print(y)ndmin
読み込み結果を最低2次元の配列にします。
data = np.loadtxt('data.txt', ndmin=2)
print(data.shape)encoding
UTF-16エンコードのファイルを読み込みます。
data = np.loadtxt('data_utf16.txt', encoding='utf-16')
print(data)max_rows
先頭3行のみ読み込みます。
data = np.loadtxt('data.txt', max_rows=3)
print(data)- 数値データを含むテキストファイルからNumPy配列として返す
- 細かい読み込み設定が可能
- 様々な形式のファイル読み込みに利用
numpy.all()
numpy.all()は、配列内の全ての要素が条件を満たすかどうかを判定します。
配列の各要素が真（True）であればTrueを返し、一つでも偽（False）があればFalseを返します。
軸（axis）を指定することで、特定の次元ごとに判定可能です。
論理演算や条件判定の際に便利なメソッドです。
| 引数名 | 値の例 | 説明 |
|---|---|---|
| a | ndarray | 真偽判定する対象の配列。 |
| axis | 0, 1, None | 判定を行う軸。指定なし（None）は全要素を対象。 |
| out | ndarray（省略可） | 結果を書き込む配列。省略時は新しい配列が返される。 |
| keepdims | True or False | 結果の次元を保つかどうか。Trueなら元の次元数を維持。 |
| where | array_like | 真偽判定を行う位置を指定するブール配列。 |
axis
全体としては偽（False）だが、軸を指定すると列や行ごとに判定できる。
import numpy as np
arr = np.array([[True, True], [True, False]])
# axis=None (デフォルト): 全要素がTrueか判定
print(np.all(arr)) # False
# axis=0: 各列ごとに判定
print(np.all(arr, axis=0)) # [True, False]
# axis=1: 各行ごとに判定
print(np.all(arr, axis=1)) # [True, False]out
結果をout配列に格納。新しい配列を生成せずに結果を得られる。
import numpy as np
arr = np.array([True, True, False])
out_arr = np.empty((), dtype=bool)
np.all(arr, out=out_arr)
print(out_arr) # Falsekeepdims
結果の次元数を元の配列の次元数と同じに保持して返す。
import numpy as np
arr = np.array([[True, True], [True, False]])
result = np.all(arr, axis=1, keepdims=True)
print(result) # [[ True]
# [False]]
print(result.shape) # (2, 1)where
whereで指定した位置だけを判定対象にする。Falseの要素は無視される。
import numpy as np
arr = np.array([True, False, True, False])
mask = np.array([True, False, True, False]) # 判定対象の位置指定
result = np.all(arr, where=mask)
print(result) # True- 全要素の論理積を判定
- 軸（axis）指定で部分判定が可能
- keepdimsやwhere引数で柔軟な判定が可能
numpy.any()
numpy.any()は、配列内の要素のうち少なくとも1つがTrueであればTrueを返します。
全ての要素がFalseの場合のみFalseを返します。
軸（axis）を指定すると、その軸ごとに判定が可能で部分的な真偽値を取得できます。
条件の存在チェックやフィルタリング処理に使われます。
| 引数名 | 値の例 | 説明 |
|---|---|---|
| axis | 0, 1, None | 真偽判定を行う軸を指定。Noneは全体を対象。 |
| out | 配列 | 出力配列。結果を格納する配列を指定可能（省略可）。 |
| keepdims | True or False | 結果の次元を元の配列に合わせて維持するかどうか。 |
| where | ブール配列 | Trueの位置だけを判定対象にするマスク。 |
import numpy as np
arr = np.array([[0, 1, 0],
[0, 0, 0]])
# 1. 全体でTrueがあるか判定
result1 = np.any(arr)
print(result1)
# → True（0以外の要素が1つあるため）
# 2. 行ごとにTrueがあるか判定
result2 = np.any(arr, axis=1)
print(result2)
# → [True, False]（1行目はTrue、2行目はFalse）
# 3. 出力配列を指定
out_arr = np.empty(2, dtype=bool)
np.any(arr, axis=1, out=out_arr)
print(out_arr)
# → [ True False]
# 4. 次元を保持
result4 = np.any(arr, axis=1, keepdims=True)
print(result4)
# → [[ True]
# [False]]
# 5. where引数を使い、一部の要素だけ判定
mask = np.array([[True, False, True],
[False, True, False]])
result5 = np.any(arr, where=mask)
print(result5)
# → True（マスクTrueの位置で1があるため）- 配列内に少なくとも1つでもTrueがあればTrueを返し、全てFalseの場合のみFalseを返す
- axis引数を指定することで、部分的な判定結果を得られる
- 出力の形状調整や判定対象の部分指定など操作可能
