División Entera en Python: Guía Completa del Operador //

Q: ¿Cuál es la diferencia entre / y // en Python?

El operador / realiza división verdadera y siempre devuelve un float, mientras que // realiza división entera y devuelve el entero más grande menor o igual al resultado. Por ejemplo, 7 / 2 devuelve 3.5, pero 7 // 2 devuelve 3.

Name: Kanaries Team

Updated on 24/11/2025

La división entera (floor division) es una operación aritmética fundamental en Python que divide dos números y redondea el resultado hacia abajo al entero más cercano. A diferencia de la división regular que devuelve un número de punto flotante, la división entera usando el operador // siempre devuelve el entero más grande menor o igual al resultado. Este artículo te guiará a través de todo lo que necesitas saber sobre la división entera en Python.

Python proporciona dos operadores de división: el operador de división regular / y el operador de división entera //. Entender cuándo usar cada uno es esencial para escribir código Python eficiente y libre de errores.

¿Quieres crear rápidamente visualizaciones de datos desde Python Pandas DataFrame sin código?

PyGWalker es una biblioteca de Python para análisis exploratorio de datos con visualización. PyGWalker (opens in a new tab) puede simplificar tu flujo de trabajo de análisis y visualización de datos en Jupyter Notebook, convirtiendo tu pandas dataframe (y polars dataframe) en una interfaz de usuario alternativa a Tableau para exploración visual.

(opens in a new tab)

¿Qué es la División Entera en Python?

La división entera es la operación de división que redondea el resultado hacia abajo al número entero más cercano. En Python, esto se realiza usando el operador //. El término "floor" (piso) proviene de la función matemática floor, que siempre redondea hacia el infinito negativo.

Aquí hay un ejemplo simple:

# División regular
print(7 / 2)   # Salida: 3.5
 
# División entera
print(7 // 2)  # Salida: 3

Como puedes ver, la división regular devuelve 3.5, mientras que la división entera devuelve 3 - el entero más grande que es menor o igual a 3.5.

Sintaxis de la División Entera

La sintaxis para la división entera en Python es directa:

resultado = dividendo // divisor

Donde:

dividendo es el número que se divide
divisor es el número por el cual se divide
resultado es el piso de la división

División Entera con Diferentes Tipos de Datos

Enteros

Cuando ambos operandos son enteros, la división entera devuelve un entero:

print(10 // 3)   # Salida: 3
print(15 // 4)   # Salida: 3
print(20 // 5)   # Salida: 4

Números de Punto Flotante

Cuando al menos un operando es un float, la división entera devuelve un float (pero todavía redondeado hacia abajo):

print(10.0 // 3)   # Salida: 3.0
print(10 // 3.0)   # Salida: 3.0
print(10.5 // 3)   # Salida: 3.0

Números Negativos

La división entera con números negativos puede ser complicada. Recuerda, la división entera siempre redondea hacia el infinito negativo, no hacia cero:

print(7 // 2)    # Salida: 3
print(-7 // 2)   # Salida: -4  (¡no -3!)
print(7 // -2)   # Salida: -4
print(-7 // -2)  # Salida: 3

Este comportamiento es importante de entender porque -7 / 2 = -3.5, y el piso de -3.5 es -4, no -3.

División Entera vs División Regular

Operación	Operador	Tipo de Resultado	Ejemplo	Salida
División Regular	`/`	Siempre float	`7 / 2`	`3.5`
División Entera	`//`	int o float	`7 // 2`	`3`

# Comparación
a = 17
b = 5
 
print(f"División regular: {a} / {b} = {a / b}")     # 3.4
print(f"División entera: {a} // {b} = {a // b}")    # 3

Casos de Uso Prácticos para División Entera

1. Calculando Páginas o Grupos

Cuando necesitas determinar cuántos grupos completos caben dentro de un total:

total_elementos = 23
elementos_por_pagina = 5
 
paginas_completas = total_elementos // elementos_por_pagina
print(f"Páginas completas: {paginas_completas}")  # Salida: 4

2. Conversión de Unidades

La división entera es útil para conversiones 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")  # Salida: 1h 2m 5s

3. Indexación de Arrays y Posicionamiento

Al trabajar con cuadrículas o arrays 2D:

# Convertir índice 1D a coordenadas 2D
indice = 17
columnas = 5
 
fila = indice // columnas
columna = indice % columnas
 
print(f"Índice {indice} -> Fila: {fila}, Columna: {columna}")  # Fila: 3, Columna: 2

4. Encontrar el Índice del Medio

Útil en búsqueda binaria y algoritmos similares:

def busqueda_binaria(arr, objetivo):
    izquierda, derecha = 0, len(arr) - 1
 
    while izquierda <= derecha:
        medio = (izquierda + derecha) // 2  # División entera para índice del medio
        if arr[medio] == objetivo:
            return medio
        elif arr[medio] < objetivo:
            izquierda = medio + 1
        else:
            derecha = medio - 1
 
    return -1

La Función divmod()

Python proporciona una función incorporada divmod() que devuelve tanto el cociente (división entera) como el resto en una sola operación:

cociente, resto = divmod(17, 5)
print(f"17 // 5 = {cociente}")    # Salida: 3
print(f"17 % 5 = {resto}")        # Salida: 2

Esto es más eficiente que llamar a // y % por separado cuando necesitas ambos valores.

División Entera con el Módulo math

También puedes lograr la división entera usando la función math.floor() combinada con división regular:

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

Ambos métodos producen el mismo resultado, pero // es más conciso y generalmente preferido.

Errores Comunes y Cómo Evitarlos

Error 1: Confundir División Entera con Truncamiento

# La división entera redondea hacia el infinito negativo
print(-7 // 2)  # Salida: -4
 
# El truncamiento (conversión a int) redondea hacia cero
print(int(-7 / 2))  # Salida: -3

Error 2: Olvidar los Resultados Float

# Si un operando es float, el resultado es float
print(type(10 // 3))    # <class 'int'>
print(type(10.0 // 3))  # <class 'float'>

Error 3: División por Cero

# Esto lanzará ZeroDivisionError
try:
    resultado = 10 // 0
except ZeroDivisionError:
    print("¡No se puede dividir por cero!")

Consideraciones de Rendimiento

La división entera es generalmente más rápida que la división regular seguida de int() o math.floor():

import timeit
 
# Operador de división entera
tiempo1 = timeit.timeit('7 // 2', number=1000000)
 
# División regular + int()
tiempo2 = timeit.timeit('int(7 / 2)', number=1000000)
 
print(f"Operador //: {tiempo1:.4f}s")
print(f"Método int(/): {tiempo2:.4f}s")

FAQ

¿Cuál es la diferencia entre / y // en Python?

El operador / realiza división verdadera y siempre devuelve un float, mientras que // realiza división entera y devuelve el entero más grande menor o igual al resultado. Por ejemplo, 7 / 2 devuelve 3.5, pero 7 // 2 devuelve 3.

¿Cómo funciona la división entera con números negativos?

La división entera siempre redondea hacia el infinito negativo. Entonces -7 // 2 es igual a -4, no -3, porque -4 es el entero más grande menor o igual a -3.5.

¿Cuándo debo usar división entera en lugar de división regular?

Usa división entera cuando necesites un resultado entero y quieras evitar problemas de precisión de punto flotante, como al calcular índices de arrays, contar grupos completos o implementar algoritmos que requieren aritmética de enteros.

Conclusión

La división entera en Python con el operador // es una herramienta poderosa para realizar división de enteros que redondea hacia abajo al número entero más cercano. Entender su comportamiento, especialmente con números negativos y operandos de punto flotante, es crucial para escribir código Python correcto. Ya sea que estés implementando algoritmos, convirtiendo unidades o trabajando con índices de arrays, la división entera es una operación esencial en tu conjunto de herramientas de Python.