Question

我想在Python中生成1或-1，作为在非负数和非正数之间随机化或随机改变已存在整数的符号的步骤。在Python中生成1或-1的最佳方法是什么？假设均匀分布，我知道我可以使用：

import random

#method1
my_number = random.choice((-1, 1))

#method2
my_number = (-1)**random.randrange(2)

#method3
# if I understand correctly random.random() should never return exactly 1
# so I use "<", not "<="
if random.random() < 0.5:
    my_number = 1
else:
    my_number = -1

#method4
my_number = random.randint(0,1)*2-1

使用timeit模块我得到了以下结果：

#method1
s = "my_number = random.choice((-1, 1))"
timeit.timeit(stmt = s, setup = "import random")
>2.814896769857569
#method2
s = "my_number = (-1)**random.randrange(2)"
timeit.timeit(stmt = s, setup = "import random")
>3.521280517518562
#method3
s = """
if random.random() < 0.5: my_number = 1
else: my_number = -1"""
timeit.timeit(stmt = s, setup = "import random")
>0.25321546903273884
#method4
s = "random.randint(0,1)*2-1"
timeit.timeit(stmt = s, setup = "import random")
>4.526625442240402

所以出乎意料的是方法3是最快的。我打赌方法1是最快的，因为它也是最短的。方法1（因为Python 3.6我认为？）和3都提供了引入不均匀分布的可能性。虽然方法1目前最短（主要优点），但我会选择方法3：

def positive_or_negative():
    if random.random() < 0.5:
        return 1
    else:
        return -1

测试：

s = """
import random
def positive_or_negative():
    if random.random() < 0.5:
        return 1
    else:
        return -1
        """
timeit.timeit(stmt = "my_number = positive_or_negative()", setup = s)
>0.3916183138621818

在Python中随机生成-1或1的更好（更快或更短）的方法？你有什么理由选择方法1而不是方法3，反之亦然？

Answer 1

＃3的单线变体：

return 1 if random.random() < 0.5 else -1

它快于（呃）比数学＆＃39;变体，因为它不涉及额外的算术。

Answer 2

这是另一个单行，我的时间显示比if / else比较0.5更快

[-1,1][random.randrange(2)]

Answer 3

如果您需要单个位（每个呼叫一个），您已经完成了基准测试，其他答案提供了其他信息。

如果您需要很多位或者可以预先计算位数以供以后使用，那么numpy的方法可能会闪耀。

以下是使用numpy的更多演示方法（令人惊讶的是，它没有专门针对此工作的方法）：

import numpy as np
import random

def sample_bits(N):
    assert N % 8 == 0  # demo only
    n_bytes = N // 8

    rbytes = np.random.randint(0, 255, dtype=np.uint8, size=n_bytes)
    return np.unpackbits(rbytes)

def alt(N):
    return np.random.choice([-1,1],size=N)

def alt2(N):
    return [1 if random.random() < 0.5 else -1 for i in range(N)]

if __name__ == '__main__':
    import timeit
    print(timeit.timeit("sample_bits(1024)", setup="from __main__ import sample_bits", number=10000))
    print(timeit.timeit("alt(1024)", setup="from __main__ import alt", number=10000))
    print(timeit.timeit("alt2(1024)", setup="from __main__ import alt2", number=10000))

输出：

0.06640421246836543
0.352129537507486
1.5522800431775592

一般的想法是：

使用numpy一步生成许多uint8
- （如果没有randint-API，可能会有更好的内部函数使用）
将uint8解包为8位
- 均匀性来自randint的均匀性保证

同样，这只是一个演示：

针对一个特定案例
不关心这些功能的不同结果类型
不关心-1与0（在你的使用案例中可能很重要）
（与更低级别的方法相比，甚至不是最优的;内部使用的MT可以用作比特源，不像许多其他PRNG那样需要fp-math！）

Answer 4

不确定你的应用程序究竟是什么，但我需要类似的大型矢量化数组。

这是获得标志数组的好方法：

（2 * np.random.randint（0,2，大小=（your_size）） - 1）

结果是一个数组，例如：

数组（[ - 1，-1，-1,1,1,1，-1，-1,1,1,1，-1，-1,1，-1]）

你可以使用reshape命令将上面的内容变为矩阵的大小：

（2 * np.random.randint（0,2，大小=（m * n个）） - 1）.reshape（M，N）

然后你可以用上面的矩阵乘以矩阵，并用随机符号得到所有成员。

A = np.array（[[1,2,3]，          [4,5,6]]）

B = A *（2 * np.random.randint（0,2，size =（2 * 3）） - 1）.reshape（2,3）

然后你得到类似的东西：

B =数组（[[1,2，-3]，[4,5，-6]]）

非常快，如果您的数据是矢量化的。

Answer 5

生成随机数的最快方法是使用numpy：

In [1]: import numpy as np

In [2]: import random

In [3]: %timeit [random.choice([-1,1]) for i in range(100000)]
10 loops, best of 3: 88.9 ms per loop

In [4]: %timeit [(-1)**random.randrange(2) for i in range(100000)]
10 loops, best of 3: 110 ms per loop

In [5]: %timeit [1 if random.random() < 0.5 else -1 for i in range(100000)]
100 loops, best of 3: 18.4 ms per loop

In [6]: %timeit [random.randint(0,1)*2-1 for i in range(100000)]
1 loop, best of 3: 180 ms per loop

In [7]: %timeit np.random.choice([-1,1],size=100000)
1000 loops, best of 3: 1.52 ms per loop

Answer 6

我的代码是

vals = array("i", [-1, 1])

def my_rnd():
    return vals[randint(0, 7) % 2]

随机生成1或-1（正整数或负整数）

6 个答案: