这是对Anurak Uniyal的回应的一种理解，也是我自己在研究的东西。

import random
import string

oneFile = open('‪Numbers.txt', 'w')
userInput = 0
key_count = 0
value_count = 0
chars = string.ascii_uppercase + string.digits + string.punctuation

for userInput in range(int(input('How many 12 digit keys do you want?'))):
    while key_count <= userInput:
        key_count += 1
        number = random.randint(1, 999)
        key = number

        text = str(key) + ": " + str(''.join(random.sample(chars*6, 12)))
        oneFile.write(text + "\n")
oneFile.close()

只需使用Python的内置uuid：

如果uuid适合您的用途，请使用内置的uuid包。

单线解决方案：

导入uuid；uuid.uuid4（）.hhex.upper（）[0:6]

深度版本：

例子：

import uuid
uuid.uuid4() #uuid4 => full random uuid
# Outputs something like: UUID('0172fc9a-1dac-4414-b88d-6b9a6feb91ea')

如果您完全需要您的格式（例如，“6U1S75”），可以这样做：

import uuid

def my_random_string(string_length=10):
    """Returns a random string of length string_length."""
    random = str(uuid.uuid4()) # Convert UUID format to a Python string.
    random = random.upper() # Make all characters uppercase.
    random = random.replace("-","") # Remove the UUID '-'.
    return random[0:string_length] # Return the random string.

print(my_random_string(6)) # For example, D9E50C

面向安全的方法

我们对任何安全相关的建议都是避免“自己动手”，并使用经过专门安全审查的机密模块。

这来自文档的最佳实践部分：

import string
import secrets
alphabet = string.ascii_letters + string.digits
password = ''.join(secrets.choice(alphabet) for i in range(8))

由于您特别要求使用大写字母，因此您可以用ascii_capsaper替换ascii_cletters，或者只使用以下内容将密码大写：

password = password.upper()

不以安全为目的的标准方法

这个问题的规范方法（如指定）使用随机模块中的choices（）函数：

>>> from random import choices
>>> from string import ascii_uppercase, digits

>>> population = ascii_uppercase + digits
>>> str.join('', choices(population, k=6))
'6JWF1H'

一种无重复的随机生成器函数，使用一个集合来存储以前生成的值。注意，如果字符串或数量非常大，这将消耗一些内存，而且可能会稍微慢一点。发电机将在给定量或达到最大可能组合时停止。

代码：

#!/usr/bin/env python

from typing import Generator
from random import SystemRandom as RND
from string import ascii_uppercase, digits


def string_generator(size: int = 1, amount: int = 1) -> Generator[str, None, None]:
    """
    Return x random strings of a fixed length.

    :param size: string length, defaults to 1
    :type size: int, optional
    :param amount: amount of random strings to generate, defaults to 1
    :type amount: int, optional
    :yield: Yield composed random string if unique
    :rtype: Generator[str, None, None]
    """
    CHARS = list(ascii_uppercase + digits)
    LIMIT = len(CHARS) ** size
    count, check, string = 0, set(), ''
    while LIMIT > count < amount:
        string = ''.join(RND().choices(CHARS, k=size))
        if string not in check:
            check.add(string)
            yield string
            count += 1


for my_count, my_string in enumerate(string_generator(6, 20)):
    print(my_count, my_string)

输出：

0 RS9N3P
1 S0GDGR
2 ZNBLFV
3 96FF97
4 38JJZ3
5 Q3214A
6 VLWNK1
7 QMT05E
8 X1ZFP0
9 MZF442
10 10L9AZ
11 GE8HIQ
12 S7PA43
13 MVLXO9
14 YX7Y0G
15 GIIKPF
16 3KCUQA
17 XHIXFV
18 BJQ5VG
19 HQF01Q

如果字符串始终需要包含字母和数字，请使用以下命令：

#!/usr/bin/env python

from typing import Generator
from random import SystemRandom as RND
from string import ascii_uppercase, digits


def string_generator(size: int = 2, amount: int = 1) -> Generator[str, None, None]:
    """
    Return x random strings of a fixed length.

    :param size: string length, defaults to 1
    :type size: int, optional
    :param amount: amount of random strings to generate, defaults to 1
    :type amount: int, optional
    :yield: Yield composed random string if unique
    :rtype: Generator[str, None, None]
    """
    if size < 2:
        print(
            'Since the string must contain letters and numbers,',
            'its size must be at least two characters',
        )
        return
    CHARS = list(ascii_uppercase + digits)
    LIMIT = len(CHARS) ** size
    count, check, string = 0, set(), ''
    while LIMIT > count < amount:
        while 1:
            string = ''.join(RND().choices(CHARS, k=size))
            if not (string.isalpha() or string.isnumeric()):
                break
        if string not in check:
            check.add(string)
            yield string
            count += 1


for my_count, my_string in enumerate(string_generator(6, 20)):
    print(my_count, my_string)

输出：

0 5JIITL
1 3W7AI1
2 8QMO10
3 ETHAI8
4 BLFPP9
5 50X2CC
6 1LI8WA
7 39CKET
8 R4IM0E
9 Q3KHGS
10 65CBIU
11 XTRHO4
12 N2XIGO
13 06VFCW
14 VE9MJ8
15 A9ADHK
16 Y5ROJ0
17 OH7EJF
18 TQ709S
19 P0DDNJ

使用此代码可以快速生成一个重复的随机文本值字符串：

import string
import random

def id_generator(size=6, chars=string.ascii_uppercase + string.digits):
    return ''.join(random.choice(chars) for _ in range(size))

moja_lista = []
for a in range(20):
    moja_lista.append(id_generator(3, "3etrY"))

你会得到20个重复的随机文本值。生成器从集合“3etrY”集合生成三个组成元素。一切都可以根据您的喜好进行设置。

print(len(moja_lista))
moja_lista

两种方法：

import random, math

def randStr_1（字符：str，长度：int）->字符串：chars*=math.ceil（长度/长度（chars））chars=字母[0:length]chars=列表（chars）随机.洗牌（字符）返回“”.join（字符）def randStr_2（字符：str，长度：int）->字符串：返回“”.join（随机.选择（字符）用于范围（字符）中的i）基准：从timeit导入timeitsetup=“”导入操作系统，子流程，时间，字符串，随机，数学def randStr_1（字母：str，长度：int）->str：letters*=math.ceil（长度/长度（字母））letters=字母[0:长度]letters=列表（字母）随机洗牌（字母）return“”.join（字母）def randStr_2（字母：str，长度：int）->str：return“”.join（范围（长度）中i的随机选择（字母））"""打印（“方法1 vs方法2”，“，每次运行10次。”）长度为[101001000100005000010005001000000]：打印（长度，'字符：'）eff1=timeit（“randStr_1（string.asci_letters，｛｝）”.format（长度），setup=设置，数字=10）eff2=timeit（“randStr_2（string.ascii_letters，｛｝）”.format（长度），setup=setup，number=10）打印（“\t｛｝s：｛｝s”。格式（圆形（eff1，6），圆形（eff2，6）））print（'\tradio={}:{}\n'.格式（eff1/eff1，round（eff2/eff1，2）））输出：方法1与方法2，每次运行10次。100个字符：0.00141秒：0.00179秒比率=1.0:1.271000个字符：0.013857秒：0.017603秒比率=1.0:1.2710000个字符：0.13426秒：0.151169秒比率=1.0:1.1350000个字符：0.709403秒：0.855136秒比率=1.0:1.21100000个字符：1.360735秒：1.674584秒比率=1.0:1.23500000个字符：6.754923秒：7.160508秒比率=1.0:1.061000000个字符：11.232965秒：14.223914秒比率=1.0:1.27第一种方法的性能更好。