脚本如何批量生成随机密码

本文目录导读：

1. Python 脚本（最灵活）
2. Bash Shell 脚本（Linux/Mac）
3. PowerShell 脚本（Windows）
4. 一键生成命令
5. 高级版本 - 可自定义规则
6. 使用建议

Python 脚本（最灵活）

import random
import string
import secrets
def generate_password(length=12):
    """生成单个随机密码"""
    # 定义字符集
    chars = string.ascii_letters + string.digits + "!@#$%^&*"
    # 使用 secrets 模块生成更安全的随机密码
    password = ''.join(secrets.choice(chars) for _ in range(length))
    return password
def batch_generate(count=10, length=12):
    """批量生成密码"""
    passwords = []
    for i in range(count):
        pw = generate_password(length)
        passwords.append(f"Password_{i+1}: {pw}")
    return passwords
# 生成 10 个 16 位的密码
result = batch_generate(10, 16)
for pw in result:
    print(pw)
# 保存到文件
with open('passwords.txt', 'w', encoding='utf-8') as f:
    f.write('\n'.join(result))

Bash Shell 脚本（Linux/Mac）

#!/bin/bash
# 批量生成随机密码
# 方法1：使用 /dev/urandom
generate_passwords() {
    local count=${1:-10}
    local length=${2:-16}
    for i in $(seq 1 $count); do
        # 从 /dev/urandom 读取并转换为可打印字符
        password=$(tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c $length)
        echo "Password_$i: $password"
    done
}
# 方法2：使用 openssl
generate_passwords_openssl() {
    local count=${1:-10}
    local length=${2:-16}
    for i in $(seq 1 $count); do
        password=$(openssl rand -base64 48 | head -c $length)
        echo "Password_$i: $password"
    done
}
# 生成 10 个 16 位密码
generate_passwords 10 16 > passwords.txt

PowerShell 脚本（Windows）

# 批量生成随机密码
function Generate-Password {
    param(
        [int]$Length = 12
    )
    # 定义字符集
    $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*'
    # 使用 .NET 的加密随机数生成器
    $rng = New-Object System.Security.Cryptography.RNGCryptoServiceProvider
    $bytes = [byte[]]::new($Length)
    $rng.GetBytes($bytes)
    $password = -join ($bytes | ForEach-Object {
        $chars[$_ % $chars.Length]
    })
    return $password
}
function Batch-Generate {
    param(
        [int]$Count = 10,
        [int]$Length = 12
    )
    $results = for ($i = 1; $i -le $Count; $i++) {
        $password = Generate-Password -Length $Length
        "Password_$i`: $password"
    }
    return $results
}
# 生成并保存
$passwords = Batch-Generate -Count 10 -Length 16
$passwords | Out-File -FilePath "passwords.txt" -Encoding UTF8

一键生成命令

Linux/Mac（单行命令）

# 生成10个16位密码
for i in {1..10}; do tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 16 && echo; done

Windows CMD

@echo off
:: 生成5个8位密码
for /L %%i in (1,1,5) do (
    set "pwd="
    for /L %%j in (1,1,8) do (
        set /a "r=!random! %% 62"
        for /F "tokens=!r!" %%a in ("a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9") do set "pwd=!pwd!%%a"
    )
    echo Password_%%i: !pwd!
)

高级版本 - 可自定义规则

import secrets
import string
import sys
class PasswordGenerator:
    def __init__(self):
        self.lowercase = string.ascii_lowercase
        self.uppercase = string.ascii_uppercase
        self.digits = string.digits
        self.special = "!@#$%^&*_-+=<>?"
    def generate(self, length=12, use_upper=True, use_lower=True, 
                 use_digits=True, use_special=True):
        """生成自定义规则的密码"""
        chars = ""
        if use_upper:
            chars += self.uppercase
        if use_lower:
            chars += self.lowercase
        if use_digits:
            chars += self.digits
        if use_special:
            chars += self.special
        if not chars:
            raise ValueError("至少需要选择一种字符类型")
        # 确保每种类型至少包含一个字符
        password = []
        if use_upper:
            password.append(secrets.choice(self.uppercase))
        if use_lower:
            password.append(secrets.choice(self.lowercase))
        if use_digits:
            password.append(secrets.choice(self.digits))
        if use_special:
            password.append(secrets.choice(self.special))
        # 填充剩余长度
        remaining = length - len(password)
        password.extend(secrets.choice(chars) for _ in range(remaining))
        # 打乱顺序
        secrets.SystemRandom().shuffle(password)
        return ''.join(password)
    def batch_generate(self, count=10, **kwargs):
        """批量生成"""
        return [self.generate(**kwargs) for _ in range(count)]
# 使用示例
gen = PasswordGenerator()
# 生成10个16位密码，包含所有字符类型
passwords = gen.batch_generate(count=10, length=16)
for i, pw in enumerate(passwords, 1):
    print(f"Password_{i}: {pw}")

使用建议

1. 安全考虑：使用 secrets 或 /dev/urandom 而非随机模块
2. 长度建议：至少12位，推荐16位以上
3. 字符组合：包含大写、小写、数字和特殊字符
4. 存储安全：生成后立即加密保存，处理后删除临时文件
5. 避免冲突：可添加检查重复的机制

选择最适合你的使用场景的方法即可！