0和1的Python随机数组

我想随机生成一个

数组

，由

n

个1和

m

个0组成

我想到了这个解决方案：

生成一个数组（

np.ones

）

生成零数组（

np.zeros

）

将它们组合成一个数组（

np.hstack

）

洗牌结果数组（

np.random.shuffle

）

---

似乎不是自然的解决方案。一些python式的想法？

我会把n个1和m个0组成一个数组作为

a = np.array([1] * n + [0] * m)

---

然后我会在上面调用

np.random.shuffle（）

。

使用

numpy.random.permutation

：

a = numpy.random.permutation([1] * n + [0] * m)

或者，使用数组而不是初始列表：

a = numpy.random.permutation(numpy.concatenate(np.ones(n), np.zeros(m)))

---

（我对

numpy

了解不够，无法评论

concatenate

和

hstack

之间的区别；它们在这里似乎产生了相同的结果。）

您的解决方案似乎是合理的。它确切地说明了它在做什么，并且做得很清楚

让我们比较一下您的实现：

a = np.hstack((np.ones(n), np.zeros(m)))
np.random.shuffle(a)

…有一个明显的选择：

a = np.ones(n+m)
a[:m] = 0
np.random.shuffle(a)

这可能会在不分配和移动大块数据的情况下节省一点时间，但需要更多的思考才能理解

并用Python而不是NumPy执行此操作：

a = np.array([1]*n + [0]*m)
np.random.shuffle(a)

…可能更简洁一点，但它似乎没有那么惯用的NumPy（就像

np.array（[1]*n）

没有

np.ones（n）

）那么惯用一样），而且它会变得更慢，并且会毫无理由地使用更多内存。（您可以通过使用

np.fromiter

来改善内存，但很明显它不会更简洁。）

---

当然，如果你不止一次这样做，真正的答案是把它分解成一个函数。然后函数的名称将解释它的功能，几乎任何不太复杂的解决方案都很容易理解…

我认为您的解决方案是合适的，因为它可读性强，具有Python风格。您没有说内存或性能是考虑因素。有可能np.random.shuffle与O（m+n）一样好，但其他答案表明它对值的洗牌不仅仅是一次传递。您可以在O（m+n）中完成此操作，只需一次传递，并且没有如下内存开销：

import random
m = 600 # zeros
n = 400 # ones

result = []
while m + n > 0:
    if (m > 0 and random.random() < float(m)/float(m + n)):
        result.append(0)
        m -= 1
    else:
        result.append(1)
        n -= 1

随机导入
m=600#零
n=400个1
结果=[]
当m+n>0时：
如果（m>0和random.random（）

你想要一个精确的

n

1和

m

零的数组，还是一个平均有

n

1和

m

零的

n+m

元素的数组？精确的n个1和m个零顺便说一句，你可能想要使用

np.random.shuffle

，不是

random。shuffle

。如果你想要精确的1和0的数字，你的解决方案在我看来非常好而且像蟒蛇一样。你为什么要这样做？它会变得更慢，占用更多的内存，而且很难看到补偿的好处。这对我来说是最容易理解的（我想，对同事来说也是如此）。这是唯一重要的事情，直到内存或速度成为问题，这部分代码成为瓶颈。我不知道

np.random.shuffle

，我会编辑它来使用它。关于

np.hstack（np.one（n），np.zero（m））

有什么难以理解的？这就直接说明了它所做的事情。你认为

np.array（[1]*n）

比

np.ones（n）

更具可读性吗？创建列表只是为了稍后将它们转换为数组对于大尺寸来说是很慢的，最好使用

np.ones

和

np.zero

和

将它们串联在一起，正如OP在他的问题中所建议的那样。为什么要使用
permutation
来制作一个乱序副本，而不是将其原地乱序？我可以看到将整件事情变成表达式的好处，在纯Python代码中我可能会写这样的东西，但在NumPy代码中，它似乎不那么惯用。就地洗牌可能确实更好。我刚刚注意到，
permutation
似乎是纯Python
sorted
（或者更确切地说，是
random.shuffled
，与
random.shuffle
的假想对应物）的
numpy
“等价物”。
np.random
与
shuffled
有一个等价物，这有点奇怪，你不经常想要它，但是stdlib的
random
没有一个，你经常想要它…至于
concatenate
和
hstack
之间的区别：如果你没有传递
axis
参数，并且你有1D数组，那根本没有区别；对于一个给定的问题，你会发现哪一个更具可读性。我想我会选择这里的
连接
，但既然OP选择了
hstack
，我想最好还是坚持下去。