NumPy徹底解説: zeros_like()の基本から応用まで

numpy.zeros_like()は、NumPyライブラリが提供する非常に便利な関数の一つです。この関数は、入力として与えられた配列と同じ形状とデータ型を持つ、すべての要素がゼロである新しい配列を作成します。

何のために使うのか？

主な用途は以下の通りです。

1. 形状とデータ型を保持したままゼロ配列を初期化する: 既存の配列と同じ「枠組み」で、内容をすべてゼロで埋めたい場合に非常に役立ちます。例えば、ある計算の初期値としてゼロ配列が必要な場合や、中間結果を格納するためのプレースホルダーとして使えます。

2. 可読性と簡潔性: np.zeros(arr.shape, dtype=arr.dtype)と書く代わりにnp.zeros_like(arr)と書くことで、コードがより短く、何をしているのかが明確になります。

使い方

基本的な使い方は非常にシンプルです。

import numpy as np

# 元になる配列
arr = np.array([[1, 2, 3],
                [4, 5, 6]])

# arr と同じ形状、同じデータ型で、要素がすべてゼロの新しい配列を作成
zero_arr = np.zeros_like(arr)

print("元の配列 (arr):\n", arr)
print("zeros_like で作成された配列 (zero_arr):\n", zero_arr)
print("zero_arr の形状:", zero_arr.shape)
print("zero_arr のデータ型:", zero_arr.dtype)

出力例

元の配列 (arr):
 [[1 2 3]
 [4 5 6]]
zeros_like で作成された配列 (zero_arr):
 [[0 0 0]
 [0 0 0]]
zero_arr の形状: (2, 3)
zero_arr のデータ型: int64

numpy.zeros_like()には、いくつかの便利なオプション引数があります。

• order: メモリ上での配列の格納順序（'C' for C-style row-major, 'F' for Fortran-style column-major）を指定できます。デフォルトは元の配列の順序に従います。

• dtype: 新しく作成される配列のデータ型を明示的に指定できます。これを指定すると、元の配列のデータ型ではなく、指定されたデータ型が使用されます。

  arr_float = np.array([1.0, 2.0, 3.0])
  zero_int = np.zeros_like(arr_float, dtype=int)
  print("元の配列 (arr_float):\n", arr_float)
  print("dtype=int で作成された配列 (zero_int):\n", zero_int)
  print("zero_int のデータ型:", zero_int.dtype)
  

  出力例
  

  元の配列 (arr_float):
   [1. 2. 3.]
  dtype=int で作成された配列 (zero_int):
   [0 0 0]
  zero_int のデータ型: int64
  

---

入力値が配列ではない、または配列ライクなオブジェクトではない場合

zeros_like() は、NumPy配列、リスト、タプルなど、形状とデータ型を推測できる「配列ライク」なオブジェクトを期待します。数値などのスカラー値を直接渡すとエラーになります。

エラーの例

import numpy as np

# スカラー値を渡すとエラー
# zero_scalar = np.zeros_like(10)
# TypeError: 'int' object has no attribute '__array_interface__'

トラブルシューティング
入力が単一の数値である場合は、np.zeros() を使用して明示的に形状を指定するか、一度NumPy配列に変換してからzeros_likeを使います。

import numpy as np

# np.zeros() を使う
zero_array_scalar = np.zeros(1) # 形状 (1,) の配列
print(zero_array_scalar)

# または、スカラー値を配列に変換してから zeros_like を使う
scalar_as_array = np.array(10)
zero_array_from_scalar = np.zeros_like(scalar_as_array)
print(zero_array_from_scalar)

意図しないデータ型 (dtype) になる

zeros_like() はデフォルトで入力配列のデータ型を継承しますが、明示的に dtype 引数を指定すると、そのデータ型が優先されます。これにより、意図しないデータ型で配列が作成されることがあります。

エラーの例 (意図しない動作)

import numpy as np

arr_float = np.array([1.1, 2.2, 3.3])
# 意図せず整数型にしてしまう
zero_int_from_float = np.zeros_like(arr_float, dtype=int)
print(zero_int_from_float) # 出力: [0 0 0] - 小数部分が失われる
print(zero_int_from_float.dtype) # 出力: int64

トラブルシューティング
データ型が期待通りであることを確認するために、dtype を明示的に指定する場合や、元の配列の dtype を確認する習慣をつけましょう。

import numpy as np

arr_float = np.array([1.1, 2.2, 3.3])
# 浮動小数点型を維持したい場合
zero_float_correct = np.zeros_like(arr_float) # dtypeを指定しないか、arr_float.dtypeを指定
print(zero_float_correct)
print(zero_float_correct.dtype)

# 明示的に元のデータ型と同じにしたい場合
zero_float_explicit = np.zeros_like(arr_float, dtype=arr_float.dtype)
print(zero_float_explicit)
print(zero_float_explicit.dtype)

メモリ不足 (MemoryError)

非常に大きな配列に対して zeros_like() を使用すると、システムメモリを使い果たし MemoryError が発生する可能性があります。これは zeros_like() に限らず、大きなNumPy配列を扱う際によくある問題です。

エラーの例

import numpy as np

# 非常に大きな配列を想定 (実際の実行は注意)
# large_array = np.zeros((100000, 100000), dtype=np.float64) # これ自体がMemoryErrorを起こす可能性
# zero_large = np.zeros_like(large_array) # これもMemoryErrorの可能性

トラブルシューティング

• メモリの解放: 不要になった大きな配列は del で削除し、Pythonのガベージコレクタにメモリを解放するように促します。
• ジェネレーターやチャンク処理を利用する: 全体を一度にメモリにロードするのではなく、データをチャンクに分割して処理することを検討します。Daskのようなライブラリが役立つ場合があります。
• より少ないメモリで済むデータ型を使用する: float64 の代わりに float32 や int32 など、必要に応じてデータ型を小さくすることを検討します。
• 配列のサイズを確認する: 作成しようとしている配列の要素数とデータ型から、必要なメモリ量を計算します。
  • 要素数 * 各要素のバイト数
  • 例: (100000 * 100000) * 8 bytes (for float64) = 80,000,000,000 bytes = 80 GB

Daskなどの遅延評価ライブラリとの連携に関する問題

Daskのような遅延評価ライブラリを使用している場合、da.zeros_like（Daskの同等の関数）で作成された配列が、後続の処理で書き込み可能でない（read-only）という問題に遭遇することがあります。これは、NumPy自体のzeros_likeとは直接関係ありませんが、似たような名前の関数を使う際に発生しやすいので注意が必要です。

# import dask.array as da
#
# dask_array_b = da.zeros_like(some_dask_array)
# # 後の処理で dask_array_b の要素を変更しようとすると ValueError が発生する可能性
# # ValueError: assignment destination is read-only

トラブルシューティング (Daskの場合)
Daskの配列が読み取り専用になる場合、map_blocksなどで処理を行う際に、新しいチャンクを明示的に作成してそこに書き込むなど、Daskの推奨される方法に従う必要があります。

shape 引数と order 引数の理解不足

zeros_like() は、NumPy 1.17.0 以降で shape 引数を受け入れるようになりました。これにより、元の配列の形状を上書きして新しい形状のゼロ配列を作成できます。また、order 引数もメモリレイアウトを制御するために使えます。これらを誤解すると、予期しない形状やパフォーマンスの問題を引き起こす可能性があります。

例

import numpy as np

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

# 元の形状を上書きして新しい形状のゼロ配列を作成
new_shape_zero = np.zeros_like(arr, shape=(3, 3))
print("新しい形状のゼロ配列:\n", new_shape_zero)

# order='F' (Fortran order) で作成
fortran_order_zero = np.zeros_like(arr, order='F')
print("Fortran order のゼロ配列:\n", fortran_order_zero)
print("Fortran order のゼロ配列のメモリ順序:", fortran_order_zero.flags['F_CONTIGUOUS'])

• order 引数は、特定のメモリレイアウトが必要な場合にのみ使用し、通常はデフォルトの K（可能な限り元の配列のレイアウトを維持）で問題ありません。パフォーマンスがクリティカルな場合や、他のライブラリとの連携で特定のメモリレイアウトが必要な場合に検討します。
• shape 引数を使う場合は、元の配列の形状ではなく、指定した形状が適用されることを理解しておく必要があります。

---

numpy.zeros_like() は、既存の配列と同じ形状とデータ型で、全ての要素がゼロの新しい配列を作成するために使用されます。さまざまなシナリオでの使用例を見ていきましょう。

例 1: 基本的な使い方 - 配列の初期化

最も基本的な使い方です。既存の配列と同じ「枠」を持つ、空（ゼロで埋められた）の配列が欲しい場合に非常に便利です。

import numpy as np

# 元になる配列
arr_original = np.array([[10, 20, 30],
                         [40, 50, 60]])

# arr_original と同じ形状、同じデータ型で、要素がすべてゼロの新しい配列を作成
arr_zeros = np.zeros_like(arr_original)

print("--- 例 1: 基本的な使い方 ---")
print("元の配列 (arr_original):\n", arr_original)
print("arr_original の形状:", arr_original.shape)
print("arr_original のデータ型:", arr_original.dtype)
print("\nzeros_like で作成された配列 (arr_zeros):\n", arr_zeros)
print("arr_zeros の形状:", arr_zeros.shape)
print("arr_zeros のデータ型:", arr_zeros.dtype)

実行結果

--- 例 1: 基本的な使い方 ---
元の配列 (arr_original):
 [[10 20 30]
 [40 50 60]]
arr_original の形状: (2, 3)
arr_original のデータ型: int64

zeros_like で作成された配列 (arr_zeros):
 [[0 0 0]
 [0 0 0]]
arr_zeros の形状: (2, 3)
arr_zeros のデータ型: int64

この例では、arr_original が (2, 3) の形状と int64 のデータ型を持っているため、arr_zeros もまったく同じ属性を持ち、中身だけがゼロで埋められています。

例 2: 異なるデータ型を指定する

デフォルトでは元の配列のデータ型が継承されますが、dtype 引数を使って明示的に別のデータ型を指定することもできます。

import numpy as np

# 元になる配列 (浮動小数点型)
arr_float = np.array([[1.1, 2.2],
                      [3.3, 4.4]])

# arr_float と同じ形状で、データ型を整数型 (int) に指定してゼロ配列を作成
arr_zeros_int = np.zeros_like(arr_float, dtype=int)

# arr_float と同じ形状で、データ型を単精度浮動小数点型 (float32) に指定してゼロ配列を作成
arr_zeros_float32 = np.zeros_like(arr_float, dtype=np.float32)

print("\n--- 例 2: 異なるデータ型を指定する ---")
print("元の配列 (arr_float):\n", arr_float)
print("arr_float のデータ型:", arr_float.dtype)

print("\ndtype=int で作成された配列 (arr_zeros_int):\n", arr_zeros_int)
print("arr_zeros_int のデータ型:", arr_zeros_int.dtype)

print("\ndtype=np.float32 で作成された配列 (arr_zeros_float32):\n", arr_zeros_float32)
print("arr_zeros_float32 のデータ型:", arr_zeros_float32.dtype)

実行結果

--- 例 2: 異なるデータ型を指定する ---
元の配列 (arr_float):
 [[1.1 2.2]
 [3.3 4.4]]
arr_float のデータ型: float64

dtype=int で作成された配列 (arr_zeros_int):
 [[0 0]
 [0 0]]
arr_zeros_int のデータ型: int64

dtype=np.float32 で作成された配列 (arr_zeros_float32):
 [[0. 0.]
 [0. 0.]]
arr_zeros_float32 のデータ型: float32

この例では、元の配列が float64 であっても、dtype=int や dtype=np.float32 を指定することで、作成されるゼロ配列のデータ型を制御できることを示しています。

例 3: リストやタプルからの作成

zeros_like() はNumPy配列だけでなく、リストやタプルなどの配列ライクなオブジェクトも入力として受け入れます。

import numpy as np

# リスト
my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# タプル
my_tuple = ((10, 11), (12, 13))

# リストからゼロ配列を作成
zeros_from_list = np.zeros_like(my_list)

# タプルからゼロ配列を作成
zeros_from_tuple = np.zeros_like(my_tuple)

print("\n--- 例 3: リストやタプルからの作成 ---")
print("元のリスト (my_list):\n", my_list)
print("リストから作成されたゼロ配列:\n", zeros_from_list)
print("ゼロ配列の形状:", zeros_from_list.shape)
print("ゼロ配列のデータ型:", zeros_from_list.dtype)

print("\n元のタプル (my_tuple):\n", my_tuple)
print("タプルから作成されたゼロ配列:\n", zeros_from_tuple)
print("ゼロ配列の形状:", zeros_from_tuple.shape)
print("ゼロ配列のデータ型:", zeros_from_tuple.dtype)

実行結果

--- 例 3: リストやタプルからの作成 ---
元のリスト (my_list):
 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
リストから作成されたゼロ配列:
 [[0 0 0]
 [0 0 0]
 [0 0 0]]
ゼロ配列の形状: (3, 3)
ゼロ配列のデータ型: int64

元のタプル (my_tuple):
 ((10, 11), (12, 13))
タプルから作成されたゼロ配列:
 [[0 0]
 [0 0]]
ゼロ配列の形状: (2, 2)
ゼロ配列のデータ型: int64

リストやタプルからでも、NumPyが形状とデータ型を適切に推測してゼロ配列を作成してくれることがわかります。

例 4: shape 引数を使って形状を上書きする (NumPy 1.17.0 以降)

NumPy 1.17.0 から、zeros_like() は shape 引数を受け取るようになりました。これにより、元の配列のデータ型は継承しつつ、形状だけを新しく指定したゼロ配列を作成できます。

import numpy as np

# 元になる配列
arr_small = np.array([1, 2, 3])

# arr_small のデータ型を継承しつつ、形状を (2, 4) に指定
arr_new_shape = np.zeros_like(arr_small, shape=(2, 4))

# arr_small のデータ型を継承しつつ、形状を (5,) に指定
arr_larger_1d = np.zeros_like(arr_small, shape=(5,))

print("\n--- 例 4: `shape` 引数を使って形状を上書きする ---")
print("元の配列 (arr_small):\n", arr_small)
print("arr_small の形状:", arr_small.shape)
print("arr_small のデータ型:", arr_small.dtype)

print("\nshape=(2, 4) で作成された配列 (arr_new_shape):\n", arr_new_shape)
print("arr_new_shape の形状:", arr_new_shape.shape)
print("arr_new_shape のデータ型:", arr_new_shape.dtype)

print("\nshape=(5,) で作成された配列 (arr_larger_1d):\n", arr_larger_1d)
print("arr_larger_1d の形状:", arr_larger_1d.shape)
print("arr_larger_1d のデータ型:", arr_larger_1d.dtype)

実行結果

--- 例 4: `shape` 引数を使って形状を上書きする ---
元の配列 (arr_small):
 [1 2 3]
arr_small の形状: (3,)
arr_small のデータ型: int64

shape=(2, 4) で作成された配列 (arr_new_shape):
 [[0 0 0 0]
 [0 0 0 0]]
arr_new_shape の形状: (2, 4)
arr_new_shape のデータ型: int64

shape=(5,) で作成された配列 (arr_larger_1d):
 [0 0 0 0 0]
arr_larger_1d の形状: (5,)
arr_larger_1d のデータ型: int64

この機能は、元の配列のデータ型だけを再利用したいが、異なるサイズの配列が必要な場合に非常に便利です。

例 5: 関数内でプレースホルダーとして使用する

計算結果を格納するための初期値（ゼロで初期化された配列）として zeros_like() を使う一般的な例です。

import numpy as np

def calculate_with_placeholder(data_array):
    """
    入力配列と同じ形状のゼロ配列をプレースホルダーとして使用し、
    特定の計算を実行する関数。
    """
    # data_array と同じ形状・データ型でゼロの配列を作成
    # これを計算結果の初期値として使う
    result_array = np.zeros_like(data_array, dtype=float) # 明示的に浮動小数点型にする

    # 例として、各要素を2倍して結果配列に加算する（実際の計算はもっと複雑になり得る）
    for i in range(data_array.shape[0]):
        if data_array.ndim == 1:
            result_array[i] = data_array[i] * 2
        else: # 2次元以上の場合
            for j in range(data_array.shape[1]):
                result_array[i, j] = data_array[i, j] * 2

    return result_array

print("\n--- 例 5: 関数内でプレースホルダーとして使用する ---")
data_1d = np.array([1, 2, 3, 4])
output_1d = calculate_with_placeholder(data_1d)
print("元の1D配列:\n", data_1d)
print("計算結果の1D配列:\n", output_1d)
print("データ型:", output_1d.dtype)


data_2d = np.array([[10, 20], [30, 40]])
output_2d = calculate_with_placeholder(data_2d)
print("\n元の2D配列:\n", data_2d)
print("計算結果の2D配列:\n", output_2d)
print("データ型:", output_2d.dtype)

実行結果

--- 例 5: 関数内でプレースホルダーとして使用する ---
元の1D配列:
 [1 2 3 4]
計算結果の1D配列:
 [2. 4. 6. 8.]
データ型: float64

元の2D配列:
 [[10 20]
 [30 40]]
計算結果の2D配列:
 [[20. 40.]
 [60. 80.]]
データ型: float64

この例では、calculate_with_placeholder 関数が、入力された data_array と同じ形状のゼロ配列を np.zeros_like() を使って作成し、それを計算結果を格納するための「プレースホルダー」として利用しています。これにより、関数がどのような形状の入力配列を受け取っても、それに適した結果配列を動的に準備できます。

---

numpy.zeros_like() は便利ですが、常にそれが唯一の選択肢というわけではありません。状況によっては、他の方法がより適切であったり、あるいは特定の場合には代替手段しか使えないこともあります。

主な代替方法は以下の通りです。

1. numpy.zeros() を使用する
2. numpy.empty_like() を使用する
3. 既存の配列をインプレースでゼロにする
4. numpy.full_like() を使用する (より汎用的なケース)
5. numpy.array() とゼロのリスト/タプルを使用する

それぞれ詳しく見ていきましょう。

numpy.zeros() を使用する

numpy.zeros_like(arr) は、内部的には numpy.zeros(arr.shape, dtype=arr.dtype) と同等の処理を行うことがよくあります。つまり、元の配列の shape (形状) と dtype (データ型) を明示的に指定して numpy.zeros() を呼び出す方法です。

いつ使うか？

• 元の配列の shape は使いたいが、dtype は別のものを指定したい場合（この場合は zeros_like でも dtype 引数を使えば可能ですが、zeros の方が概念的に分かりやすい場合もあります）。
• zeros_like() の動作をより明示的にしたい場合。

コード例

import numpy as np

arr_original = np.array([[1, 2], [3, 4]], dtype=np.int32)

# zeros_like の代替として zeros を使う
# 元の配列の形状とデータ型を明示的に指定
alt_zeros = np.zeros(arr_original.shape, dtype=arr_original.dtype)

print("--- 代替方法 1: numpy.zeros() を使用する ---")
print("元の配列 (arr_original):\n", arr_original)
print("arr_original の形状:", arr_original.shape)
print("arr_original のデータ型:", arr_original.dtype)
print("\n代替ゼロ配列 (alt_zeros):\n", alt_zeros)
print("alt_zeros の形状:", alt_zeros.shape)
print("alt_zeros のデータ型:", alt_zeros.dtype)

# 形状は同じだが、データ型をfloat64にしたい場合
alt_zeros_float = np.zeros(arr_original.shape, dtype=np.float64)
print("\nデータ型を float64 にした代替ゼロ配列:\n", alt_zeros_float)
print("データ型:", alt_zeros_float.dtype)

考察
コードが少し長くなりますが、何が引数として渡されているかが非常に明確になります。NumPy 1.17.0 以降の zeros_like(arr, shape=...) と同様に、zeros(new_shape, dtype=arr.dtype) とすることで、形状だけを変えつつデータ型を継承することも可能です。

numpy.empty_like() を使用する

numpy.empty_like() は、zeros_like() と同様に、入力配列と同じ形状とデータ型を持つ新しい配列を作成しますが、要素は初期化されません。つまり、その時点でのメモリ上の「ゴミデータ」が含まれたままになります。

いつ使うか？

• 初期値がゼロである必要がない場合。
• パフォーマンスが非常にクリティカルな場合。ゼロで初期化するオーバーヘッドがないため、zeros_like() よりもわずかに高速な場合があります。ただし、現代のPython環境ではその差はほとんど無視できるレベルであることが多いです。
• 後で配列の全ての要素を上書きすることがわかっている場合。

注意
初期化されていないため、意図せずゴミデータを使用して計算を行ってしまうリスクがあります。必ず全ての要素を上書きする前提で使用してください。

コード例

import numpy as np

arr_original = np.array([[10, 20], [30, 40]])

# empty_like を使用
alt_empty = np.empty_like(arr_original)

print("\n--- 代替方法 2: numpy.empty_like() を使用する ---")
print("元の配列 (arr_original):\n", arr_original)
print("\nempty_like で作成された配列 (alt_empty):\n", alt_empty)
print("alt_empty の形状:", alt_empty.shape)
print("alt_empty のデータ型:", alt_empty.dtype)

# 例: 後で要素を上書きする
alt_empty[0, 0] = 100
print("\n要素を上書きした後:\n", alt_empty)

考察
出力される alt_empty の初期値は、実行環境によって異なるランダムな値になります。パフォーマンスが重要で、かつ「必ず上書きする」という強い保証がある場合に検討する選択肢です。

既存の配列をインプレースでゼロにする

もし、既存のNumPy配列の内容を「ゼロ」で上書きしたいだけで、新しい配列を作成する必要がない場合は、その配列の要素を直接ゼロに設定することができます。これは新しいメモリを割り当てないため、非常に効率的です。

いつ使うか？

• （例えば、ある計算のイテレーションごとに配列をリセットしたい場合など）
• 既存の配列オブジェクトを再利用したい場合。
• メモリ使用量を最小限に抑えたい場合。

コード例

import numpy as np

arr_data = np.array([[1, 2, 3], [4, 5, 6]])

print("\n--- 代替方法 3: 既存の配列をインプレースでゼロにする ---")
print("ゼロにする前の配列 (arr_data):\n", arr_data)

# 配列の全要素をゼロに設定
arr_data.fill(0) # または arr_data[:] = 0

print("\nゼロにした後の配列 (arr_data):\n", arr_data)
print("データ型:", arr_data.dtype)
print("形状:", arr_data.shape)

考察
これは新しい配列を作成するのではなく、既存の配列を変更する点に注意してください。元のデータが不要になる場合にのみ使用すべきです。

numpy.full_like() を使用する (より汎用的なケース)

numpy.full_like() は、zeros_like() のより汎用的なバージョンです。入力配列と同じ形状とデータ型で、全ての要素が指定した値で埋められた新しい配列を作成します。ゼロで埋める場合は、単に指定する値を 0 にすれば zeros_like() と同じ結果になります。

いつ使うか？

• zeros_like() の代わりに、より一般的な初期化関数を使いたい場合。
• ゼロだけでなく、任意の特定の値で配列を初期化したい場合。

コード例

import numpy as np

arr_original = np.array([[1.0, 2.0], [3.0, 4.0]])

# zeros_like の代替として full_like を使う (ゼロで埋める)
alt_full_zeros = np.full_like(arr_original, 0)

# 特定の値 (例えば 7.7) で埋める場合
alt_full_sevens = np.full_like(arr_original, 7.7)

print("\n--- 代替方法 4: numpy.full_like() を使用する ---")
print("元の配列 (arr_original):\n", arr_original)
print("\nfull_like でゼロで作成された配列 (alt_full_zeros):\n", alt_full_zeros)
print("データ型:", alt_full_zeros.dtype)

print("\nfull_like で 7.7 で作成された配列 (alt_full_sevens):\n", alt_full_sevens)
print("データ型:", alt_full_sevens.dtype)

考察
full_like は zeros_like よりも表現力が豊かです。ゼロで初期化するだけでなく、他の値で初期化したい場面が頻繁にある場合は、こちらを使うとコードの一貫性を保ちやすいかもしれません。

numpy.array() とゼロのリスト/タプルを使用する

これは、NumPy配列をゼロで初期化する最も「手動」な方法です。最初にゼロを含むPythonのリストやタプルを作成し、それを np.array() に渡してNumPy配列に変換します。

いつ使うか？

• (ほとんどの場合、これは推奨されません。上記の方法の方が効率的でNumPyらしいからです。)
• NumPyを使い始めたばかりで、より基本的な方法から理解したい場合。
• 非常に特殊なケースで、NumPyの初期化関数が使えない場合。

コード例

import numpy as np

# 形状を明示的に指定してゼロのリストを作成
list_of_zeros = [[0, 0, 0], [0, 0, 0]]
alt_array_from_list = np.array(list_of_zeros)

# 形状とデータ型を指定してゼロのリストを作成（あまり一般的ではないが、可能）
# float_list_of_zeros = [[0.0] * 2] * 3 # これだと浅いコピーになる可能性があるので注意
float_list_of_zeros = [[0.0 for _ in range(2)] for _ in range(3)]
alt_array_from_float_list = np.array(float_list_of_zeros, dtype=np.float32)

print("\n--- 代替方法 5: numpy.array() とゼロのリスト/タプルを使用する ---")
print("リストから作成されたゼロ配列:\n", alt_array_from_list)
print("形状:", alt_array_from_list.shape)
print("データ型:", alt_array_from_list.dtype)

print("\nfloat32 で作成されたゼロ配列:\n", alt_array_from_float_list)
print("形状:", alt_array_from_float_list.shape)
print("データ型:", alt_array_from_float_list.dtype)

考察
この方法は、リストの構築自体にオーバーヘッドがあり、特に大きな配列では非効率的です。NumPyの提供する専用の初期化関数（zeros, zeros_like など）を使う方が、パフォーマンスとコードの簡潔性の両面で優れています。

代替方法	特徴
numpy.zeros()	最も直接的な代替。形状とデータ型を明示的に指定。zeros_like の内部動作に近い。
numpy.empty_like()	初期化を行わない。パフォーマンスが重要で、全要素を確実に上書きする場合。ゴミデータに注意。
既存の配列をインプレースでゼロにする	新しいメモリを割り当てず、既存の配列を変更する。メモリ効率が良い。元のデータが不要になる場合に限る。
numpy.full_like()	zeros_like の汎用版。ゼロだけでなく、任意の指定された値で配列を初期化できる。
numpy.array() + ゼロのリスト/タプル	最も手動な方法。非効率的で、ほとんどの場合推奨されない。学習目的やごく小規模な配列でのみ検討。