如何生成一个不以 0 开头且具有唯一数字的随机 4 位数字？
How to generate a random 4 digit number not starting with 0 and having unique digits?
这几乎可以正常工作，但数字有时以 0 开头：
import random
numbers = random.sample(range(10), 4)
print(''.join(map(str, numbers)))
我找到了很多示例，但其中 none 保证序列不会以 0 开头。
您可以对 3 个数字使用全范围，然后在剩余数字中选择前导数字：
import random
numbers = random.sample(range(0,10), 3)
first_number = random.choice(list(set(range(1,10))-set(numbers)))
print(''.join(map(str, [first_number]+numbers)))
如果需要重复选择（并且如果您在位数上保持合理），另一种方法是使用 itertools.permutations 预先计算可能的输出列表，过滤掉那些一个前导零，并从中构建一个整数列表：
import itertools,random
l = [int(''.join(map(str,x))) for x in itertools.permutations(range(10),4) if x[0]]
这是一些计算时间，但之后您可以调用：
random.choice(l)
次数不限。它非常快并且提供均匀分布的随机数。
这将在第一个数字后允许零 -
numbers = random.sample(range(1,10),1) + random.sample(range(10),3)
循环直到你有你喜欢的东西：
import random
numbers = [0]
while numbers[0] == 0:
numbers = random.sample(range(10), 4)
print(''.join(map(str, numbers)))
拒绝抽样法。从 10 位数字中创建一个 4 位数字的随机组合，如果不符合条件，则重新采样。
r4=0
while r4 < 1000:
r4=int(''.join(map(str,random.sample(range(10),4))))
注意到这与@Austin Haskings 的
基本相同
我们生成 1 - 9 范围内的第一个数字，然后从剩余数字中取出接下来的 3 个数字：
import random
# We create a set of digits: {0, 1, .... 9}
digits = set(range(10))
# We generate a random integer, 1 <= first <= 9
first = random.randint(1, 9)
# We remove it from our set, then take a sample of
# 3 distinct elements from the remaining values
last_3 = random.sample(digits - {first}, 3)
print(str(first) + ''.join(map(str, last_3)))
生成的数字是等概率的，我们一步得到一个有效数字。
这与其他答案非常相似，但您可以在 1000-9999 范围内抽取一个随机整数，而不是 sample 或 shuffle，直到您得到一个仅包含唯一数字的整数：
import random
val = 0 # initial value - so the while loop is entered.
while len(set(str(val))) != 4: # check if it's duplicate free
val = random.randint(1000, 9999)
print(val)
正如@Claudio 在评论中指出的那样，范围实际上只需要是 1023 - 9876，因为该范围之外的值包含重复数字。
通常 random.randint 会比 random.shuffle 或 random.choice 快得多，所以即使它更有可能需要绘制多次（正如@karakfa 指出的那样），这取决于比任何 shuffle、choice 还需要 join 个位数的方法快 3 倍。
[已修复] 将所有四位数字移到一个位置不正确。用固定位置交换前导零也不对。但是前导零与九个位置中的任何一个的随机交换是正确的并且给出相等的概率：
""" Solution: randomly shuffle all numbers. If 0 is on the 0th position,
randomly swap it with any of nine positions in the list.
Proof
Lets count probability for 0 to be in position 7. It is equal to probability 1/10
after shuffle, plus probability to be randomly swapped in the 7th position if
0 come to be on the 0th position: (1/10 * 1/9). In total: (1/10 + 1/10 * 1/9).
Lets count probability for 3 to be in position 7. It is equal to probability 1/10
after shuffle, minus probability to be randomly swapped in the 0th position (1/9)
if 0 come to be on the 0th position (1/10) and if 3 come to be on the 7th position
when 0 is on the 0th position (1/9). In total: (1/10 - 1/9 * 1/10 * 1/9).
Total probability of all numbers [0-9] in position 7 is:
9 * (1/10 - 1/9 * 1/10 * 1/9) + (1/10 + 1/10 * 1/9) = 1
Continue to prove in the same way that total probability is equal to
1 for all other positions.
End of proof. """
import random
l = [0,1,2,3,4,5,6,7,8,9]
random.shuffle(l)
if l[0] == 0:
pos = random.choice(range(1, len(l)))
l[0], l[pos] = l[pos], l[0]
print(''.join(map(str, l[0:4])))
我不太了解Python，但有点像
digits=[1,2,3,4,5,6,7,8,9] <- no zero
random.shuffle(digits)
first=digits[0] <- first digit, obviously will not be zero
digits[0]=0 <- used digit can not occur again, zero can
random.shuffle(digits)
lastthree=digits[0:3] <- last three digits, no repeats, can contain zero, thanks @Dubu
一个更有用的迭代，实际上创建了一个数字：
digits=[1,2,3,4,5,6,7,8,9] # no zero
random.shuffle(digits)
val=digits[0] # value so far, not zero for sure
digits[0]=0 # used digit can not occur again, zero becomes a valid pick
random.shuffle(digits)
for i in range(0,3):
val=val*10+digits[i] # update value with further digits
print(val)
从其他解决方案中窃取部分内容后，加上来自@DavidHammen 的技巧：
val=random.randint(1,9)
digits=[1,2,3,4,5,6,7,8,9]
digits[val-1]=0
for i in random.sample(digits,3):
val=val*10+i
print(val)
我不知道 Python 所以我会 post 针对这个特定问题的伪代码解决方案：
创建一个包含从 0 开始的数字列表的查找变量：
lu = [1, 2, 3, 4, 5, 6, 7, 8, 9]
生成四个从0开始的随机数如下：
r1 = random number between 0 and 8
r2 = random number between 0 and 8
r3 = random number between 0 and 7
r4 = random number between 0 and 6
使用查找变量将随机数一位一位地转换为数字。每次查找后，通过删除已使用的数字来改变查找变量：
d1 = lu[r1]
lu.remove(d1)
lu.insert(0)
d2 = lu[r2]
lu.remove(d2)
d3 = lu[r3]
lu.remove(d3)
d4 = lu[r4]
lu.remove(d4)
打印结果：
print concatenate(d1, d2, d3, d4)
可以稍微概括一下这个想法。例如，您可以创建一个接受列表（数字）和数字（所需结果长度）的函数；该函数将 return 数字并通过删除用完的数字来改变列表。下面是此解决方案的 JavaScript 实现：
function randomCombination(list, length) {
var i, rand, result = "";
for (i = 0; i < length; i++) {
rand = Math.floor(Math.random() * list.length);
result += list[rand];
list.splice(rand, 1);
}
return result;
}
function desiredNumber() {
var list = [1, 2, 3, 4, 5, 6, 7, 8, 9],
result;
result = randomCombination(list, 1);
list.push(0);
result += randomCombination(list, 3);
return result;
}
var i;
for (i = 0; i < 10; i++) {
console.log(desiredNumber());
}
这是我的做法
while True:
n = random.randrange(1000, 10000)
if len(set(str(n))) == 4: # unique digits
return n
更一般地说，给定一个生成器，您可以使用内置函数 filter and next 来获取满足某个测试函数的第一个元素。
numbers = iter(lambda: random.randrange(1000, 10000), None) # infinite generator
test = lambda n: len(set(str(n))) == 4
return next(filter(test, numbers))
将生成器与 next
合并
Pythonic 的编写方式是使用 2 个嵌套生成器和 next:
from random import randint
from itertools import count
print(next(i for i in (randint(1023, 9876) for _ in count()) if len(set(str(i))) == 4))
# 8756
它基本上是
的单行变体
预处理所有可接受的数字
如果您需要很多随机数，您可以投入一些时间和内存来预处理所有可接受的数字：
import random
possible_numbers = [i for i in range(1023, 9877) if len(set(str(i))) == 4]
1023 和 9877 用作边界，因为任何小于 1023 或大于 9876 的整数都不能有 4 个唯一的、不同的数字。
那么，您只需要 random.choice 即可快速生成：
print(random.choice(possible_numbers))
# 7234
免责声明：这是一种糟糕的反Python方法，严格针对基准测试部分（参见@DavidHammen 的评论，以及 http://ideone.com/qyopLF）
这个想法是一步生成数字的序列号，然后修复任何冲突：
rnd=random.randint(0,4535)
(rnd,d1)=divmod(rnd,9)
(rnd,d2)=divmod(rnd,9)
#(rnd,d3)=divmod(rnd,8)
#(rnd,d4)=divmod(rnd,7)
(d4,d3)=divmod(rnd,8) # miracle found: 1 divmod happens to run faster than 2
现在我们有 d1=0..8、d2=0..8、d3=0..7、d4=0..6，可以通过 运行 带有 rnd 的代码片段进行测试=4535 (4535=9*9*8*7-1,顺便)
首先，d1需要修补
d1=d1+1 # now d1 = 1..9
然后 d2 必须 "skip" d1 如有必要
if d2>=d1
d2=d2+1 # now d2 = 0..9 "-" d1
然后对剩下的数字也做同样的事情，很快就变丑了:
if d3>=d1:
d3=d3+1 # now d3 = 0..8 "-" d1
if d3>=d2:
d3=d3+1 # now d3 = 0..9 "-" {d1,d2}
elif d3>=d2: # this branch prepares for the other variant
d3=d3+1
if d3>=d1: # ">=" is preserved for consistency, here "==" may occur only
d3=d3+1
最后一部分是灾难性的：
if d4>=d1:
d4=d4+1
if d4>=d2:
d4=d4+1
if d4>=d3:
d4=d4+1
elif d4>=d3:
d4=d4+1
if d4>=d2:
d4=d4+1
elif d4>=d2:
d4=d4+1
if d4>=d1:
d4=d4+1
if d4>=d3:
d4=d4+1
elif d4>=d3:
d4=d4+1
if d4>=d1:
d4=d4+1
elif d4>=d3:
d4=d4+1
if d4>=d2:
d4=d4+1
if d4>=d1:
d4=d4+1
elif d4>=d1:
d4=d4+1
if d4>=d2:
d4=d4+1
对于更长的数字，使用位域可能会更快，但我看不出有什么简单的方法。
（只检查一次 >= 关系是不够的，因为在递增后很容易发生碰撞。
例如d1=1, d2=2, d3=1：d3与d1碰撞，但最初不与d2碰撞。然而，在 "puching the hole" 为 1 之后，d3 变为 2，现在它与 d2 发生碰撞。没有简单的方法可以提前发现这种碰撞）
由于代码太臭了，我在最后放了一个验证步骤
val = d1*1000 + d2*100 + d3*10 + d4
#if len(set(str(val))) != 4: print(str(val)+" "+str(o1)+","+str(o2)+","+str(o3)+","+str(o4))
if len(set(str(val))) != 4: print(val)
它已经比其他真正快速的代码快了（注释验证显示了 divmod-s 之后保留的原始数字，用于调试目的。这不是那种立即工作的代码。 ..).评论这两个验证会使它更快。
编辑：关于检查这个和那个
这是一种在最小有效输入集 (0...4535) 和有效输出（9*9*8*7 可能的 4 位数字，具有不同的数字）之间保持 1:1 关系的方法数字，不以 0 开头）。因此，一个简单的循环可以而且应该生成所有数字，可以一个一个地检查它们，并且可以将它们收集到一个集合中，例如为了查看它们是否都是不同的结果
实际上：
collect=set()
for rnd in range(0,4536):
(rnd,d1)=divmod(rnd,9)
... rest of the code, also the verification step kept active ...
collect.add(val)
print(len(collect))
1) 它不会在循环中打印任何东西（所有结果都是具有不同数字的 4 位数字）
2)最后会打印4536（所有结果都不一样）
可以为第一个数字 (d1) 添加验证，这里和现在我只是假设
"(something mod 9)+1" 不会是 0。
这几乎可以正常工作，但数字有时以 0 开头：
import random
numbers = random.sample(range(10), 4)
print(''.join(map(str, numbers)))
我找到了很多示例，但其中 none 保证序列不会以 0 开头。
您可以对 3 个数字使用全范围，然后在剩余数字中选择前导数字：
import random
numbers = random.sample(range(0,10), 3)
first_number = random.choice(list(set(range(1,10))-set(numbers)))
print(''.join(map(str, [first_number]+numbers)))
如果需要重复选择（并且如果您在位数上保持合理），另一种方法是使用 itertools.permutations 预先计算可能的输出列表，过滤掉那些一个前导零，并从中构建一个整数列表：
import itertools,random
l = [int(''.join(map(str,x))) for x in itertools.permutations(range(10),4) if x[0]]
这是一些计算时间，但之后您可以调用：
random.choice(l)
次数不限。它非常快并且提供均匀分布的随机数。
这将在第一个数字后允许零 -
numbers = random.sample(range(1,10),1) + random.sample(range(10),3)
循环直到你有你喜欢的东西：
import random
numbers = [0]
while numbers[0] == 0:
numbers = random.sample(range(10), 4)
print(''.join(map(str, numbers)))
拒绝抽样法。从 10 位数字中创建一个 4 位数字的随机组合，如果不符合条件，则重新采样。
r4=0
while r4 < 1000:
r4=int(''.join(map(str,random.sample(range(10),4))))
注意到这与@Austin Haskings 的
我们生成 1 - 9 范围内的第一个数字，然后从剩余数字中取出接下来的 3 个数字：
import random
# We create a set of digits: {0, 1, .... 9}
digits = set(range(10))
# We generate a random integer, 1 <= first <= 9
first = random.randint(1, 9)
# We remove it from our set, then take a sample of
# 3 distinct elements from the remaining values
last_3 = random.sample(digits - {first}, 3)
print(str(first) + ''.join(map(str, last_3)))
生成的数字是等概率的，我们一步得到一个有效数字。
这与其他答案非常相似，但您可以在 1000-9999 范围内抽取一个随机整数，而不是 sample 或 shuffle，直到您得到一个仅包含唯一数字的整数：
import random
val = 0 # initial value - so the while loop is entered.
while len(set(str(val))) != 4: # check if it's duplicate free
val = random.randint(1000, 9999)
print(val)
正如@Claudio 在评论中指出的那样，范围实际上只需要是 1023 - 9876，因为该范围之外的值包含重复数字。
通常 random.randint 会比 random.shuffle 或 random.choice 快得多，所以即使它更有可能需要绘制多次（正如@karakfa 指出的那样），这取决于比任何 shuffle、choice 还需要 join 个位数的方法快 3 倍。
[已修复] 将所有四位数字移到一个位置不正确。用固定位置交换前导零也不对。但是前导零与九个位置中的任何一个的随机交换是正确的并且给出相等的概率：
""" Solution: randomly shuffle all numbers. If 0 is on the 0th position,
randomly swap it with any of nine positions in the list.
Proof
Lets count probability for 0 to be in position 7. It is equal to probability 1/10
after shuffle, plus probability to be randomly swapped in the 7th position if
0 come to be on the 0th position: (1/10 * 1/9). In total: (1/10 + 1/10 * 1/9).
Lets count probability for 3 to be in position 7. It is equal to probability 1/10
after shuffle, minus probability to be randomly swapped in the 0th position (1/9)
if 0 come to be on the 0th position (1/10) and if 3 come to be on the 7th position
when 0 is on the 0th position (1/9). In total: (1/10 - 1/9 * 1/10 * 1/9).
Total probability of all numbers [0-9] in position 7 is:
9 * (1/10 - 1/9 * 1/10 * 1/9) + (1/10 + 1/10 * 1/9) = 1
Continue to prove in the same way that total probability is equal to
1 for all other positions.
End of proof. """
import random
l = [0,1,2,3,4,5,6,7,8,9]
random.shuffle(l)
if l[0] == 0:
pos = random.choice(range(1, len(l)))
l[0], l[pos] = l[pos], l[0]
print(''.join(map(str, l[0:4])))
我不太了解Python，但有点像
digits=[1,2,3,4,5,6,7,8,9] <- no zero
random.shuffle(digits)
first=digits[0] <- first digit, obviously will not be zero
digits[0]=0 <- used digit can not occur again, zero can
random.shuffle(digits)
lastthree=digits[0:3] <- last three digits, no repeats, can contain zero, thanks @Dubu
一个更有用的迭代，实际上创建了一个数字：
digits=[1,2,3,4,5,6,7,8,9] # no zero
random.shuffle(digits)
val=digits[0] # value so far, not zero for sure
digits[0]=0 # used digit can not occur again, zero becomes a valid pick
random.shuffle(digits)
for i in range(0,3):
val=val*10+digits[i] # update value with further digits
print(val)
从其他解决方案中窃取部分内容后，加上来自@DavidHammen 的技巧：
val=random.randint(1,9)
digits=[1,2,3,4,5,6,7,8,9]
digits[val-1]=0
for i in random.sample(digits,3):
val=val*10+i
print(val)
我不知道 Python 所以我会 post 针对这个特定问题的伪代码解决方案：
创建一个包含从 0 开始的数字列表的查找变量：
lu = [1, 2, 3, 4, 5, 6, 7, 8, 9]生成四个从0开始的随机数如下：
r1 = random number between 0 and 8 r2 = random number between 0 and 8 r3 = random number between 0 and 7 r4 = random number between 0 and 6使用查找变量将随机数一位一位地转换为数字。每次查找后，通过删除已使用的数字来改变查找变量：
d1 = lu[r1] lu.remove(d1) lu.insert(0) d2 = lu[r2] lu.remove(d2) d3 = lu[r3] lu.remove(d3) d4 = lu[r4] lu.remove(d4)打印结果：
print concatenate(d1, d2, d3, d4)
可以稍微概括一下这个想法。例如，您可以创建一个接受列表（数字）和数字（所需结果长度）的函数；该函数将 return 数字并通过删除用完的数字来改变列表。下面是此解决方案的 JavaScript 实现：
function randomCombination(list, length) {
var i, rand, result = "";
for (i = 0; i < length; i++) {
rand = Math.floor(Math.random() * list.length);
result += list[rand];
list.splice(rand, 1);
}
return result;
}
function desiredNumber() {
var list = [1, 2, 3, 4, 5, 6, 7, 8, 9],
result;
result = randomCombination(list, 1);
list.push(0);
result += randomCombination(list, 3);
return result;
}
var i;
for (i = 0; i < 10; i++) {
console.log(desiredNumber());
}
这是我的做法
while True:
n = random.randrange(1000, 10000)
if len(set(str(n))) == 4: # unique digits
return n
更一般地说，给定一个生成器，您可以使用内置函数 filter and next 来获取满足某个测试函数的第一个元素。
numbers = iter(lambda: random.randrange(1000, 10000), None) # infinite generator
test = lambda n: len(set(str(n))) == 4
return next(filter(test, numbers))
将生成器与 next
合并
Pythonic 的编写方式是使用 2 个嵌套生成器和 next:
from random import randint
from itertools import count
print(next(i for i in (randint(1023, 9876) for _ in count()) if len(set(str(i))) == 4))
# 8756
它基本上是
预处理所有可接受的数字
如果您需要很多随机数，您可以投入一些时间和内存来预处理所有可接受的数字：
import random
possible_numbers = [i for i in range(1023, 9877) if len(set(str(i))) == 4]
1023 和 9877 用作边界，因为任何小于 1023 或大于 9876 的整数都不能有 4 个唯一的、不同的数字。
那么，您只需要 random.choice 即可快速生成：
print(random.choice(possible_numbers))
# 7234
免责声明：这是一种糟糕的反Python方法，严格针对基准测试部分（参见@DavidHammen 的评论，以及 http://ideone.com/qyopLF） 这个想法是一步生成数字的序列号，然后修复任何冲突：
rnd=random.randint(0,4535)
(rnd,d1)=divmod(rnd,9)
(rnd,d2)=divmod(rnd,9)
#(rnd,d3)=divmod(rnd,8)
#(rnd,d4)=divmod(rnd,7)
(d4,d3)=divmod(rnd,8) # miracle found: 1 divmod happens to run faster than 2
现在我们有 d1=0..8、d2=0..8、d3=0..7、d4=0..6，可以通过 运行 带有 rnd 的代码片段进行测试=4535 (4535=9*9*8*7-1,顺便)
首先，d1需要修补
d1=d1+1 # now d1 = 1..9
然后 d2 必须 "skip" d1 如有必要
if d2>=d1
d2=d2+1 # now d2 = 0..9 "-" d1
然后对剩下的数字也做同样的事情，很快就变丑了:
if d3>=d1:
d3=d3+1 # now d3 = 0..8 "-" d1
if d3>=d2:
d3=d3+1 # now d3 = 0..9 "-" {d1,d2}
elif d3>=d2: # this branch prepares for the other variant
d3=d3+1
if d3>=d1: # ">=" is preserved for consistency, here "==" may occur only
d3=d3+1
最后一部分是灾难性的：
if d4>=d1:
d4=d4+1
if d4>=d2:
d4=d4+1
if d4>=d3:
d4=d4+1
elif d4>=d3:
d4=d4+1
if d4>=d2:
d4=d4+1
elif d4>=d2:
d4=d4+1
if d4>=d1:
d4=d4+1
if d4>=d3:
d4=d4+1
elif d4>=d3:
d4=d4+1
if d4>=d1:
d4=d4+1
elif d4>=d3:
d4=d4+1
if d4>=d2:
d4=d4+1
if d4>=d1:
d4=d4+1
elif d4>=d1:
d4=d4+1
if d4>=d2:
d4=d4+1
对于更长的数字，使用位域可能会更快，但我看不出有什么简单的方法。 （只检查一次 >= 关系是不够的，因为在递增后很容易发生碰撞。 例如d1=1, d2=2, d3=1：d3与d1碰撞，但最初不与d2碰撞。然而，在 "puching the hole" 为 1 之后，d3 变为 2，现在它与 d2 发生碰撞。没有简单的方法可以提前发现这种碰撞）
由于代码太臭了，我在最后放了一个验证步骤
val = d1*1000 + d2*100 + d3*10 + d4
#if len(set(str(val))) != 4: print(str(val)+" "+str(o1)+","+str(o2)+","+str(o3)+","+str(o4))
if len(set(str(val))) != 4: print(val)
它已经比其他真正快速的代码快了（注释验证显示了 divmod-s 之后保留的原始数字，用于调试目的。这不是那种立即工作的代码。 ..).评论这两个验证会使它更快。
编辑：关于检查这个和那个
这是一种在最小有效输入集 (0...4535) 和有效输出（9*9*8*7 可能的 4 位数字，具有不同的数字）之间保持 1:1 关系的方法数字，不以 0 开头）。因此，一个简单的循环可以而且应该生成所有数字，可以一个一个地检查它们，并且可以将它们收集到一个集合中，例如为了查看它们是否都是不同的结果
实际上：
collect=set()
for rnd in range(0,4536):
(rnd,d1)=divmod(rnd,9)
... rest of the code, also the verification step kept active ...
collect.add(val)
print(len(collect))
1) 它不会在循环中打印任何东西（所有结果都是具有不同数字的 4 位数字）
2)最后会打印4536（所有结果都不一样）
可以为第一个数字 (d1) 添加验证，这里和现在我只是假设
"(something mod 9)+1" 不会是 0。