Las funciones incorporadas de Python no son una lista: cada una impone un contrato distinto

Aprender funciones incorporadas como una lista de cinco nombres produce una ilusión de dominio. Puedes recordar print(), len(), range(), type() e int() y aun así no saber por qué una de ellas devuelve una secuencia que no es una lista, otra acepta un objeto que no esperabas y otra transforma una cadena pero lanza una excepción con una entrada aparentemente inocente.

La documentación oficial de funciones incorporadas de Python las presenta junto con tipos que siempre están disponibles en el intérprete. Pero que estén disponibles no significa que compartan el mismo contrato. print() produce una representación en una salida; len() pide una medida a un objeto; range() describe una sucesión; type() informa sobre el tipo; e int(), float() y str() intentan convertir o construir valores con reglas propias.

La tesis de este artículo es que no debes elegir una función incorporada por frecuencia o por longitud del nombre. Debes elegirla por el contrato que necesitas: observar, medir, repetir, inspeccionar o convertir. Cuando ese contrato no está claro, el código puede parecer correcto y seguir produciendo una decisión equivocada.

Antes de llamar a una función, nombra el trabajo que debe hacer

Imagina que recibes una lista de precios y quieres mostrar cuántos elementos contiene, repetir una operación cinco veces y convertir una entrada escrita por el usuario. Son tres tareas que un principiante puede mezclar porque todas caben en una línea:

print(len(precios))
for indice in range(5):
    print(indice)

cantidad = int(input("Cantidad: "))

La primera línea observa un resultado; la segunda construye el conjunto de pasos de una iteración; la tercera convierte texto a entero. Si una de ellas falla, no se arregla sustituyéndola por otra función que “también trabaja con datos”. Primero pregunta qué trabajo estaba pendiente.

La tabla es un mapa de preguntas, no una tarjeta para memorizar. Si la variable representa una cadena con espacios, `len` cuenta caracteres; si representa una lista, cuenta elementos; si representa un diccionario, cuenta pares de claves. El nombre de la función no contiene esa decisión: el objeto y su contrato sí.

print() muestra una representación, no demuestra que el programa esté bien

print() es una herramienta de observación rápida. Puedes usarla para comprobar el valor de una variable, revisar el orden de una lista o ver si una rama del programa se ejecutó. Pero imprimir algo no significa que el estado sea correcto. Un programa puede imprimir “guardado” antes de que una operación termine o mostrar un diccionario que contiene un campo equivocado.

Considera la diferencia entre observar una entrada y declarar un resultado:

print("usuario recibido:", usuario)
resultado = guardar(usuario)
print("guardado:", resultado)

El primer mensaje ayuda a depurar el camino de entrada. El segundo solo es informativo si guardar() devuelve un valor que realmente representa el éxito. La salida de print() no conoce el significado de tu dominio; lo debes definir tú.

También conviene recordar que una salida de consola puede contener datos sensibles. No imprimas contraseñas, tokens ni respuestas completas de usuarios solo para inspeccionarlas. El artículo sobre código Python limpio puede ayudarte a separar una comprobación temporal de una decisión que debe permanecer en el programa.

len() no mide “lo que ves”: pregunta al objeto por su tamaño

La referencia de len() define una operación sobre objetos que proporcionan una longitud. La documentación de tipos incorporados explica que distintas colecciones y secuencias tienen contratos diferentes. Por eso estas expresiones son válidas, aunque no significan lo mismo:

len("Python")          # caracteres
len(["P", "y", "t"])   # elementos
len({"name": "Ana"})   # claves
len({"a", "b", "c"})   # elementos del conjunto

Un error común es usar len() como si fuera una prueba universal de contenido. Una lista con un elemento puede contener una cadena vacía; un diccionario con tres claves puede tener valores nulos; una cadena puede tener espacios que visualmente parecen ausentes. “Tiene longitud” y “tiene información útil” no son la misma pregunta.

También puedes recibir TypeError cuando el objeto no define una longitud. Ese error es información: significa que la función que llamaste no puede aplicar el contrato que esperabas. Si tu código acepta varias clases de objetos, decide si debes convertirlos, validar el tipo o diseñar una interfaz común.

¿Qué devuelve len() si el contenido está vacío?

Devuelve cero para colecciones o secuencias vacías que implementan el contrato de tamaño. Eso no te dice si el dato es válido para tu aplicación: un formulario vacío, una lista sin resultados y un archivo vacío pueden requerir mensajes diferentes.

range() describe una sucesión; no es una lista de números

La referencia de range() describe un objeto que representa una sucesión de enteros. Con range(5), el inicio por defecto es cero y el límite final no se incluye: los valores son 0, 1, 2, 3 y 4. Esta decisión sobre el límite explica muchos errores de uno más o uno menos.

for indice in range(len(nombres)):
    print(indice, nombres[indice])

El ejemplo funciona, pero no siempre es la forma más clara de expresar la intención. Si necesitas los elementos y sus posiciones, enumerate() comunica mejor el contrato:

for indice, nombre in enumerate(nombres):
    print(indice, nombre)

La elección no depende de qué función recuerdas primero. Depende de si estás recorriendo posiciones, elementos o una sucesión independiente del tamaño de una colección. Además, range() no materializa necesariamente todos los números en una lista; eso permite describir iteraciones grandes sin crear una lista completa solo para recorrerla.

Si necesitas imprimir o modificar la sucesión como una colección concreta, puedes convertirla con list(range(5)). Hazlo cuando el contrato de tu siguiente operación necesite una lista, no como reflejo automático para que el resultado “se vea” familiar.

type() ayuda a investigar, pero no debería convertirse en una red de parches

type() puede responder una pregunta durante el aprendizaje: “¿qué objeto llegó hasta aquí?”. Es útil cuando una función recibe una cadena donde esperabas un número o una lista donde esperabas un diccionario. La salida puede revelar una conversión que ocurrió antes o un valor que vino de una entrada externa.

valor = input("Escribe algo: ")
print(type(valor))

El resultado será str, incluso si el usuario escribió 42. input() recibe texto; el programador decide si debe convertirlo. Esa diferencia explica por qué una suma puede concatenar cadenas o producir un error en vez de realizar una operación matemática.

Sin embargo, llenar el código de condiciones como if type(valor) == str puede ser una señal de que la función no tiene un contrato claro. Para muchas decisiones es preferible validar un comportamiento, usar isinstance() cuando necesitas una relación de tipos y separar la conversión en el límite de entrada. type() es una lupa; no es un diseño de datos.

Conversión: int(), float() y str() no prometen conservar la misma información

Las funciones de conversión son especialmente engañosas porque parecen una reparación rápida. Si int() recibe una cadena como "18", puede producir el entero 18. Si recibe "18.5", no interpreta automáticamente que debe truncar el decimal: la cadena no tiene el formato de un entero y la operación puede lanzar ValueError.

int("18")       # 18
float("18.5")   # 18.5
int(18.9)        # 18
str(18)          # "18"

La última línea transforma un número en texto. La tercera descarta la parte fraccionaria al convertir un valor flotante en entero. No son operaciones simétricas. Convertir a texto suele cambiar el tipo sin perder la representación básica; convertir entre números puede perder precisión o información de escala.

La documentación de tipos numéricos de Python explica que `int`, `float` y `complex` son tipos distintos y que las conversiones tienen reglas específicas. Antes de convertir, define qué debe ocurrir con espacios, signo, decimales, valores enormes, texto vacío y valores especiales como nan o inf cuando corresponda.

En una entrada de usuario, la conversión debe formar parte de un flujo que pueda recuperarse:

texto = input("Cantidad entera: ").strip()
try:
    cantidad = int(texto)
except ValueError:
    print("Escribe un número entero, por favor.")
else:
    print("Cantidad aceptada:", cantidad)

El artículo sobre excepciones en Python profundiza en por qué capturar el tipo correcto importa. Aquí basta observar la conexión: una función incorporada puede devolver un resultado o producir una señal de que el contrato de entrada no se cumplió.

¿Por qué int("18.5") no hace lo mismo que int(18.5)?

Porque la primera operación intenta interpretar texto con formato entero y la segunda convierte un valor numérico flotante. La conversión desde float descarta la parte fraccionaria; la cadena con punto no cumple directamente el formato esperado por `int()`.

Un experimento: cinco funciones, cinco preguntas

En vez de repetir definiciones, usa un mismo dato y cambia la pregunta:

datos = ["7", "11", "13"]

print(datos)              # ¿qué representación recibí?
print(len(datos))         # ¿cuántos elementos hay?
print(list(range(len(datos))))  # ¿qué posiciones puedo recorrer?
print(type(datos))        # ¿qué tipo de objeto es?
print([int(item) for item in datos])  # ¿puedo convertir cada elemento?

El experimento revela que las funciones no compiten por ser “más importantes”. Cada una añade una operación distinta al programa. El resultado de range() puede servir para controlar el recorrido; el de int() cambia el tipo de cada elemento; el de type() sirve para inspección y normalmente no pertenece a la lógica final; el de print() hace visible una representación.

Este enfoque también muestra cuándo una solución se está complicando. Si quieres contar, usa len(); si quieres convertir, construye una conversión explícita; si quieres recorrer elementos, no fabriques posiciones sin necesidad. La función corta no es necesariamente la función adecuada.

La frontera que no debes tratar como una función de conveniencia

Python incluye eval() entre sus funciones incorporadas, pero su disponibilidad no la convierte en una herramienta normal para interpretar entradas. La referencia oficial advierte que evalúa código arbitrario y que usarla con datos proporcionados por usuarios crea vulnerabilidades.

# Peligroso si expresion proviene de una persona o de una petición web
resultado = eval(expresion)

Si un principiante quiere convertir texto con una estructura limitada, puede explorar alternativas como ast.literal_eval() para literales permitidos, analizar el formato de manera explícita o usar JSON cuando el contrato sea JSON. La elección depende del dato, pero la regla es firme: una función incorporada puede tener un radio de acción demasiado grande para la entrada que recibe.

Esta es una de las razones por las que “está incorporada” no significa “es segura” ni “es adecuada”. La documentación existe para que puedas leer el contrato completo, incluidos errores, restricciones y advertencias.

Cuando las funciones forman una cadena, revisa el contrato entre cada paso

Los programas reales combinan funciones:

texto = input("Escribe precios separados por comas: ")
precios = [float(parte.strip()) for parte in texto.split(",")]
total = sum(precios)
print(f"Total: {total:.2f}")

Aquí input() produce texto, split() produce partes, strip() elimina espacios, float() convierte cada parte y sum() combina números. Si una etapa falla, no basta con envolver toda la cadena en una captura genérica. Hay que decidir qué dato se acepta, qué mensaje se muestra y si el total debe conservar precisión decimal.

La guía sobre estructuras de datos en Python puede ayudarte a ver cómo listas, diccionarios y conjuntos cambian el contrato de funciones como `len`, `enumerate` y las conversiones. El aprendizaje se vuelve más sólido cuando puedes seguir el tipo y la forma de los datos de principio a fin.

Qué deberías recordar cuando dejes de ser principiante

Las funciones incorporadas son pequeñas puertas hacia contratos distintos. `print()` hace visible, `len()` mide, `range()` estructura una iteración, `type()` investiga e `int()` o `float()` transforman bajo reglas específicas. La lista es fácil de memorizar; la pregunta que la vuelve útil es más importante: ¿qué garantía necesito de este paso?

Cuando una función no produce lo que esperabas, no cambies el nombre al azar. Lee qué acepta, qué devuelve, qué excepciones puede producir y qué información puede perder. Esa lectura convierte una colección de nombres conocidos en una forma de razonar sobre el programa.

¿Debo usar type() para validar todos mis datos?

No. Puede servir para investigar durante el aprendizaje, pero una función estable suele definir un contrato y validar el comportamiento que necesita. Cuando la relación de tipos es relevante, `isinstance()` o una conversión controlada suelen expresar mejor la intención.

¿range() crea una lista completa?

No necesariamente. Representa una sucesión de enteros que puede recorrerse. Convierte explícitamente a `list` solo cuando la siguiente operación necesita una lista materializada.

¿Es seguro usar eval() porque es una función de Python?

No con entrada no confiable. `eval()` puede ejecutar código arbitrario. Para datos limitados, usa un formato y un parser con un contrato más estrecho, como JSON o un mecanismo diseñado para literales permitidos.

¿Por qué una función incorporada lanza una excepción?

Porque la entrada no cumple el contrato de la operación. Una conversión puede rechazar un formato inválido, `len()` puede rechazar un objeto sin tamaño y `range()` puede requerir argumentos enteros. La excepción aporta información para decidir qué hacer.

Martin Rojas

Martin Rojas escribe sobre tecnología, programación y desarrollo web. En Skydutz Academy comparte explicaciones prácticas sobre herramientas digitales, conceptos de programación y recursos para aprender de forma progresiva. Su objetivo es hacer que los temas técnicos sean más claros, útiles y accesibles para lectores de distintos niveles.