Aula 8.4 - Módulos, Aleatórios e type()

🧩 8.10 Módulos

Um módulo é simplesmente um arquivo Python com funções que podem ser importadas em outros programas. Isso permite criar bibliotecas reutilizáveis e organizar o código em arquivos separados.

Abaixo criamos um módulo chamado entrada.py com funções de validação de entrada:

Listagem 8.34 — Módulo entrada.py# entrada.py — funções de leitura validada

def lê_int(msg):
    """Lê um inteiro do teclado, pedindo novamente em caso de erro."""
    while True:
        try:
            return int(input(msg))
        except ValueError:
            print("Erro: digite um número inteiro.")

def lê_float(msg):
    """Lê um float do teclado, pedindo novamente em caso de erro."""
    while True:
        try:
            return float(input(msg))
        except ValueError:
            print("Erro: digite um número real.")

def faixa_int(msg, minimo, maximo):
    """Lê um inteiro dentro de [minimo, maximo]."""
    while True:
        n = lê_int(msg)
        if minimo <= n <= maximo:
            return n
        print(f"Digite entre {minimo} e {maximo}.")

Para usar o módulo em outro arquivo, usamos import:

Listagem 8.35 — Importando e usando o módulo entrada# Forma 1: importar o módulo inteiro
import entrada

n = entrada.lê_int("Digite um inteiro: ")
nota = entrada.faixa_int("Nota (0-10): ", 0, 10)

# Forma 2: importar funções específicas
from entrada import lê_int, faixa_int

n = lê_int("Digite um inteiro: ")

💡 O arquivo entrada.py deve estar na mesma pasta do programa que o importa, ou num diretório que esteja no PYTHONPATH.

🎲 8.11 Números Aleatórios

O módulo random da biblioteca padrão do Python oferece funções para gerar números pseudo-aleatórios. É muito útil em jogos, simulações e testes.

random.randint(a, b)

Retorna um inteiro aleatório entre a e b, inclusive:

Listagem 8.36 — Usando randintimport random

dado = random.randint(1, 6)
print(dado)   # um número entre 1 e 6

Exemplo completo: jogo de adivinhar o número:

Listagem 8.37 — Jogo: adivinhe o númeroimport random

secreto = random.randint(1, 10)
tentativas = 0

while True:
    chute = int(input("Adivinhe o número (1-10): "))
    tentativas += 1
    if chute == secreto:
        print(f"Acertou em {tentativas} tentativa(s)!")
        break
    elif chute < secreto:
        print("Maior!")
    else:
        print("Menor!")

✏️ Exercício 8.13

Modifique o jogo de adivinhar para limitar o número de tentativas a 5. Se o jogador errar 5 vezes, o programa deve revelar o número secreto.

Outras funções do módulo random

Listagem 8.38 — random.random()>>> random.random()
0.37444887175646646   # float entre 0.0 e 1.0 (exclusive)

Listagem 8.39 — random.uniform(a, b)>>> random.uniform(1.5, 3.5)
2.847392...   # float aleatório entre 1.5 e 3.5

Listagem 8.40 — random.sample() — loteriaimport random

dezenas = random.sample(range(1, 61), 6)
dezenas.sort()
print(dezenas)

[3, 17, 24, 38, 45, 59]

Listagem 8.41 — random.shuffle() — embaralharimport random

cartas = ['A', '2', '3', '4', '5',
          '6', '7', '8', '9', '10',
          'J', 'Q', 'K']

random.shuffle(cartas)
print(cartas[:5])   # primeiras 5 cartas embaralhadas

['7', 'Q', '2', 'K', 'A']

Função	Descrição
random.randint(a, b)	Inteiro aleatório em [a, b]
random.random()	Float aleatório em [0.0, 1.0)
random.uniform(a, b)	Float aleatório em [a, b]
random.sample(seq, k)	k elementos distintos aleatórios de seq
random.shuffle(lista)	Embaralha a lista no lugar (in-place)
random.choice(seq)	Elemento aleatório de uma seqüência

✏️ Exercício 8.14

Escreva um programa de simulação de dados: lança dois dados (1–6) 1000 vezes e conta quantas vezes a soma foi igual a 7. Exiba a porcentagem.

🔍 8.12 A Função type()

A função embutida type() retorna o tipo de um objeto. É útil para depurar código e para escrever funções que se comportam diferentemente conforme o tipo do argumento:

Listagem 8.42 — Exemplos de type()>>> type(42)
<class 'int'>
>>> type(3.14)
<class 'float'>
>>> type("olá")
<class 'str'>
>>> type([1, 2, 3])
<class 'list'>
>>> type(True)
<class 'bool'>

Podemos usar type() em comparações com ==:

Listagem 8.43 — Função diz_o_tipodef diz_o_tipo(x):
    t = type(x)
    if t == int:
        print(f"{x} é um inteiro")
    elif t == float:
        print(f"{x} é um real")
    elif t == str:
        print(f"{x} é uma string")
    elif t == list:
        print(f"{x} é uma lista")
    else:
        print(f"{x} é do tipo {t}")

diz_o_tipo(42)
diz_o_tipo("Python")
diz_o_tipo([1, 2])

42 é um inteiro
Python é uma string
[1, 2] é uma lista

Verificando tipos em listas mistas

Listagem 8.44 — Tipos dos elementos de uma listalista = [1, "dois", 3.0, True, [4, 5]]

for e in lista:
    print(type(e).__name__, "→", e)

int → 1
str → dois
float → 3.0
bool → True
list → [4, 5]

Podemos usar type() para filtrar elementos de um tipo específico:

Listagem 8.45 — Navegando listas pelo tipodef só_inteiros(lista):
    return [e for e in lista if type(e) == int]

def só_strings(lista):
    return [e for e in lista if type(e) == str]

mista = [1, "a", 2, "b", 3.5, 4]
print(só_inteiros(mista))
print(só_strings(mista))

[1, 2, 4]
['a', 'b']

💡 Para verificar tipos de forma mais flexível (respeitando herança), prefira isinstance(x, int) em vez de type(x) == int. O isinstance retorna True também para subclasses.

✏️ Exercício 8.15

Escreva uma função soma_por_tipo(lista) que receba uma lista mista e retorne um dicionário com as somas separadas por tipo. Por exemplo: {"int": 6, "float": 3.5} para a lista [1, 2, 3, 3.5].

📦 Módulos, Aleatórios e type()