Introdução ao Módulo random do Python! Como Gerar Valores Aleatórios com Código de Copiar e Colar

Para executar Python no prompt de comando ou PowerShell no seu PC, é necessário baixar e instalar o Python.
Se ainda não o fez, consulte o artigo Instalação do Python e configuração do ambiente de desenvolvimento para instalar o Python.

Olá! Você já quis adicionar um pouco de dinamismo ou imprevisibilidade ao seu site? Por exemplo, mudando a imagem exibida a cada visita, mostrando artigos recomendados aleatoriamente ou gerando muitos dados fictícios durante o desenvolvimento.

Para alcançar essa "aleatoriedade", o Python oferece uma biblioteca padrão muito conveniente chamada de módulo random. Como é uma biblioteca padrão, nenhuma instalação adicional é necessária se você tiver o Python, tornando-a uma aliada confiável para criadores da web.

Neste artigo, explicaremos detalhadamente como usar o módulo random do Python, do básico às aplicações, com muitos exemplos de código, para que até mesmo os criadores da web iniciantes possam começar a usá-lo imediatamente. Todo o código de exemplo foi projetado para funcionar perfeitamente com apenas um copiar e colar. Ao "apenas experimentar", você pode vivenciar a diversão e a conveniência da geração de números aleatórios!

Preparação: Importando o Módulo random

Primeiramente, para usar os recursos do módulo random, você precisa importá-lo no início do seu script Python. É muito simples; você só precisa escrever a seguinte linha.

import random

# A partir deste ponto, você pode usar os recursos do módulo random.
print("O módulo random foi importado!")

Agora você está pronto para chamar várias funções dentro do módulo usando o formato random.nome_da_funcao(). Vamos dar uma olhada em algumas das funções mais comuns, uma por uma.

Parte 1: Gerando Inteiros Aleatórios (randint, randrange)

Um dos recursos mais usados é a geração de um número inteiro aleatório dentro de um intervalo especificado. Isso é muito útil em muitas situações em que você precisa de um número inteiro aleatório, como "um número de 1 a 6 (um lançamento de dado 🎲)" ou "uma pontuação de teste de 100 a 200."

Obter um inteiro em um intervalo especificado: random.randint()

random.randint(a, b) retorna um inteiro aleatório entre os dois números `a` e `b` passados como argumentos. Um ponto importante é que este intervalo é inclusivo de ambos a e b (maior ou igual a a e menor ou igual a b).

Exemplo: Um inteiro aleatório de 1 a 6 (um lançamento de dado)

import random

# Gerar um inteiro aleatório de 1 a 6 (inclusive)
resultado_dado = random.randint(1, 6)

print(f"O resultado do dado é: {resultado_dado}")

Use-o como range(): random.randrange()

random.randrange() também gera inteiros, mas funciona exatamente como a função padrão range() do Python. Por esse motivo, pode parecer mais intuitivo para os programadores.

• randrange(stop): Um inteiro de 0 até, mas não incluindo, stop.
• randrange(start, stop): Um inteiro de start até, mas não incluindo, stop.
• randrange(start, stop, step): Um inteiro do intervalo de start a stop, com um intervalo de step.

Diferente de randint(a, b), note que o valor final (stop) não está incluído no intervalo.

Exemplo: Um inteiro aleatório de 0 a 9 (10 não está incluído)

import random

# Gerar um inteiro aleatório de 0 até (mas não incluindo) 10
# Mesma lógica que range(10)
numero = random.randrange(10)

print(f"Um número aleatório de 0 a 9: {numero}")

O verdadeiro poder do randrange() é demonstrado quando você quer gerar números aleatórios com um passo (intervalo) específico. Por exemplo, você pode especificar "apenas números pares" ou "apenas múltiplos de 5."

Exemplo: Um múltiplo de 5 aleatório de 10 a 100

import random

# Começar em 10, até (mas não incluindo) 101, com um passo de 5
# Os candidatos são 10, 15, 20, ..., 100
multiplo_de_cinco = random.randrange(10, 101, 5)

print(f"Um múltiplo de 5 aleatório de 10 a 100: {multiplo_de_cinco}")

Parte 2: Escolhendo Elementos de uma Lista (choice, choices, sample)

Este é um recurso muito útil para situações como "exibir um artigo aleatório de uma lista de artigos recomendados" ou "exibir algumas imagens de banner selecionadas de várias" em um site. Ele extrai elementos de uma coleção (sequência) como uma lista ou tupla.

Escolher apenas um: random.choice()

random.choice(seq) escolhe apenas um elemento aleatório de uma sequência como uma lista ou tupla. É uma função simples e muito fácil de usar.

Exemplo: Escolhendo uma sorte de um papel da sorte

import random

sortes = ["Grande Sorte", "Sorte Média", "Pequena Sorte", "Sorte", "Azar", "Grande Azar"]

# Escolher um elemento aleatório da lista
resultado = random.choice(sortes)

print(f"A sua sorte de hoje é... {resultado}!")

Escolher múltiplos com reposição: random.choices()

random.choices(population, k=n) escolhe múltiplos elementos de uma lista. O ponto importante é que ele permite duplicatas (amostragem com reposição). Isso significa que um elemento que foi escolhido uma vez pode ser escolhido novamente. Você especifica o número de elementos a serem escolhidos com k.

Exemplo: Uma simulação de jogar uma moeda 10 vezes (Cara e Coroa são escolhidas com reposição)

import random

lados_moeda = ["Cara", "Coroa"]

# Escolher 10 vezes de lados_moeda com reposição (k=10)
resultados = random.choices(lados_moeda, k=10)

print(f"Resultados do lançamento da moeda: {resultados}")
print(f"Número de Caras: {resultados.count('Cara')}")
print(f"Número de Coroas: {resultados.count('Coroa')}")

Além disso, choices() permite que você especifique weights (pesos), o que pode alterar a probabilidade de cada elemento ser escolhido. Isso é muito útil para situações em que você deseja manipular probabilidades, como no recurso de gacha de um jogo.

Exemplo: Uma simulação de um sistema de gacha onde itens de alta raridade são menos prováveis de aparecer

import random

itens = ["Super Raro SSR+", "SSR", "SR", "R", "N"]
#         Probabilidade:  0.5%,      3%,   15%,  30%, 51.5% pesos correspondentes
pesos = [0.5,       3,    15,    30,   51.5]

# Sortear 10 vezes considerando os pesos
resultados_gacha = random.choices(itens, weights=pesos, k=10)

print(f"Resultados do gacha de 10 sorteios: {resultados_gacha}")

Escolher múltiplos sem reposição: random.sample()

random.sample(population, k) escolhe múltiplos elementos de uma lista sem duplicatas (amostragem sem reposição). É ideal para situações como "sortear 3 vencedores de uma lista de participantes sem duplicatas" ou "garantir que os artigos relacionados exibidos não se sobreponham."

Exemplo: Sortear 2 vencedores de 5 usuários

import random

usuarios = ["UsuarioA", "UsuarioB", "UsuarioC", "UsuarioD", "UsuarioE"]

# Escolher 2 pessoas da lista de usuários sem duplicatas (k=2)
vencedores = random.sample(usuarios, k=2)

print(f"Parabéns aos vencedores!: {vencedores}")

Parte 3: Embaralhando a Ordem de uma Lista (shuffle)

Se você quer reordenar aleatoriamente os elementos de uma lista existente, use random.shuffle(x).

Como um ponto de atenção, shuffle() não retorna uma nova lista, mas modifica a lista original diretamente (operação in-place). Portanto, se você quiser manter a ordem original, deve usá-lo após copiar a lista.

Exemplo: Embaralhando um baralho de cartas

import random

cartas = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
print(f"Antes de embaralhar: {cartas}")

# Reordenar aleatoriamente a própria lista de cartas
random.shuffle(cartas)

print(f"Depois de embaralhar: {cartas}")

Se você quer obter uma "nova" lista embaralhada, mantendo a lista original, é fácil usar o já mencionado random.sample(). Se você especificar o número total de elementos da lista para k, obterá como resultado uma nova lista embaralhada.

Exemplo: Obter uma lista embaralhada mantendo a lista original

import random

lista_original = [1, 2, 3, 4, 5]

# Amostrar tantos itens quanto o comprimento da lista original
lista_embaralhada = random.sample(lista_original, k=len(lista_original))

print(f"Lista original (inalterada): {lista_original}")
print(f"Nova lista embaralhada: {lista_embaralhada}")

Parte 4: Gerando Números de Ponto Flutuante Aleatórios (random, uniform)

Você pode gerar não apenas inteiros, mas também números aleatórios que incluem um ponto decimal (números de ponto flutuante). Isso pode ser usado para parâmetros de animação ou para calcular proporções em testes A/B.

Um valor entre 0.0 e 1.0: random.random()

random.random() é a função mais básica para gerar decimais, retornando um número de ponto flutuante aleatório que é maior ou igual a 0.0 e menor que 1.0 ($0.0 \le N < 1.0$). Não requer argumentos.

Exemplo: Gerando um número de ponto flutuante aleatório

import random

valor = random.random()
print(f"Valor gerado: {valor}")

# Exemplo de exibir "Sucesso!" com uma probabilidade de 70%
if valor < 0.7:
    print("Sucesso com uma probabilidade de 70%!")
else:
    print("Que pena, falhou...")

Um decimal em um intervalo especificado: random.uniform()

Se você quer um decimal dentro de um intervalo específico, use random.uniform(a, b). Isso retorna um número de ponto flutuante aleatório que é maior ou igual a a e menor ou igual a b ($a \le N \le b$).

Exemplo: Gerando um decimal aleatório de -1.0 a 1.0

import random

# Gerar um decimal aleatório de -1.0 a 1.0
decimal_aleatorio = random.uniform(-1.0, 1.0)

print(f"Decimal gerado: {decimal_aleatorio}")

# Se você quiser exibi-lo com 3 casas decimais
print(f"Com 3 casas decimais: {decimal_aleatorio:.3f}")

Aplicações: Exemplos Práticos para Produção Web

A partir daqui, apresentaremos exemplos mais práticos que os criadores da web podem usar no desenvolvimento real, combinando as funções básicas que aprendemos até agora.

Aplicação 1: Gerando Senhas ou Strings de ID Aleatórias

Isso é útil quando você quer gerar senhas iniciais para usuários de teste ou IDs de sessão temporários. Aqui, apresentamos uma maneira inteligente de escrever isso, combinando random.choice() com manipulação de strings e compreensões de lista.

import random
import string

# Definir os caracteres candidatos
# string.ascii_letters são todas as letras inglesas (a-z, A-Z)
# string.digits são números (0-9)
# string.punctuation são símbolos (!"#$%&...)
caracteres = string.ascii_letters + string.digits + string.punctuation
print(f"Caracteres candidatos parciais: {caracteres[:20]}...")

# Especificar o comprimento da senha
comprimento = 16

# Gerar uma string aleatória do comprimento especificado usando uma compreensão de lista
# "".join(lista) concatena os elementos de uma lista em uma única string
senha_aleatoria = "".join(random.choice(caracteres) for _ in range(comprimento))

print(f"String aleatória gerada: {senha_aleatoria}")

Aplicação 2: Gerando HTML com Elementos Aleatórios usando Python

O Python também atua no lado do servidor web. Aqui, apresentamos um código que gera dinamicamente um arquivo HTML com conteúdo aleatório. Isso é útil quando você quer criar protótipos ou dados de teste para um site de forma eficiente.

O código Python a seguir gera um arquivo HTML simples com uma cor de fundo diferente e uma mensagem diferente a cada execução.

Código Python: Gerando HTML aleatório

import random

# 1. Gerar um código de cor aleatório
# Converter um inteiro de 0 a 16777215 (FFFFFF) para um número hexadecimal
cor_de_fundo = f"#{random.randint(0, 0xFFFFFF):06x}"

# 2. Selecionar uma mensagem e um ícone aleatórios
mensagens = [
    ("Bem-vindo ao mundo do Python!", "🐍"),
    ("O módulo random é útil, não é?", "👍"),
    ("O design da Web é divertido!", "🎨"),
    ("Hoje é um ótimo dia para codificar.", "💻")
]
mensagem, icone = random.choice(mensagens)

# 3. Criar a estrutura HTML com uma f-string
conteudo_html = f"""<!DOCTYPE html>
<html lang="pt">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Página Gerada Aleatoriamente</title>
    <style>
        body {{
            background-color: {cor_de_fundo};
            color: #333;
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
            text-align: center;
            padding-top: 100px;
            transition: background-color 0.5s ease;
        }}
        .container {{
            background-color: rgba(255, 255, 255, 0.8);
            padding: 2em 3em;
            border-radius: 12px;
            display: inline-block;
            box-shadow: 0 8px 20px rgba(0,0,0,0.15);
            backdrop-filter: blur(10px);
        }}
        h1 {{
            font-size: 2.5rem;
        }}
    </style>
</head>
<body>
    <div class="container">
        <h1>{icone} {mensagem}</h1>
        <p>A cor de fundo desta página é <strong>{cor_de_fundo}</strong>.</p>
    </div>
</body>
</html>
"""

# 4. Salvar o HTML gerado em um arquivo chamado "random_page.html"
with open("random_page.html", "w", encoding="utf-8") as f:
    f.write(conteudo_html)

print("`random_page.html` foi gerado. Por favor, abra-o em um navegador para verificar.")

Ao executar o script Python acima, um arquivo chamado `random_page.html` será criado no mesmo diretório do script. Se você abrir este arquivo em um navegador, uma página com um design diferente deverá ser exibida a cada vez. Por favor, experimente.

Pontos a Observar e Uso Avançado

Reprodutibilidade de Números Aleatórios: random.seed()

Os números aleatórios gerados pelo módulo random na verdade não são completamente aleatórios, mas sim números pseudoaleatórios gerados por um cálculo (algoritmo) específico. O ponto de partida para este cálculo é um valor chamado "semente" (seed).

Normalmente, a semente é definida automaticamente a partir de um valor imprevisível, como a hora atual, então uma sequência diferente de números aleatórios é gerada a cada execução. No entanto, para depuração ou testes, você pode querer gerar "valores aleatórios, mas a mesma sequência de valores aleatórios todas as vezes". Isso é alcançado com random.seed().

Se você fornecer um número específico (valor da semente) para random.seed(), a sequência de números aleatórios gerada a partir daí será completamente fixada. Não importa quantas vezes você o execute, os mesmos números aleatórios aparecerão na mesma ordem a partir do mesmo valor de semente.

import random

# Definir o valor da semente como 42
random.seed(42)
print("--- Executando com o valor da semente 42 ---")
print(random.randint(1, 100))
print(random.choice(["A", "B", "C"]))
print(random.random())

print("\n--- Executando novamente com o valor da semente 42 ---")
# Se você definir a semente para o mesmo valor novamente, a sequência de números aleatórios será redefinida e você obterá exatamente o mesmo resultado
random.seed(42)
print(random.randint(1, 100))
print(random.choice(["A", "B", "C"]))
print(random.random())

【Mais Importante】Use o módulo secrets para fins de segurança

O uso do módulo secrets é muito semelhante ao do módulo random, mas ele usa a fonte de aleatoriedade mais segura fornecida pelo sistema operacional, tornando extremamente difícil a previsão por terceiros.

Exemplo: Gerando um token seguro com o módulo secrets

import secrets
import string

# --- Gerar um token seguro para URL (32 bytes) ---
# Pode ser usado para URLs de redefinição de senha, etc.
token_seguro_url = secrets.token_urlsafe(32)
print(f"Token seguro para URL: {token_seguro_url}")


# --- Exemplo de geração de uma senha segura (16 caracteres) ---
# Usar caracteres alfanuméricos e símbolos como caracteres candidatos
alfabeto = string.ascii_letters + string.digits + string.punctuation
# Usar secrets.choice() para escolher caracteres de forma segura
senha_segura = ''.join(secrets.choice(alfabeto) for i in range(16))
print(f"Exemplo de senha segura: {senha_segura}")

Resumo

Neste artigo, explicamos em detalhes tudo, desde o básico da geração de números aleatórios usando o módulo random do Python até exemplos práticos de aplicação na produção web e importantes precauções de segurança.

Finalmente, vamos revisar as principais funções mais uma vez.

• Inteiros: random.randint(a, b) (inclusivo de a, b), random.randrange(start, stop) (exclusivo de stop)
• Seleção de Elementos: random.choice(seq) (um), random.choices(seq, k=n) (n itens com reposição), random.sample(seq, k=n) (n itens sem reposição)
• Reordenação: random.shuffle(x) (modifica a lista original diretamente)
• Decimais: random.random() (0.0 a 1.0), random.uniform(a, b) (no intervalo de a a b)
• Reprodutibilidade: random.seed(value) (fixa a sequência de números aleatórios)
• Segurança: Sempre use o módulo secrets para senhas e tokens!

Ao dominar essas funções, você pode facilmente criar dados de teste no desenvolvimento web ou adicionar um pouco de surpresa e interatividade à experiência do usuário. Por favor, copie e cole o código que apresentamos e torne o recurso de geração aleatória seu, executando-o você mesmo!