numpy.reciprocal()

2025-06-06

逆数とは？

ある数 x の逆数とは、x にかけると積が 1 になる数のことです。つまり、1/x と表されます。

`numpy.reciprocal()` の基本的な使い方

numpy.reciprocal(x, /, out=None, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

out, where などの引数は、計算結果の格納先や条件指定など、NumPyの一般的なユニバーサル関数（ufunc）に共通するオプションです。
x: 入力となる配列（array_like）。スカラー値でも配列でも指定できます。

動作の例

簡単な例で動作を見てみましょう。

import numpy as np

# スカラー値の場合
a = 2
reciprocal_a = np.reciprocal(a)
print(f"2の逆数: {reciprocal_a}") # 出力: 2の逆数: 0.5

# 配列の場合
arr = np.array([1, 2, 0.5, 4])
reciprocal_arr = np.reciprocal(arr)
print(f"配列の逆数: {reciprocal_arr}") # 出力: 配列の逆数: [1.   0.5  2.   0.25]

# 整数型の配列の場合の注意
# 整数型で計算すると、逆数が浮動小数点数になるため、
# 結果も浮動小数点数型になります。
# 割り切れない場合は、結果は0になることがあります（NumPyのバージョンや環境による）。
# 一般的には浮動小数点数型への変換が行われます。
int_arr = np.array([1, 2, 3, 4])
reciprocal_int_arr = np.reciprocal(int_arr)
print(f"整数配列の逆数: {reciprocal_int_arr}") # 出力例: 整数配列の逆数: [1 0 0 0] (これはNumPyのバージョンやdtypeによって変わる可能性があります)
                                             # 通常は [1.         0.5        0.33333333 0.25      ] のような浮動小数点数になります
                                             # 正確な結果を得るためには、入力が浮動小数点数型であることを推奨します。
                                             # 例：
float_int_arr = np.array([1, 2, 3, 4], dtype=float)
reciprocal_float_int_arr = np.reciprocal(float_int_arr)
print(f"浮動小数点数型としての整数配列の逆数: {reciprocal_float_int_arr}")
# 出力: 浮動小数点数型としての整数配列の逆数: [1.         0.5        0.33333333 0.25      ]

# 0の逆数について
# 0の逆数は数学的に定義されていません（無限大になります）。
# NumPyでは、0をnp.inf（無限大）として扱います。
zero_val = np.array([0])
reciprocal_zero = np.reciprocal(zero_val)
print(f"0の逆数: {reciprocal_zero}") # 出力: 0の逆数: [inf]

# 警告: 0がある場合はRuntimeWarningが発生することがあります
# np.seterr(divide='ignore') などで警告を抑制することも可能ですが、
# 通常は警告を受け入れるか、事前に0の要素がないか確認する方が良いでしょう。

数理計算: 数式の中で逆数が必要な場面で利用されます。
データ変換: データのスケールを変更したり、特定の統計計算で逆数が必要な場合に使用されます。

ゼロ除算 (Division by Zero)

これは最も一般的で重要な問題です。数学的に 0 の逆数は定義されていません（無限大になります）。

エラー/警告の発生パターン

import numpy as np

arr = np.array([1, 2, 0, 4])
# 実行すると RuntimeWarning: divide by zero encountered in reciprocal が発生する
result = np.reciprocal(arr)
print(result)
# 出力例: [ 1.   0.5  inf  0.25]

結果: 警告は出ますが、計算自体は実行され、該当する要素は np.inf (無限大) となります。
RuntimeWarning: divide by zero encountered in reciprocal: この警告は、入力配列に 0 が含まれており、0 の逆数を計算しようとした場合に発生します。

トラブルシューティング

入力データに 0 が含まれていないか確認する: 最も基本的な対策です。もし 0 が含まれる可能性がある場合は、事前に処理を検討する必要があります。
```
if 0 in arr:
    print("警告: 配列に0が含まれています。逆数はinfになります。")
```
0 の要素を事前に置き換える: 例えば、0 を非常に小さな数（np.finfo(arr.dtype).eps など）に置き換えることで、無限大になるのを避けることができます。ただし、これは厳密な逆数ではなく、近似値になります。
```
arr_no_zero = np.where(arr == 0, np.finfo(arr.dtype).eps, arr)
result = np.reciprocal(arr_no_zero)
print(result)
```
警告を無視する（非推奨）: 警告がアプリケーションの動作を妨げる場合に、一時的に警告を抑制する方法もあります。しかし、これは問題の本質を解決するものではないため、慎重に適用すべきです。
```
# 警告を一時的に無視する
old_settings = np.seterr(divide='ignore')
result = np.reciprocal(arr)
np.seterr(**old_settings) # 設定を元に戻す
print(result)
```
0 の要素に対応する結果をNaNなどに変更する: 無限大ではなく、np.nan (Not a Number) を入れたい場合は、計算後に置き換えることもできます。
```
result = np.reciprocal(arr)
result[np.isinf(result)] = np.nan # 無限大になった要素をNaNに
print(result)
```

整数型の入力と結果の型

numpy.reciprocal() は、入力が整数型であっても、結果は浮動小数点数型になるのが一般的です。しかし、古いNumPyのバージョンや特定の環境では、整数型として逆数を計算しようとし、結果が切り捨てられてしまうことがあります。

エラー/予期せぬ挙動のパターン

import numpy as np

int_arr = np.array([1, 2, 3, 4])
result_int = np.reciprocal(int_arr)
print(result_int)
print(result_int.dtype)
# 出力例1 (期待される挙動 - float型になる):
# [1.         0.5        0.33333333 0.25      ]
# float64

# 出力例2 (予期せぬ挙動 - 整数型で切り捨てられる):
# [1 0 0 0]
# int64

上記「出力例2」のような挙動は、特に古いNumPyのバージョンで発生したり、あるいはdtypeが明示的に指定された場合などに起こりえます。新しいNumPyのバージョンでは、通常は入力が整数型でも結果は自動的に浮動小数点数型にプロモートされます。

入力配列を浮動小数点数型にする: 最も確実な方法は、numpy.reciprocal() に渡す前に、入力配列のデータ型を浮動小数点数型にすることです。

float_arr = np.array([1, 2, 3, 4], dtype=float) # または dtype=np.float64
result_float = np.reciprocal(float_arr)
print(result_float)
print(result_float.dtype)
# 出力: [1.         0.5        0.33333333 0.25      ]
#       float64

結果の型を明示的に指定する（out引数やdtype引数）: out引数で、結果を格納する配列の型を事前に浮動小数点数型として作成しておくか、dtype引数で明示的に指定します。

# out 引数を使用
output_array = np.empty_like(int_arr, dtype=float)
np.reciprocal(int_arr, out=output_array)
print(output_array)
print(output_array.dtype)

# dtype 引数を使用 (一部のufuncでサポートされていますが、reciprocalでは直接dtypeを指定するよりも
# 入力側のdtypeを制御する方が一般的です)
# np.reciprocal(int_arr, dtype=float) # この方法はreciprocalでは直接動作しない場合があります

非常に大きな数や非常に小さな数の逆数を計算しようとすると、浮動小数点数の表現範囲を超えてオーバーフローやアンダーフローが発生し、np.inf や 0 になることがあります。

import numpy as np

# 非常に大きな数
large_num = np.array([1e300]) # float64の最大値に近い
reciprocal_large = np.reciprocal(large_num)
print(f"非常に大きな数の逆数: {reciprocal_large}") # 出力例: [0.] (アンダーフローにより0になる)

# 非常に小さな数 (0に近い正の数)
small_num = np.array([1e-320]) # float64の最小値に近い
reciprocal_small = np.reciprocal(small_num)
print(f"非常に小さな数の逆数: {reciprocal_small}") # 出力例: [inf] (オーバーフローによりinfになる)

これらの場合、通常は警告は発生しませんが、結果が 0 や np.inf になることで、計算の精度が失われます。

データのスケールを調整する: 計算前にデータのスケールを調整し、オーバーフローやアンダーフローが発生しない範囲に収めることを検討します。
より高い精度を持つデータ型を使用する: np.float128 のような、より広い範囲を表現できるデータ型を使用することで、この問題を緩和できる場合があります。ただし、float128 はすべてのシステムでサポートされているわけではなく、計算速度も低下する可能性があります。
```
large_num_high_prec = np.array([1e300], dtype=np.float128)
reciprocal_high_prec = np.reciprocal(large_num_high_prec)
print(f"高精度での逆数: {reciprocal_high_prec}")
```

numpy.reciprocal() を使用する際の主な注意点は、以下の3点です。

ゼロ除算: 入力に 0 が含まれると np.inf となり、警告が発生します。事前に 0 の有無を確認し、必要に応じて処理を検討してください。
整数型入力: 予期せぬ切り捨てを避けるため、入力配列は浮動小数点数型にすることをお勧めします。
オーバーフロー/アンダーフロー: 非常に大きな数や小さな数を扱う場合は、結果が 0 や np.inf になる可能性があるため、データのスケールやデータ型に注意が必要です。

基本的な使用法：スカラーと配列

最も基本的な使い方です。単一の数値（スカラー）やNumPy配列の各要素に対して逆数を計算します。

import numpy as np

print("--- 基本的な使用法 ---")

# スカラー値の逆数
scalar_val = 5
reciprocal_scalar = np.reciprocal(scalar_val)
print(f"スカラー値 {scalar_val} の逆数: {reciprocal_scalar}")
# 出力: スカラー値 5 の逆数: 0.2

# 1次元配列の逆数
arr_1d = np.array([1, 2, 4, 10])
reciprocal_arr_1d = np.reciprocal(arr_1d)
print(f"1次元配列 {arr_1d} の逆数: {reciprocal_arr_1d}")
# 出力: 1次元配列 [ 1  2  4 10] の逆数: [1.   0.5  0.25 0.1 ]

# 2次元配列の逆数
arr_2d = np.array([[1, 0.5], [0.25, 5]])
reciprocal_arr_2d = np.reciprocal(arr_2d)
print(f"2次元配列\n{arr_2d}\nの逆数:\n{reciprocal_arr_2d}")
# 出力:
# 2次元配列
# [[1.   0.5 ]
#  [0.25 5.  ]]
# の逆数:
# [[1.  2. ]
#  [4.  0.2]]

整数型配列の扱いと型変換

前述の通り、整数型の配列を入力した場合、NumPyは自動的に結果を浮動小数点数型に変換します。これにより、正確な逆数（0.5,0.333... など）が得られます。

import numpy as np

print("\n--- 整数型配列の扱いと型変換 ---")

int_array = np.array([1, 2, 3, 4, 5])
reciprocal_int_array = np.reciprocal(int_array)

print(f"元の整数配列: {int_array}")
print(f"逆数計算結果: {reciprocal_int_array}")
print(f"結果のデータ型: {reciprocal_int_array.dtype}")
# 出力:
# 元の整数配列: [1 2 3 4 5]
# 逆数計算結果: [1.         0.5        0.33333333 0.25       0.2       ]
# 結果のデータ型: float64

# 入力時に明示的にfloat型にする場合
int_to_float_array = np.array([1, 2, 3, 4, 5], dtype=float)
reciprocal_float_input = np.reciprocal(int_to_float_array)
print(f"\nfloat型で入力した場合:\n{reciprocal_float_input}")
print(f"結果のデータ型: {reciprocal_float_input.dtype}")
# 出力:
# float型で入力した場合:
# [1.         0.5        0.33333333 0.25       0.2       ]
# 結果のデータ型: float64

ゼロ除算のハンドリング

入力配列に 0 が含まれる場合、np.reciprocal() は警告 (RuntimeWarning) を出力し、該当する要素を np.inf (無限大) とします。これをどのように扱うか、いくつかの方法を見てみましょう。

import numpy as np

print("\n--- ゼロ除算のハンドリング ---")

arr_with_zero = np.array([1.0, 2.0, 0.0, 4.0])

# そのまま計算すると警告が出る
print("--- 警告が出る例 ---")
# RuntimeWarning: divide by zero encountered in reciprocal
result_with_zero = np.reciprocal(arr_with_zero)
print(f"0を含む配列 {arr_with_zero} の逆数: {result_with_zero}")
# 出力: 0を含む配列 [1. 2. 0. 4.] の逆数: [ 1.   0.5  inf  0.25]

print("\n--- 0をNaNに置き換える例 ---")
# 警告を無視して計算し、infになった部分をNaNに変換する
# np.seterr で警告を一時的に抑制することも可能
old_settings = np.seterr(divide='ignore')
result_nan = np.reciprocal(arr_with_zero)
np.seterr(**old_settings) # 設定を元に戻す

result_nan[np.isinf(result_nan)] = np.nan # infをNaNに置き換える
print(f"0がNaNに変換された配列: {result_nan}")
# 出力: 0がNaNに変換された配列: [ 1.   0.5  nan  0.25]

print("\n--- 0を別の小さな値に置き換える例 (近似) ---")
# 0の要素を、非常に小さな正の数に置き換えてから逆数を取る
# np.finfo().eps は浮動小数点数の最小の差
arr_replaced_zero = np.where(arr_with_zero == 0, np.finfo(float).eps, arr_with_zero)
result_replaced_zero = np.reciprocal(arr_replaced_zero)
print(f"0が小さな値に置き換えられた配列: {result_replaced_zero}")
# 出力例: 0が小さな値に置き換えられた配列: [1.00000000e+00 5.00000000e-01 1.00000000e+16 2.50000000e-01]
# (1.0e+16 は 1/np.finfo(float).eps の概算値)

out 引数を使った結果の格納

out 引数を使用すると、計算結果を既存の配列に直接書き込むことができます。これは、メモリの割り当てを節約したい場合や、ループ内で繰り返し計算を行う場合に便利です。

import numpy as np

print("\n--- 'out' 引数の使用 ---")

input_arr = np.array([1.0, 2.0, 5.0])
output_arr = np.empty_like(input_arr) # 入力配列と同じ形状・型の空の配列を作成

np.reciprocal(input_arr, out=output_arr)

print(f"入力配列: {input_arr}")
print(f"出力配列 (out引数使用): {output_arr}")
# 出力:
# 入力配列: [1. 2. 5.]
# 出力配列 (out引数使用): [1.  0.5 0.2]

# 別の型に出力する場合
input_arr_int = np.array([1, 2, 4])
output_arr_float = np.zeros(3, dtype=float) # float型の配列を作成

np.reciprocal(input_arr_int, out=output_arr_float)
print(f"\n整数入力からfloat出力への例:")
print(f"入力配列: {input_arr_int}")
print(f"出力配列 (float型): {output_arr_float}")
# 出力:
# 整数入力からfloat出力への例:
# 入力配列: [1 2 4]
# 出力配列 (float型): [1.   0.5  0.25]

where 引数を使用すると、特定の条件を満たす要素のみに対して逆数計算を行い、それ以外の要素は元の値を保持したり、別の値にしたりできます。これは、特に 0 除算を避けたい場合に有効です。

import numpy as np

print("\n--- 'where' 引数の使用 ---")

data = np.array([1.0, 2.0, 0.0, 4.0, 0.5])

# 0以外の要素の逆数を計算し、0の要素は元の0のままにする
# where= (data != 0) は、dataが0ではない要素に対してTrueとなるブール配列
result_where = np.reciprocal(data, where=(data != 0), out=np.zeros_like(data))
# out=np.zeros_like(data) は、where条件がFalseの要素に0を格納する初期値を提供
# この場合、元の値 (0) を保持したいので、dataを直接使う方が適切

# 正しい使い方: 元の値を保持しつつ、条件を満たす要素のみ計算
# out には元の data を指定し、where が False の場合は out の元の値が保持される
result_conditional = data.copy() # 結果を格納する配列をコピーしておく
np.reciprocal(data, out=result_conditional, where=(data != 0))

print(f"元の配列: {data}")
print(f"0以外の要素のみ逆数を計算し、0はそのままにした結果: {result_conditional}")
# 出力: 元の配列: [1.  2.  0.  4.  0.5]
#       0以外の要素のみ逆数を計算し、0はそのままにした結果: [1.  0.5 0.  0.25 2. ]

# 別の例: 特定の範囲の要素だけ逆数を計算
data_range = np.array([0.1, 1.0, 5.0, 0.0, 10.0])
# 1より大きい要素のみ逆数を計算
result_large_only = data_range.copy()
np.reciprocal(data_range, out=result_large_only, where=(data_range > 1))

print(f"\n元の配列: {data_range}")
print(f"1より大きい要素のみ逆数を計算した結果: {result_large_only}")
# 出力: 元の配列: [ 0.1  1.   5.   0.  10. ]
#       1より大きい要素のみ逆数を計算した結果: [0.1  1.   0.2  0.   0.1]

単純な割り算 (Division) を使う

最も直接的な代替方法は、1 を各要素で割るという、通常の割り算演算子 / を使用することです。NumPy配列に対するこの操作は、要素ごと（element-wise）に実行されます。

例:

import numpy as np

print("--- 1. 単純な割り算を使用 ---")

arr = np.array([1, 2, 0.5, 4])

# np.reciprocal() と同じ結果が得られます
result_reciprocal = np.reciprocal(arr)
print(f"np.reciprocal() の結果: {result_reciprocal}")
# 出力: [1.   0.5  2.   0.25]

# 1 / arr の形式
result_division = 1 / arr
print(f"1 / arr の結果: {result_division}")
# 出力: [1.   0.5  2.   0.25]

# 0を含む場合も同様に RuntimeWarning が発生し、inf となる
arr_with_zero = np.array([1, 0, 4])
result_division_zero = 1 / arr_with_zero
print(f"0を含む配列に対する 1 / arr の結果: {result_division_zero}")
# 出力: [ 1.  inf  0.25]
# (RuntimeWarning: divide by zero encountered in true_divide が発生)

利点

NumPyのユニバーサル関数（ufunc）としての性質を共有しており、ブロードキャストなどの機能も利用できます。
numpy.reciprocal() と同様に、NumPyの内部で最適化されており、高速です。
直感的で読みやすい: 1 / array という表現は、逆数計算であることが一目瞭然です。

欠点

numpy.reciprocal() と同様に、0 で割ろうとすると RuntimeWarning が発生し、np.inf が結果となります。

numpy.power() を使う（指数として -1 を指定）

逆数は、x−1 とも表現できます。NumPyの numpy.power() 関数は、配列の各要素を指定された指数でべき乗するため、指数に -1 を指定することで逆数を計算できます。

import numpy as np

print("\n--- 2. numpy.power() を使用 ---")

arr = np.array([1, 2, 0.5, 4])

# arr の各要素を -1 乗する
result_power = np.power(arr, -1)
print(f"np.power(arr, -1) の結果: {result_power}")
# 出力: [1.   0.5  2.   0.25]

# 0を含む場合
arr_with_zero = np.array([1, 0, 4])
result_power_zero = np.power(arr_with_zero, -1)
print(f"0を含む配列に対する np.power() の結果: {result_power_zero}")
# 出力: [ 1.  inf  0.25]
# (RuntimeWarning: divide by zero encountered in power が発生)

利点

numpy.reciprocal() や / 演算子と同様に高速です。
数学的な定義 x−1 と一致するため、概念的に分かりやすい場合があります。

欠点

やはり 0 で割ろうとすると RuntimeWarning が発生し、np.inf が結果となります。
numpy.reciprocal() や / 演算子と比べて、少し冗長に感じられるかもしれません。

条件付き処理と組み合わせる

特定の条件（例えば、0 を含む場合など）に基づいて、逆数計算の動作を変えたい場合、np.where() などの条件付き関数と組み合わせることで、より柔軟な制御が可能です。これは、numpy.reciprocal() の where 引数と同等の機能を提供しますが、より複雑なロジックを実装できる場合があります。

例: 0をNaNに置き換える

import numpy as np

print("\n--- 3. 条件付き処理 (np.where) を使用 ---")

arr_data = np.array([1, 2, 0, 4, 0.5])

# 0でない場合は逆数を計算、0の場合は NaN を設定
# RuntimeWarning は発生しません
result_conditional = np.where(arr_data != 0, 1 / arr_data, np.nan)
print(f"np.where を使った結果 (0はNaN): {result_conditional}")
# 出力: [ 1.   0.5  nan  0.25  2. ]

# 0でない場合は逆数を計算、0の場合は元の値を保持
result_keep_zero = np.where(arr_data != 0, 1 / arr_data, arr_data)
print(f"np.where を使った結果 (0はそのまま): {result_keep_zero}")
# 出力: [1.   0.5  0.   0.25  2. ]

利点

RuntimeWarning の発生を抑制できます（0 で除算される場所を事前に定義しているため）。

欠点

コードが少し複雑になります。

NumPyを使用する主な利点は、C言語などの最適化された内部実装による高速な配列操作ですが、概念的な理解のために、Pythonの標準的なループを使って各要素の逆数を計算することも可能です。ただし、これは非常に大きな配列に対しては非推奨であり、パフォーマンスが著しく低下します。

import numpy as np

print("\n--- 4. 手動ループ (非推奨) ---")

arr_small = np.array([1, 2, 4])
result_manual = []

for x in arr_small:
    if x != 0:
        result_manual.append(1 / x)
    else:
        result_manual.append(np.inf) # または np.nan, 0 など
print(f"手動ループの結果: {np.array(result_manual)}")
# 出力: 手動ループの結果: [1.   0.5  0.25]

利点

NumPyに慣れていない場合でも、Pythonの基本知識で実装できます。

欠点

コードがNumPyの「ベクトル化」の恩恵を受けません。
パフォーマンスが非常に悪い: 大規模な配列では実用的ではありません。

numpy.reciprocal() の代替方法としては、ほとんどのケースで単純な割り算 (1 / array) が最も推奨されます。これは、直感的で、高速であり、numpy.reciprocal() と同等の機能を提供します。

numpy.power(arr, -1) も有効な代替手段ですが、記述がわずかに長くなります。

record.dumps()を超えた！NumPyのrecord arrayをシリアル化する方法5選

NumPyは、科学計算やデータ分析において広く使用されるPythonライブラリです。NumPyには、様々な種類のデータ構造を扱うことができるサブクラスが用意されており、その中でも"record array"は、構造化されたデータを効率的に扱うために役立ちます。

NumPy record.flat属性: 構造化配列を効率的に処理するための秘訣

構造化配列は、複数のデータ型を列として持つことができる特殊な配列です。各列は "フィールド" と呼ばれ、異なるデータ型を持ちます。構造化配列は、従来の多次元配列よりも柔軟で、データをより効率的に格納することができます。record. flat 属性は、構造化配列の各フィールドを 1 次元ビューとして表現します。これは、構造化配列の要素を個別にアクセスしたり、操作したりする際に役立ちます。

NumPyのrecord型配列で非ゼロ要素を見つける：record.nonzero()徹底解説

record 型配列は、各要素が複数のフィールドを持つ構造化データを表すために使用されます。各フィールドは、名前とデータ型を持つ属性として定義されます。これは、関係データベースのテーブルのようなデータ構造を表現するのに適しています。record

Pythonプログラミング初心者でも安心！NumPy recarrayのrecord.resize()をわかりやすく解説

NumPy は、科学計算やデータ分析に広く用いられる Python ライブラリです。その中でも、"Standard array subclasses" は、さまざまなデータ構造を効率的に処理するために設計された重要な機能です。この解説では、"Standard array subclasses" の一つである "recarray" における "record

Pandas じゃなくても大丈夫！ NumPy record.sum() で構造化データ分析を極める

"record. sum()" メソッドは、"record" 型配列の指定されたフィールドの値を合計し、スカラ値を返します。引数として、以下の要素を指定することができます。out 結果を出力する NumPy 配列。dtype 計算結果のデータ型。デフォルトは入力データのデータ型と同じです。

NumPy の Standard array subclasses で record.take() を使ってレコードを抽出する方法

record. take() メソッドは、レコード配列 arr とインデックスの配列 indices を引数として取り、indices で指定されたインデックスに対応するレコードの新しいレコード配列を返します。基本的な使い方このコードでは、data というサンプルのレコード配列を作成し、indices というインデックスの配列を使用して、最初のレコードと最後のレコードを抽出しています。

Python プログラミング：NumPy の「record.trace()」関数で「recarray」型配列の対角線要素の合計を計算する方法

"recarray" 型の配列は、レコード型のデータ構造を持つ配列です。レコード型とは、複数のフィールド (列) を持つデータ構造を指します。各フィールドには、異なるデータ型を割り当てることができます。"record. trace()" 関数は、"recarray" 型の配列の対角線要素の合計を計算し、スカラー値として返します。対角線要素とは、行と列のインデックスが一致する要素のことを指します。

NumPy の「Standard array subclasses」における「record.var()」のプログラミング解説

引数として、以下のものを指定できます。axis (オプション): 分散を計算する軸を指定します。デフォルトは None で、この場合、すべての列の分散を計算します。ddof (オプション): ベッセル補正の度合いを指定します。デフォルトは 0 です。keepdims (オプション): 結果が配列になるかどうかを指定します。デフォルトは False です。

NumPyのnumpy.rint()関数: 具体的なコード例

NumPyのnumpy. rint()関数は、配列の各要素を最も近い整数に丸めるための関数です。基本的な使い方丸めの方向負の数 -0.5以下の場合は切り捨て、-0.5以上の場合は切り上げ。正の数 0.5以上の場合は切り上げ、0.5未満の場合は切り捨て。

numpy.rot90()

numpy. rot90(m, k=1, axes=(0, 1)) は、NumPyの配列（行列）を90度ずつ反時計回りに回転させる関数です。主に2次元配列に対して使用されますが、多次元配列の特定の2つの軸に沿って回転させることも可能です。axes：回転させる軸を指定するタプル。デフォルトは(0, 1)で、これは2次元配列の行（axis 0）と列（axis 1）を回転させることを意味します。多次元配列の場合、このタプルで指定された2つの軸に沿って回転が行われます。例えば、(0, 2)と指定すると、0番目の軸と2番目の軸の間で回転が行われます。