python - 减少程序生成随机数据的运行时间

Question

我需要生成10GB的随机数据。
我编写了下面的python脚本，通过将包含可打印的任意长度的ASCII字符的字符串写入每行文件来生成所需的字节数
它需要3个命令行参数。
1）尺寸
2）字符串的最小长度（可选参数，默认为4）
3）字符串的最大长度（可选参数，默认值为10）
这个程序既不使用内存，也不做大量的IO。我可以使用什么策略来增加单位时间写入的字节数。

import random
import sys

K_SIZE = 1000

class Generator:
    def __init__(self,low=4,high=10):
        self.table = {i:chr(i) for i in range(33,127)}
        self.low = low
        self.high = high


    def create_n_bytes(self,total_bytes):
        bytes_created = 0
        """Hack at the moment, this condition will fail only after more than n bytes are 
        written """
        while bytes_created < total_bytes:
            bytes_to_create = random.randint(self.low,self.high)
            bytes_created = bytes_created+bytes_to_create+1
            word=[""]*bytes_to_create
            for i in range(bytes_to_create):
                word[i] = self.table[random.randint(33,126)]
            text = "".join(word)
            #print(str(hash(text))+"\t"+text)
            print(text)

def get_file_size_from_command_line():
    size = sys.argv[1]
    return size

def get_min_word_len_from_command_line():
    if len(sys.argv) > 2:
        low = sys.argv[2]
        return int(low)

def get_max_word_len_from_command_line():
    if len(sys.argv) > 3:
        high = sys.argv[3]
        return int(high)

def get_file_size_in_bytes(size):
    multiplier = 1
    size_unit = size[-1]

    if size_unit == 'M' or size_unit == 'm':
        multiplier = K_SIZE*K_SIZE
    elif size_unit == 'K' or size_unit == 'k':
        multiplier = K_SIZE
    elif size_unit == 'G' or size_unit == 'g':
        multiplier = K_SIZE*K_SIZE*K_SIZE
    elif size_unit in ('0','1','2','3','4','5','6','7','8','9'):
        multiplier = 1
    else:
        print("invalid size")
        exit()

    total_bytes = 0
    if multiplier == 1:
        total_bytes = int(size)
    else:
        total_bytes = multiplier*int(size[:len(size)-1])

    return total_bytes


def main():
    if len(sys.argv) == 2:
        gen = Generator()
    elif len(sys.argv) == 3:
        gen = Generator(get_min_word_len_from_command_line())
    elif len(sys.argv) == 4:
        gen = Generator(get_min_word_len_from_command_line(),get_max_word_len_from_command_line())
    file_size = get_file_size_in_bytes(get_file_size_from_command_line())
    gen.create_n_bytes(file_size)

if __name__== "__main__":
    main()

Answer 1

首先，如果要生成纯ASCII，并且需要尽可能快地生成，那么生成bytes可能要比生成str快。如果需要，您可以随时调用decode('ascii')，但更简单的是，直接将它们写到sys.stdout.buffer或sys.stdout.buffer.raw。
这意味着您可以去掉将数字映射到chr值的表，只需从int构造一个bytes或bytearray。（只要所有的值都在range(0, 128)中，就可以保证得到相同的结果，但是只有一个函数调用，其中包含一个C循环，而不是Python循环中的函数调用。）
另外，您可以调用random.choices(range(33, 127), k=N)并将结果传递给bytes构造函数，而不是构造一个N个空字符串的列表，然后逐个替换它们。
正如Dillon Davis所指出的，当我们在这里的时候，randint是相当慢的；通过手动执行相同的逻辑，您可以获得3-5倍的速度。这在这里没什么大不了的（我们只花了几百块钱就做了一块），但还是可以解决的。
所以，把这些放在一起：

def create_n_bytes(self,total_bytes):
    bytes_created = 0
    """Hack at the moment, this condition will fail only after more than n bytes are 
    written """
    chars = range(33, 127)
    while bytes_created < total_bytes:
        bytes_to_create = int(random.random() * (high-low+1) + low)
        word = bytes(random.choices(chars, k=bytes_to_create))
        bytes_created = bytes_created+bytes_to_create+1
        sys.stdout.buffer.write(word + b'\n')
    # necessary if you're doing any prints between calls
    sys.stdout.flush() 

另外，尝试在PyPy而不是CPython中运行相同的代码。它可能快5%，也可能快20倍。
如果您需要挤出更多的性能，所有常用的微观优化技巧都可能适用于此，比如在局部变量中隐藏 randint和 choices和 randint（或者 choices-尝试两种方法）。
如果它仍然不够快，你需要改变一些东西，一次生成更多的字节。
这意味着传递一个更大的 sys.stdout.buffer值，但也可能意味着在NumPy中拖动：

buf = np.random.randint(33, 127, size=total_bytes, dtype=np.uint8)

现在，如何将其分解为 sys.stdout.buffer.write到 total_bytes字节的单词？我想不出什么是真正聪明的，但是一个愚蠢的循环应该比上面所有的代码都快：

i = 0
while i < len(buf) - self.high:
    i += random.randint(self.low, self.high)
    buf[i] = 10 # newline
sys.stdout.buffer.write(buf.data[:i])

这次结束得太快而不是太过分。但不管你做什么，你显然都要处理好，不管你怎么做，你都要准确命中 low的几率，对吧？
（对 high返回的 total_bytes进行切片而不是对数组进行切片并对其调用 1/(high-low)有点老套，但考虑到我们创建数组的方式，它保证会执行相同的操作，而且可能会节省几微秒，因此可能值得使用注释。）
如果我们不介意浪费内存，我们可以构建一个随机偏移数组，该数组保证足够大（但可能太大），然后将其用作索引数组：

sizes = np.random.randint(self.low, self.high, total_bytes//self.low, dtype=np.int32)
offsets = np.cumsum(sizes)
last = np.searchsorted(offsets, 1000)
offsets = offsets[:last]
buf[offsets] = 10

这里的加速比1000字节的小数组要大得多，比如说，1MB的数组（由于额外的分配，它也可能对绝对庞大的数组不好），但它确实值得测试。
性能比较将在很大程度上取决于您的平台（包括您正在写入的终端，如果您没有重定向到 memoryview或 data），以及您选择的参数。
使用默认值 to_bytes()、 /dev/null和 NUL（我使用 low=4表示NumPy失败），在我的笔记本电脑上运行（macOS、iTerm中的IPython，而不是重定向stdout、CPython 3.7.0和pypypy 3.5.2/5.10），下面是我的结果：
原代码：2.7ms
PyPy原始代码：938微秒
带 high=10的我的版本：911微秒
带 total_bytes=1000:909微秒的我的版本
我的PyPy版本（不带 1010）：799微秒
NumPy回路版本：584微秒
只写一个预先存在的1000字节缓冲器：504秒
如果减去最后一个，得到不同算法的实时时间：
原代码：2.2ms
PyPy原始代码：434微秒
我的版本具有：407微秒
带 randint的我的版本：405微秒
我的PyPy版本（不带 random）：295微秒
NumPy回路版本：80微秒
我在另一台笔记本电脑上安装了NumPy random.choices/ randint版本，但与原来的NumPy版本进行了对比测试，stdout重定向到/dev/null：
NumPy回路版本：122微秒
NumPy random版本：41微秒
所以，这是一个3倍的速度比已经是27倍的速度快，所以我们在讨论80倍的速度。但是，写到终端的速度慢得足以使挂钟的速度只有5倍左右（如果你是在Windows上的话，可能会差得多）仍然不错。