创建随机字母数组：Python 3

使用下面的函数可以更方便地创建随机整数数组

def generate_random_strings(x, i, j):

    return np.random.randint(0, 2, size=[x, i, j]).astype(np.float32)

print (generate_random_strings(3, 5, 4))

[[[0. 0. 0. 0.]
[0. 1. 1. 0.]
[0. 1. 1. 0.]
[0. 0. 0. 1.]
[0. 1. 0. 1.]]

[[0. 1. 0. 0.]
[1. 0. 1. 1.]
[0. 1. 1. 0.]
[1. 0. 1. 0.]
[0. 0. 0. 0.]]

[[0. 0. 1. 0.]
[1. 0. 1. 1.]
[0. 0. 0. 1.]
[0. 1. 0. 0.]
[1. 1. 0. 0.]]]

我试图为字母（a-z）而不是整数构建与上述类似的函数，但我无法从numpy或任何其他可用库中找到任何内置函数

所以我使用了3-for循环，如下所示

# Generate random letter
def randomword(len):
    return random.choice(string.ascii_lowercase)

x= 3
i= 5
j= 4

buf = []

for _ in range(x):
    bu = []
    for i in range(i):
        b = []
        for j in range(j):
            b.append(randomword(1))
        bu.append(b)
    buf.append(np.asarray(bu))

print(np.asarray(buf))

[[['u' 'w' 'w' 'x']
  ['b' 's' 'p' 'a']
  ['k' 'u' 'y' 'p']
  ['p' 'z' 'b' 'u']
  ['o' 'h' 'c' 'm']]

 [['t' 'y' 'b' 'r']
  ['e' 's' 'e' 't']
  ['p' 'n' 'd' 'w']
  ['h' 'f' 'i' 'e']
  ['o' 'b' 'q' 'r']]

 [['x' 'z' 'd' 'x']
  ['r' 'b' 'f' 'b']
  ['d' 'h' 'e' 'g']
  ['p' 'g' 'u' 'x']
  ['k' 'j' 'z' 'd']]]

---

所以，现在我的问题是，对于字符串/字母是否有任何函数作为

np.random.randint（）

，如果没有，是否有任何pythonic方法来减少（循环）代码长度。

您可以对所有ascii小写字母使用

numpy.choice

：

import string
import numpy as np

np.random.choice(list(string.ascii_lowercase),  size=(3, 5,4))

---

创建所需的任意多个随机字母，并将其重塑为numpy数组：

import numpy as np
import string
import random

def randomLetters(amount:int):
    return random.choices(string.ascii_lowercase, k=amount)    

i=5
j=4
x=3

d =  np.array(randomLetters(x*i*j)).reshape((x,i,j))

输出：

[
[
    ['e', 'y', 'y', 'a'],
    ['p', 'o', 'k', 'z'],
    ['j', 'p', 'n', 'p'],
    ['d', 'y', 'k', 's'],
    ['k', 'c', 'k', 'o']
],
[
    ['v', 'w', 't', 'a'],
    ['f', 'a', 't', 'm'],
    ['h', 'w', 'i', 'x'],
    ['a', 'w', 's', 'z'],
    ['x', 'f', 'b', 'b']
],
[
    ['x', 'f', 'm', 'y'],
    ['b', 'u', 'z', 's'],
    ['j', 'p', 'x', 'l'],
    ['a', 'p', 'b', 'i'],
    ['z', 's', 'v', 'k']
]
]

---

如果您想坚持使用numpy，可以使用

'S1'

数据类型，这只是长度为1字节的字符串。因此，

ord

与8位无符号整数对应。因此，您可以使用

numpy.random.randint

生成随机无符号8位整数，并将其转换为字节字符串：

注意，速度是原来的两倍，需要四分之一的内存：

In [8]: %timeit np.random.choice(list(string.ascii_lowercase),  size=(10, 10, 10))
24.8 µs ± 311 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [9]: %timeit np.random.randint(97, 123, (10, 10, 10), dtype=np.uint8).view('S1')
7.45 µs ± 95.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [10]: %timeit np.random.choice(list(string.ascii_lowercase),  size=(10, 100, 10))
116 µs ± 2.33 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [11]: %timeit np.random.randint(97, 123, (10, 100, 10), dtype=np.uint8).view('S1')
53.4 µs ± 641 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [12]: %timeit np.random.choice(list(string.ascii_lowercase),  size=(10, 100, 100))
993 µs ± 8.34 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [13]: %timeit np.random.randint(97, 123, (10, 100, 100), dtype=np.uint8).view('S1')
503 µs ± 6.13 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [14]: %timeit np.random.choice(list(string.ascii_lowercase),  size=(100, 100, 100))
9.99 ms ± 58.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [15]: %timeit np.random.randint(97, 123, (100, 100, 100), dtype=np.uint8).view('S1')
5.06 ms ± 129 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

---

chr（randint（97122））

numpy是否具有所有“正常”的随机模块方法？选择/选择似乎是一体的，那么sample或randint呢？@PatrickArtner See.注意，

list（string.ascii_小写）

不是必需的，你只需要

string.ascii_小写

就必须停止懒惰，搜索一些好的numpy tuts mumble谢谢@miradulo-这个链接很棒。#@juanpa.arrivillaga不，它应该是一个数组。虽然不太清晰，但速度可能会更快。用

np.dtype

包装有什么原因吗？@miradulo不知道你的意思。你是说“np.dtype（'S1'）”？嗯，您需要精确地定义数据类型

np.str

不起作用，而且不正确。对不起，我只是想删除

np.dtype

<代码>视图（'S1'）。。。数据类型是第一个参数。@miradulo啊，没有理由，只是我的第一个爱好。@miradulo是的，速度并不是我所信奉的主要优势，相反，它更有效地利用了空间。U1数据类型需要4个字节，而S1需要1个字节。因为

ord（'A'）

和

ord（'z'）

比97和122更不神奇，神奇的数字越少越好

>>> ord('a'), ord('z')
(97, 122)
>>> np.random.randint(97, 123, (3, 5, 4), dtype=np.uint8).view('S1')
array([[[b'p', b'q', b'b', b'x'],
        [b'm', b'x', b'e', b'f'],
        [b'u', b'h', b'e', b'd'],
        [b'o', b'n', b'w', b'v'],
        [b'z', b'q', b'g', b'e']],

       [[b'f', b'o', b'c', b'j'],
        [b'z', b'x', b'l', b'x'],
        [b'u', b'f', b'w', b'r'],
        [b'q', b'z', b'm', b'o'],
        [b't', b'e', b'm', b'e']],

       [[b'f', b'i', b'x', b'k'],
        [b'z', b'w', b'm', b'g'],
        [b't', b'f', b'u', b'q'],
        [b'e', b'w', b'w', b'r'],
        [b'e', b'q', b'a', b'g']]],
      dtype='|S1')

In [8]: %timeit np.random.choice(list(string.ascii_lowercase),  size=(10, 10, 10))
24.8 µs ± 311 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [9]: %timeit np.random.randint(97, 123, (10, 10, 10), dtype=np.uint8).view('S1')
7.45 µs ± 95.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [10]: %timeit np.random.choice(list(string.ascii_lowercase),  size=(10, 100, 10))
116 µs ± 2.33 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [11]: %timeit np.random.randint(97, 123, (10, 100, 10), dtype=np.uint8).view('S1')
53.4 µs ± 641 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [12]: %timeit np.random.choice(list(string.ascii_lowercase),  size=(10, 100, 100))
993 µs ± 8.34 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [13]: %timeit np.random.randint(97, 123, (10, 100, 100), dtype=np.uint8).view('S1')
503 µs ± 6.13 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [14]: %timeit np.random.choice(list(string.ascii_lowercase),  size=(100, 100, 100))
9.99 ms ± 58.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [15]: %timeit np.random.randint(97, 123, (100, 100, 100), dtype=np.uint8).view('S1')
5.06 ms ± 129 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)