Divisão Inteira em Python: Guia Completo do Operador //

Q: Qual é a diferença entre / e // em Python?

O operador / realiza divisão verdadeira e sempre retorna um float, enquanto // realiza divisão inteira e retorna o maior inteiro menor ou igual ao resultado. Por exemplo, 7 / 2 retorna 3.5, mas 7 // 2 retorna 3.

Name: Kanaries Team

Updated on 24/11/2025

A divisão inteira (floor division) é uma operação aritmética fundamental em Python que divide dois números e arredonda o resultado para baixo para o inteiro mais próximo. Diferente da divisão regular que retorna um número de ponto flutuante, a divisão inteira usando o operador // sempre retorna o maior inteiro menor ou igual ao resultado. Este artigo irá guiá-lo através de tudo que você precisa saber sobre divisão inteira em Python.

Python fornece dois operadores de divisão: o operador de divisão regular / e o operador de divisão inteira //. Entender quando usar cada um é essencial para escrever código Python eficiente e livre de erros.

Quer criar rapidamente visualizações de dados a partir de Python Pandas DataFrame sem código?

PyGWalker é uma biblioteca Python para Análise Exploratória de Dados com Visualização. PyGWalker (opens in a new tab) pode simplificar seu fluxo de trabalho de análise e visualização de dados no Jupyter Notebook, transformando seu pandas dataframe (e polars dataframe) em uma Interface de Usuário alternativa ao Tableau para exploração visual.

(opens in a new tab)

O que é Divisão Inteira em Python?

A divisão inteira é a operação de divisão que arredonda o resultado para baixo para o número inteiro mais próximo. Em Python, isso é realizado usando o operador //. O termo "floor" (piso) vem da função matemática floor, que sempre arredonda em direção ao infinito negativo.

Aqui está um exemplo simples:

# Divisão regular
print(7 / 2)   # Saída: 3.5
 
# Divisão inteira
print(7 // 2)  # Saída: 3

Como você pode ver, a divisão regular retorna 3.5, enquanto a divisão inteira retorna 3 - o maior inteiro que é menor ou igual a 3.5.

Sintaxe da Divisão Inteira

A sintaxe para divisão inteira em Python é direta:

resultado = dividendo // divisor

Onde:

dividendo é o número sendo dividido
divisor é o número pelo qual você está dividindo
resultado é o piso da divisão

Divisão Inteira com Diferentes Tipos de Dados

Inteiros

Quando ambos os operandos são inteiros, a divisão inteira retorna um inteiro:

print(10 // 3)   # Saída: 3
print(15 // 4)   # Saída: 3
print(20 // 5)   # Saída: 4

Números de Ponto Flutuante

Quando pelo menos um operando é um float, a divisão inteira retorna um float (mas ainda arredondado para baixo):

print(10.0 // 3)   # Saída: 3.0
print(10 // 3.0)   # Saída: 3.0
print(10.5 // 3)   # Saída: 3.0

Números Negativos

A divisão inteira com números negativos pode ser complicada. Lembre-se, a divisão inteira sempre arredonda em direção ao infinito negativo, não em direção a zero:

print(7 // 2)    # Saída: 3
print(-7 // 2)   # Saída: -4  (não -3!)
print(7 // -2)   # Saída: -4
print(-7 // -2)  # Saída: 3

Este comportamento é importante de entender porque -7 / 2 = -3.5, e o piso de -3.5 é -4, não -3.

Divisão Inteira vs Divisão Regular

Operação	Operador	Tipo de Resultado	Exemplo	Saída
Divisão Regular	`/`	Sempre float	`7 / 2`	`3.5`
Divisão Inteira	`//`	int ou float	`7 // 2`	`3`

# Comparação
a = 17
b = 5
 
print(f"Divisão regular: {a} / {b} = {a / b}")     # 3.4
print(f"Divisão inteira: {a} // {b} = {a // b}")   # 3

Casos de Uso Práticos para Divisão Inteira

1. Calculando Páginas ou Grupos

Quando você precisa determinar quantos grupos completos cabem dentro de um total:

total_itens = 23
itens_por_pagina = 5
 
paginas_completas = total_itens // itens_por_pagina
print(f"Páginas completas: {paginas_completas}")  # Saída: 4

2. Conversão de Unidades

A divisão inteira é útil para conversões de unidades:

total_segundos = 3725
 
horas = total_segundos // 3600
minutos = (total_segundos % 3600) // 60
segundos = total_segundos % 60
 
print(f"{horas}h {minutos}m {segundos}s")  # Saída: 1h 2m 5s

3. Indexação de Arrays e Posicionamento

Ao trabalhar com grades ou arrays 2D:

# Converter índice 1D para coordenadas 2D
indice = 17
colunas = 5
 
linha = indice // colunas
coluna = indice % colunas
 
print(f"Índice {indice} -> Linha: {linha}, Coluna: {coluna}")  # Linha: 3, Coluna: 2

4. Encontrando o Índice do Meio

Útil em busca binária e algoritmos similares:

def busca_binaria(arr, alvo):
    esquerda, direita = 0, len(arr) - 1
 
    while esquerda <= direita:
        meio = (esquerda + direita) // 2  # Divisão inteira para índice do meio
        if arr[meio] == alvo:
            return meio
        elif arr[meio] < alvo:
            esquerda = meio + 1
        else:
            direita = meio - 1
 
    return -1

A Função divmod()

Python fornece uma função embutida divmod() que retorna tanto o quociente (divisão inteira) quanto o resto em uma única operação:

quociente, resto = divmod(17, 5)
print(f"17 // 5 = {quociente}")    # Saída: 3
print(f"17 % 5 = {resto}")         # Saída: 2

Isso é mais eficiente do que chamar // e % separadamente quando você precisa de ambos os valores.

Divisão Inteira com o Módulo math

Você também pode alcançar a divisão inteira usando a função math.floor() combinada com divisão regular:

import math
 
resultado1 = 7 // 2
resultado2 = math.floor(7 / 2)
 
print(resultado1)  # Saída: 3
print(resultado2)  # Saída: 3

Ambos os métodos produzem o mesmo resultado, mas // é mais conciso e geralmente preferido.

Erros Comuns e Como Evitá-los

Erro 1: Confundir Divisão Inteira com Truncamento

# Divisão inteira arredonda em direção ao infinito negativo
print(-7 // 2)  # Saída: -4
 
# Truncamento (conversão para int) arredonda em direção a zero
print(int(-7 / 2))  # Saída: -3

Erro 2: Esquecer dos Resultados Float

# Se um operando é float, o resultado é float
print(type(10 // 3))    # <class 'int'>
print(type(10.0 // 3))  # <class 'float'>

Erro 3: Divisão por Zero

# Isso vai levantar ZeroDivisionError
try:
    resultado = 10 // 0
except ZeroDivisionError:
    print("Não é possível dividir por zero!")

Considerações de Desempenho

A divisão inteira é geralmente mais rápida do que divisão regular seguida de int() ou math.floor():

import timeit
 
# Operador de divisão inteira
tempo1 = timeit.timeit('7 // 2', number=1000000)
 
# Divisão regular + int()
tempo2 = timeit.timeit('int(7 / 2)', number=1000000)
 
print(f"Operador //: {tempo1:.4f}s")
print(f"Método int(/): {tempo2:.4f}s")

FAQ

Qual é a diferença entre / e // em Python?

O operador / realiza divisão verdadeira e sempre retorna um float, enquanto // realiza divisão inteira e retorna o maior inteiro menor ou igual ao resultado. Por exemplo, 7 / 2 retorna 3.5, mas 7 // 2 retorna 3.

Como a divisão inteira funciona com números negativos?

A divisão inteira sempre arredonda em direção ao infinito negativo. Então -7 // 2 é igual a -4, não -3, porque -4 é o maior inteiro menor ou igual a -3.5.

Quando devo usar divisão inteira em vez de divisão regular?

Use divisão inteira quando você precisar de um resultado inteiro e quiser evitar problemas de precisão de ponto flutuante, como ao calcular índices de arrays, contar grupos completos ou implementar algoritmos que requerem aritmética de inteiros.

Conclusão

A divisão inteira em Python com o operador // é uma ferramenta poderosa para realizar divisão de inteiros que arredonda para baixo para o número inteiro mais próximo. Entender seu comportamento, especialmente com números negativos e operandos de ponto flutuante, é crucial para escrever código Python correto. Seja implementando algoritmos, convertendo unidades ou trabalhando com índices de arrays, a divisão inteira é uma operação essencial no seu kit de ferramentas Python.