Enteros en Python: guía completa para principiantes

Los enteros son números completos sin parte decimal. Python los utiliza para contadores, cantidades, edades, índices, identificadores, puntuaciones, fechas, bucles y muchos cálculos. Pueden ser positivos, negativos o cero.

Esta guía explica los enteros en Python desde los literales y operaciones básicas hasta división, conversión, validación, bases numéricas, valores grandes, operaciones de bits, bucles y errores frecuentes.

Crear valores enteros

age = 28
temperature = -4
balance_change = 0

print(age)
print(type(age))

El tipo es int. Python lo deduce automáticamente a partir de un literal sin parte decimal. La documentación oficial de tipos numéricos explica enteros, flotantes y números complejos.

Literales grandes y legibles

Los guiones bajos pueden agrupar dígitos sin cambiar el valor.

population = 8_000_000_000
file_size = 1_048_576

print(population)
print(file_size)

Utiliza una agrupación coherente con el dominio del dato.

Operaciones aritméticas

a = 12
b = 5

print(a + b)
print(a - b)
print(a * b)
print(a ** b)

La guía de operadores en Python explica aritmética, comparación, lógica, pertenencia e identidad.

División con /, // y %

La división normal devuelve un float, incluso cuando el resultado es exacto:

print(10 / 2)  # 5.0
print(7 / 2)   # 3.5

La división entera redondea hacia menos infinito:

print(7 // 2)   # 3
print(-7 // 2)  # -4

El operador módulo devuelve el resto:

print(7 % 2)   # 1
print(15 % 4)  # 3

Es útil para comprobar pares, calcular páginas y convertir unidades:

number = 18

if number % 2 == 0:
    print("Par")
else:
    print("Impar")

Utilizar divmod()

minutes = 137
hours, remaining_minutes = divmod(minutes, 60)

print(hours)
print(remaining_minutes)

divmod() devuelve cociente y resto en una sola operación.

Orden de operaciones

result = 2 + 3 * 4
print(result)  # 14

result = (2 + 3) * 4
print(result)  # 20

Los paréntesis hacen explícita la intención y evitan interpretaciones incorrectas.

Comparar enteros

score = 82

print(score == 82)
print(score != 100)
print(score >= 60)
print(0 <= score <= 100)

Las comparaciones devuelven booleanos. La guía de booleanos en Python explica valores verdaderos, falsos y operadores lógicos.

Convertir texto a entero

text = "42"
number = int(text)

print(number + 8)

int() acepta espacios alrededor de un entero válido, pero no una cadena decimal:

print(int(" 25 "))
# int("3.5") genera ValueError

La documentación oficial de int() describe bases, conversiones y argumentos aceptados.

Validar la entrada del usuario

while True:
    try:
        quantity = int(input("Cantidad: "))
    except ValueError:
        print("Introduce un entero.")
        continue

    if quantity < 1:
        print("La cantidad debe ser positiva.")
        continue

    break

print(f"Cantidad aceptada: {quantity}")

La guía de input() en Python muestra validación, menús y funciones reutilizables. Para excepciones, consulta try y except.

Convertir un entero a texto

order_id = 582
message = "Pedido #" + str(order_id)
print(message)

print(f"Pedido #{order_id}")

Las f-strings suelen ser más claras y admiten formato adicional.

Binario, octal y hexadecimal

binary_value = 0b1010
octal_value = 0o12
hex_value = 0xA

print(binary_value)
print(octal_value)
print(hex_value)

Los tres valores representan el decimal 10.

Convertir texto desde otra base

print(int("1010", 2))
print(int("12", 8))
print(int("A", 16))

print(int("0b1010", 0))
print(int("0xFF", 0))

La base cero permite que Python reconozca prefijos estándar.

Mostrar bases diferentes

number = 255

print(bin(number))
print(oct(number))
print(hex(number))

print(f"{number:b}")
print(f"{number:o}")
print(f"{number:x}")

Enteros muy grandes

Los enteros de Python tienen precisión arbitraria y están limitados principalmente por la memoria disponible.

large_number = 10 ** 100
print(large_number)
print(len(str(large_number)))

Esto permite cálculos exactos con números completos enormes, aunque las operaciones siguen consumiendo tiempo y memoria. Bases de datos y APIs externas pueden imponer límites de 32 o 64 bits.

Booleanos y enteros

bool es una subclase de int. True se comporta numéricamente como 1 y False como 0.

print(True + True)
print(False + 10)
print(isinstance(True, int))

responses = [True, False, True, True]
print(sum(responses))

Aunque es válido, utiliza código explícito cuando resulte más fácil de entender.

Enteros en range()

for number in range(1, 6):
    print(number)

for number in range(10, 0, -2):
    print(number)

El valor final queda excluido. La guía de range() en Python explica inicio, fin, paso y secuencias descendentes.

Enteros como índices

colors = ["azul", "verde", "naranja"]

print(colors[0])
print(colors[-1])

Un índice fuera del rango produce IndexError. Puedes validarlo:

index = 1

if 0 <= index < len(colors):
    print(colors[index])

Métodos de int

bit_length() indica cuántos bits necesita el valor absoluto:

number = 255
print(number.bit_length())

to_bytes() y from_bytes() convierten entre enteros y secuencias de bytes:

number = 1024
encoded = number.to_bytes(2, byteorder="big")
decoded = int.from_bytes(encoded, byteorder="big")

print(encoded)
print(decoded)

Operaciones bit a bit

a = 0b1100
b = 0b1010

print(bin(a & b))
print(bin(a | b))
print(bin(a ^ b))
print(bin(a << 1))
print(bin(a >> 1))

Estas operaciones aparecen en flags, permisos, protocolos y formatos binarios. Para condiciones normales, los operadores booleanos suelen ser más legibles.

int() frente a round()

int() trunca hacia cero; no redondea al entero más cercano.

print(int(3.9))
print(int(-3.9))
print(round(3.9))

Elige la operación de acuerdo con la regla del proyecto.

Enteros aleatorios

import random

value = random.randint(1, 6)
print(value)

randint() incluye ambos extremos. Para contraseñas y tokens utiliza secrets, no random. La guía del módulo random explica selección, muestreo y seguridad.

Proyecto: calculadora de cambio

def calculate_change(amount_cents: int) -> dict[int, int]:
    if amount_cents < 0:
        raise ValueError("La cantidad no puede ser negativa")

    denominations = [100, 50, 25, 10, 5, 1]
    result = {}
    remaining = amount_cents

    for denomination in denominations:
        count, remaining = divmod(remaining, denomination)
        result[denomination] = count

    return result


for denomination, count in calculate_change(287).items():
    print(f"{denomination:>3} centavos: {count}")

Proyecto: calcular páginas

def total_pages(total_items: int, items_per_page: int) -> int:
    if total_items < 0:
        raise ValueError("total_items no puede ser negativo")
    if items_per_page <= 0:
        raise ValueError("items_per_page debe ser positivo")

    return (total_items + items_per_page - 1) // items_per_page


print(total_pages(101, 20))

Errores frecuentes

• Esperar que / devuelva un entero.
• Confundir int() con redondeo.
• Hacer cálculos directamente con input().
• Dividir entre cero.
• Utilizar un índice fuera de rango.
• Suponer que sistemas externos aceptan enteros ilimitados.
• Usar random para valores de seguridad.

Conclusión

Los enteros de Python permiten cálculos exactos, literales legibles, varias bases numéricas y una precisión práctica muy amplia. Convierte el texto con cuidado, distingue división real y entera, valida rangos y recuerda que otros sistemas pueden tener límites más estrictos. Dominar int facilita trabajar con bucles, índices, identificadores, cantidades y reglas de negocio.