Python NumPy数组初始化（用相同的值填充）

我需要创建一个长度为

n

的NumPy数组，其中的每个元素都是

v

还有什么比这更好的吗

a = empty(n)
for i in range(n):
    a[i] = v

我知道

零

和

一

对v=0,1有效。我可以使用

v*ones（n）

，但是当

v

是

None

时，它就不起作用了，而且速度会慢得多。

我认为这是最快的方法

a = np.empty(10)
a.fill(7)

---

您还应该始终避免像在示例中那样进行迭代。一个简单的

A[：]=v

将完成使用numpy进行的迭代。

您可以使用

numpy.tile

，例如：

v = 7
rows = 3
cols = 5
a = numpy.tile(v, (rows,cols))
a
Out[1]: 
array([[7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7]])

---

虽然

tile

的意思是“平铺”一个数组（而不是像本例中的标量），但它可以完成这项工作，创建任何大小和维度的预填充数组。

为Numpy 1.7.0更新：（帽子提示@Rolf Bartstra。）

a=np.empty（n）；a、 填充（5）

最快

按降速顺序：

%timeit a=np.empty(10000); a.fill(5)
100000 loops, best of 3: 5.85 us per loop

%timeit a=np.empty(10000); a[:]=5 
100000 loops, best of 3: 7.15 us per loop

%timeit a=np.ones(10000)*5
10000 loops, best of 3: 22.9 us per loop

%timeit a=np.repeat(5,(10000))
10000 loops, best of 3: 81.7 us per loop

%timeit a=np.tile(5,[10000])
10000 loops, best of 3: 82.9 us per loop

timeit a=np.empty(1e4); a.fill(5) 
# 100000 loops, best of 3: 10.2 us per loop
timeit a=np.empty(1e4); a[:]=5
# 100000 loops, best of 3: 16.9 us per loop
timeit a=np.ones(1e4)*5
# 100000 loops, best of 3: 32.2 us per loop
timeit a=np.tile(5,[1e4])
# 10000 loops, best of 3: 90.9 us per loop
timeit a=np.repeat(5,(1e4))
# 10000 loops, best of 3: 98.3 us per loop
timeit a=np.array([5]*int(1e4))
# 1000 loops, best of 3: 1.69 ms per loop (slowest BY FAR!)

---

显然，不仅绝对速度，而且速度顺序（由用户1579844报告）都取决于机器；以下是我的发现：

a=np.empty（1e4）；a、 填充（5）

最快

按降速顺序：

%timeit a=np.empty(10000); a.fill(5)
100000 loops, best of 3: 5.85 us per loop

%timeit a=np.empty(10000); a[:]=5 
100000 loops, best of 3: 7.15 us per loop

%timeit a=np.ones(10000)*5
10000 loops, best of 3: 22.9 us per loop

%timeit a=np.repeat(5,(10000))
10000 loops, best of 3: 81.7 us per loop

%timeit a=np.tile(5,[10000])
10000 loops, best of 3: 82.9 us per loop

timeit a=np.empty(1e4); a.fill(5) 
# 100000 loops, best of 3: 10.2 us per loop
timeit a=np.empty(1e4); a[:]=5
# 100000 loops, best of 3: 16.9 us per loop
timeit a=np.ones(1e4)*5
# 100000 loops, best of 3: 32.2 us per loop
timeit a=np.tile(5,[1e4])
# 10000 loops, best of 3: 90.9 us per loop
timeit a=np.repeat(5,(1e4))
# 10000 loops, best of 3: 98.3 us per loop
timeit a=np.array([5]*int(1e4))
# 1000 loops, best of 3: 1.69 ms per loop (slowest BY FAR!)

因此，请尝试找出并使用平台上最快的方法。

介绍了NumPy 1.8，这是一种比

empty（）

后跟

fill（）

更直接的方法，用于创建填充了特定值的数组：

>>> np.full((3, 5), 7)
array([[ 7.,  7.,  7.,  7.,  7.],
       [ 7.,  7.,  7.,  7.,  7.],
       [ 7.,  7.,  7.,  7.,  7.]])

>>> np.full((3, 5), 7, dtype=int)
array([[7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7]])

这可以说是创建一个填充了特定值的数组的方法，因为它明确地描述了正在实现的目标（原则上，它可以非常有效，因为它执行一项非常具体的任务）。

numpy.array（n*[值]）

考虑到这一点，但显然这比所有其他关于足够大的

n

的建议都要慢

这是与（我的一个宠物项目）的充分比较

两个

empty

替代方案仍然是最快的（使用NumPy 1.12.1）

full

适用于大型阵列

---

生成绘图的代码：

将numpy导入为np
导入性能图
def空载_加注（n）：
a=np.空（n）
a、 填充（3.14）
归还
def空_冒号（n）：
a=np.空（n）
a[：]=3.14
归还
def ones_次（n）：
返回3.14*np.ones（n）
def重复（n）：
返回np。重复（3.14，（n））
def磁贴（n）：
返回np。重复（3.14，[n]）
def满（n）：
返回np.full（（n），3.14）
def列表到阵列（n）：
返回np.数组（n*[3.14]）
perfplot.show(
设置=λn:n，
内核=[empty\u fill，empty\u冒号，one\u次，repeat，tile，full，list\u to\u数组]，
n_范围=[2**k表示范围（27）中的k]，
xlabel=“len（a）”，
logx=True，
逻辑=正确，
)

不带numpy

>>>[2]*3
[2, 2, 2]

---

非常感谢。在查看

fill

时，我发现

repeat

更适合我的需要。您是否介意更新您的答案，说您对

a[：]=v

的建议实际上比

fill

的总体速度更快？@max它更快吗？广播是一种更通用的填充数组的方法，我想它比

fill

这个非常狭隘的用例要慢或相等。这个full（）方法对我来说很好，但我找不到相关的文档。有人能给我指出正确的位置吗？你至少可以在Python shell中执行

help（numpy.full）

。在我的系统（Python 2.7，Numpy 1.8）上，np.full（）实际上比np.empty（）和np.fill（）稍慢。对于10000个元素，我观察到了相同的情况（除了

np.fill（）

不存在，应该是

arr.fill（）

），相差约10%。如果差异更大，我会在NumPy bug追踪器中提出一个问题。：）我更喜欢更明确、更清晰的代码，因为执行时间上的差异如此之小，所以我一直使用

np.full（）

。在我的机器上，np.full（）的速度与np.array.fill（）的速度相同。为更近、更直接的

np.full（）添加计时将非常有用。在我的机器上，使用NumPy 1.8.1，它比不太直接的
fill（）
版本慢了大约15%（这是出乎意料的，因为
full（）
可能会稍微快一点）。@DavidSanders:我不确定我是否在跟踪你：
fill（）
是最快的解决方案。乘法解要慢得多。注意：如果速度确实是一个问题，那么使用
10000
而不是
1e4
会产生明显的不同，因为某种原因（
full（）
几乎慢了50%，使用
1e4
）。只需使用
full（）
添加我的结果，当数据类型不是显式的浮点型时，它运行得相当慢。否则，它与这里最好的方法相比（但速度稍慢）。@user2699我没有观察到这一点，有100000个元素：
full（100000，5）
，
full（100000，5，dtype=float）
，
full（100000，5，dtype=int）
和
a=np.empty（100000）；a、 fill（5）
在我的机器上大约占用相同的时间（没有缓存：
%timeit-r1-n1…
）（NumPy 1.11.2）。在我的计算机上，对于0情况，在循环中使用
a=np.zeros（n）
比
a.fill（0）
快。这与我的预期相反，因为我认为
a=np。零（n）
需要分配和初始化新内存。如果有人能解释这一点，我将不胜感激。你不能在numpy数组中放置None，因为单元格是用特定的数据类型创建的，而没有一个单元格有自己的类型，实际上是指针。@Camion是的，我现在知道：）当然
v*ones（n）
仍然很可怕，因为它使用了昂贵的乘法。但是，将
*
替换为
+
，并且
v+zeros（n）
在某些情况下表现得出人意料地好（）.max，在添加v之前不使用零创建数组，而是使用
var=np.empty（n）
将其创建为空，然后