填充NumPy数组的最优方法：如何优雅替代列表循环转数组的代码？

Great question—your original approach works, but we can make this cleaner, more efficient, and more idiomatic to NumPy/Python. Let’s walk through the best options:

1. List Comprehension (Clean & Faster Than Explicit append) #

First, a quick win: replace your loop-and-append with a list comprehension. Python optimizes list comprehensions under the hood, so they’re faster than manually calling append in a loop, and the code is far more concise:

import numpy as np
a = np.array([sample_function(x) for _ in range(1000)])

This does the same thing as your original code but in one line, with better performance for most cases.

2. np.fromiter (Memory-Efficient for Large Datasets) #

If you’re working with very large numbers of iterations (way bigger than 1000), building a full Python list first can waste memory. np.fromiter lets you create a NumPy array directly from an iterator, skipping the intermediate list entirely:

# Replace dtype with the actual type returned by sample_function (e.g., np.int32, np.bool_)
a = np.fromiter((sample_function(x) for _ in range(1000)), dtype=np.float64)

This is especially useful when memory is a constraint—you don’t have to store the entire list in memory before converting to an array.

3. Vectorized Function Call (Optimal Performance) #

The fastest approach by far is to avoid Python-level loops entirely, if sample_function can handle NumPy arrays as input. If sample_function is already vectorized (i.e., it works element-wise on arrays), you can generate an array of x values and pass it directly:

# Create an array with 1000 copies of x
x_array = np.full(1000, x)
# Call the function once on the entire array
a = sample_function(x_array)

If sample_function isn’t vectorized yet, you can wrap it with np.vectorize (note: this is mostly syntactic sugar, not a performance boost over list comprehensions, but it makes the code look cleaner):

vectorized_sample = np.vectorize(sample_function)
a = vectorized_sample(np.full(1000, x))

For true performance gains, though, rewrite sample_function to natively handle NumPy arrays (using NumPy operations instead of Python loops) whenever possible.

Quick Comparison #

• Your original loop: Verbose, slowest due to repeated append calls (list resizing overhead).
• List comprehension: Clean, faster than append loops, good for small-to-medium datasets.
• np.fromiter: Memory-efficient, great for large datasets.
• Vectorized calls: Fastest (C-level loops), ideal if the function supports arrays.

内容的提问来源于stack exchange，提问作者Nemes Gyula Ádám