Un error pequeño que confunde a casi todos
Casi todas las personas que empiezan con Python se topan tarde o temprano con este mensaje en la terminal: TypeError: 'module' object is not callable. Aparece de golpe, suele señalar una línea que a simple vista parece correcta y deja la sensación de que el intérprete se ha vuelto exigente sin motivo. Sin embargo, el mensaje es muy preciso: intentaste ejecutar con paréntesis algo que es un módulo, y los módulos no se pueden ejecutar como si fueran funciones.
Lo curioso es que el fallo no tiene que ver con la lógica de tu programa, sino con la forma en que Python organiza los nombres. Entre import random y from random import random hay una diferencia enorme, y esa diferencia es la raíz de la mayoría de estos errores. A lo largo de este tutorial vamos a recorrer qué es exactamente un módulo, por qué no es invocable, cuáles son las causas habituales y cómo detectarlas rápido, y qué hábitos y herramientas evitan que vuelva a ocurrir.
Para los ejemplos usaremos el entorno de una versión moderna de Python. En el momento de escribir esto, la rama estable más reciente que figura en la página oficial de descargas es Python 3.15, aunque todo lo que verás aquí funciona igual en cualquier 3.x actual, porque el modelo de importación de módulos lleva años sin cambios de fondo. Si trabajas con una versión anterior, no tendrás que adaptar nada.
El plan es el siguiente: primero entenderemos el mensaje, luego reproduciremos los casos más comunes con módulos de la biblioteca estándar y de terceros, después veremos fallos más sutiles como el sombreado de nombres y los archivos que se llaman igual que un módulo, y terminaremos con técnicas de depuración, linters y buenas prácticas.
Qué significa realmente el mensaje
Para leer bien el error conviene separar sus dos partes. TypeError indica que la operación es válida en general, pero se aplicó a un objeto de un tipo que no la soporta. Y 'module' object is not callable te dice cuál es ese tipo: module. En Python, un módulo es un objeto más, instancia de la clase types.ModuleType, que se crea cuando importas un archivo o un paquete.
Un objeto es invocable cuando admite la sintaxis objeto(argumentos). Lo son las funciones, los métodos, las clases (al llamarlas crean instancias) y cualquier instancia cuya clase defina el método especial __call__. Un módulo no cumple ninguna de esas condiciones: es un contenedor de nombres, un espacio donde viven funciones, clases y variables, pero no una función en sí.
Puedes comprobarlo en el intérprete con la función integrada callable, que devuelve True o False según el objeto admita llamadas.
import random
import datetime
print(type(random))
print(callable(random))
print(callable(random.randint))
print(callable(datetime))
print(callable(datetime.datetime))
La salida deja claro dónde está la frontera entre lo que se puede llamar y lo que no.
<class 'module'>
False
True
False
True
El módulo random no es invocable, pero la función random.randint sí. El módulo datetime tampoco, pero la clase datetime.datetime, que vive dentro de él, sí lo es. Fíjate en que esta última combinación ya anticipa uno de los errores más frecuentes, porque el módulo y la clase comparten nombre.
Reproducir el error en una línea
La forma más directa de provocarlo es escribir el nombre de un módulo seguido de paréntesis. Imagina que quieres un número aleatorio y, por costumbre, escribes esto.
import random
numero = random()
print(numero)
Al ejecutarlo, Python se detiene con un traceback breve.
Traceback (most recent call last):
File "sorteo.py", line 3, in <module>
numero = random()
TypeError: 'module' object is not callable
La causa es que import random enlaza el nombre random con el módulo completo. La función que querías, que también se llama random, está dentro del módulo, de modo que se accede con la notación de punto.
import random
numero = random.random()
print(numero)
Aquí random.random() significa: busca en el módulo random el atributo random y llámalo. La primera palabra es el contenedor, la segunda es la función. Esa duplicidad de nombres es justo lo que despista, y no es una casualidad exclusiva de este módulo: pasa con tqdm, con datetime, con time en algunos usos, con glob, con pprint y con muchos paquetes que reutilizan el nombre de su pieza principal.
El caso del módulo y la clase con el mismo nombre
El ejemplo más típico de la biblioteca estándar es datetime. El módulo se llama datetime y contiene una clase también llamada datetime, además de date, time y timedelta. Si importas el módulo y quieres la fecha de hoy, esto falla.
import datetime
ahora = datetime.now()
print(ahora)
El error en este caso es distinto, porque datetime.now no existe en el módulo y verás un AttributeError. Pero si intentas construir una fecha llamando al módulo directamente, aparece el que nos ocupa.
import datetime
entrega = datetime(2026, 12, 1)
print(entrega)
Traceback (most recent call last):
File "plazos.py", line 3, in <module>
entrega = datetime(2026, 12, 1)
TypeError: 'module' object is not callable
Hay dos soluciones equivalentes. La primera es mantener el import del módulo y acceder a la clase mediante el punto.
import datetime
entrega = datetime.datetime(2026, 12, 1)
hoy = datetime.datetime.now()
print(entrega - hoy)
La segunda es importar directamente la clase, de modo que el nombre datetime pase a referirse a ella y ya no al módulo.
from datetime import datetime
entrega = datetime(2026, 12, 1)
hoy = datetime.now()
print(entrega - hoy)
Ambas formas son correctas. Lo importante es ser coherente dentro de un mismo archivo: si importas la clase con from, no uses a la vez datetime.date, porque ese nombre ya no apunta al módulo. Mezclar los dos estilos en un archivo es la receta ideal para que el error reaparezca en una refactorización.
Importar el módulo cuando querías la función
Otro escenario muy común ocurre con código propio. Supón que organizas tu proyecto con un archivo por cada utilidad. Tienes un archivo llamado conversor.py que contiene una función conversor.
# conversor.py
def conversor(euros, tasa):
return round(euros * tasa, 2)
Desde otro archivo escribes lo siguiente, creyendo que importas la función.
# principal.py
import conversor
print(conversor(50, 1.08))
Python responde con el mismo error. El motivo es que import conversor importa el archivo conversor.py como módulo, y el nombre conversor pasa a ser ese módulo. La función está dentro, así que hay dos arreglos posibles. Puedes traer la función por su nombre.
# principal.py
from conversor import conversor
print(conversor(50, 1.08))
O bien puedes conservar el módulo y usar la notación de punto.
# principal.py
import conversor
print(conversor.conversor(50, 1.08))
La primera opción es más corta y deja el código de llamada más limpio. La segunda es más explícita sobre el origen de cada nombre, lo que ayuda cuando el proyecto crece. Una tercera alternativa, a menudo la mejor, es evitar la coincidencia de nombres desde el principio, por ejemplo llamando al archivo conversion_moneda.py y a la función convertir. Volveremos sobre esta idea más adelante.
Paquetes de terceros que reutilizan su nombre
Con las librerías externas la historia se repite. Un caso muy popular es tqdm, la utilidad de barras de progreso. El paquete se llama tqdm y la clase que se usa para envolver iterables también se llama tqdm, y está dentro del paquete. Esto falla:
import tqdm
import time
for paso in tqdm(range(5)):
time.sleep(0.2)
Traceback (most recent call last):
File "progreso.py", line 4, in <module>
for paso in tqdm(range(5)):
TypeError: 'module' object is not callable
La corrección sigue el mismo patrón que ya conoces: o bien importas la clase desde el paquete, o bien usas el punto.
from tqdm import tqdm
import time
for paso in tqdm(range(5)):
time.sleep(0.2)
import tqdm
import time
for paso in tqdm.tqdm(range(5)):
time.sleep(0.2)
Lo mismo ocurre con glob (el módulo contiene una función glob), con pprint (que incluye la función pprint), con copy (que tiene copy) y con tempfile en ciertas variantes de uso. Una regla práctica: si la documentación de una librería muestra from paquete import nombre, no asumas que import paquete te da ese mismo nombre ya listo para llamar.
import glob
import pprint
archivos = glob.glob("*.txt")
pprint.pprint(archivos)
Observa que en los dos casos se escribe el nombre dos veces. Es una señal visual de que el primer nombre es el contenedor y el segundo, el objeto invocable.
Cómo leer el traceback para ubicar la causa
Cuando aparece el error, el traceback es tu mejor amigo, y vale la pena aprender a leerlo de abajo hacia arriba. La última línea te da el tipo de error y el mensaje. La penúltima muestra el código exacto de la línea que falló, y las anteriores recorren la cadena de llamadas hasta ese punto.
Con este error, la pregunta que debes hacerte es siempre la misma: en la línea señalada, ¿qué nombre estoy llamando con paréntesis y a qué objeto apunta realmente? A menudo la respuesta es evidente al mirar los imports del principio del archivo. Si importaste el nombre con import nombre, lo que tienes en esa variable es un módulo. Si lo importaste con from algo import nombre, depende de lo que algo exporte con ese nombre, que puede ser otro módulo, una función o una clase.
Cuando el archivo es largo, resulta útil inspeccionar el objeto justo antes de la línea problemática. Dos herramientas bastan para eso.
import random
print(type(random))
print(random)
<class 'module'>
<module 'random' from '/usr/lib/python3.15/random.py'>
La representación del módulo incluye la ruta del archivo de donde se cargó. Ese dato es oro puro, porque permite descubrir si estás importando el módulo que crees o uno distinto, como veremos enseguida.
Sombreado de nombres: cuando tú mismo tapas la función
Hasta ahora el problema venía de importar mal. Pero existe una causa más traicionera: que el nombre apunte a una función durante un rato y luego, sin darte cuenta, se reasigne a un módulo. A este fenómeno se le llama sombreado de nombres, y consiste en que un identificador oculta a otro con el mismo nombre dentro de un ámbito.
Observa este ejemplo. Aquí se importa primero la función y después se importa el módulo, que ocupa el mismo nombre.
from random import random
import random
print(random())
La segunda línea sustituye el nombre random, que apuntaba a la función, por el módulo. El resultado es el mismo error, pero ahora la causa no está en la línea que falla sino dos líneas más arriba. Esto es especialmente engañoso cuando los imports están repartidos por un archivo largo, o cuando un bloque from modulo import * trae decenas de nombres sin que lo notes.
from math import *
from random import *
import time
print(sqrt(16))
print(random())
Con los imports con asterisco el orden importa y es difícil razonar sobre qué nombre ganó. Si dos módulos exportan un nombre igual, el último import prevalece. Por eso las guías de estilo desaconsejan esta forma, salvo en sesiones interactivas.
El sombreado también puede ocurrir con variables locales. Imagina que defines una variable con el nombre de un módulo y luego intentas usar una función de ese módulo.
import statistics
statistics = [4, 8, 15, 16, 23, 42]
print(statistics.mean(statistics))
Aquí el error será un AttributeError, porque statistics ya es una lista, pero ilustra el mecanismo: reutilizar el nombre de un módulo para una variable lo hace desaparecer. Dar a las variables nombres descriptivos y distintos (por ejemplo, valores) elimina el riesgo por completo.
El archivo que se llama igual que un módulo
Este es quizá el caso más desconcertante, y por eso merece su propia sección. Python busca los módulos siguiendo un orden: primero los módulos integrados, luego los directorios de sys.path, que incluye la carpeta del script que ejecutas. Si en esa carpeta existe un archivo llamado random.py, datetime.py o tqdm.py, ese archivo puede ser el que se importe en lugar del de la biblioteca estándar o el paquete instalado.
Supón esta estructura de directorios.
proyecto/
├── random.py
├── simulador.py
└── datos/
└── resultados.csv
Y este contenido en simulador.py.
import random
print(random.randint(1, 6))
Al ejecutarlo, no obtendrás un dado, sino un AttributeError que dice que el módulo random no tiene el atributo randint. Lo que se importó fue tu random.py, no el de la biblioteca estándar. En otras variantes, si tu archivo contiene una función con ese nombre y haces malabares con los imports, aparecerá el TypeError de módulo no invocable.
La señal inequívoca para detectar este caso está en la representación del módulo, que ya vimos antes.
import random
print(random)
print(random.__file__)
<module 'random' from '/home/usuario/proyecto/random.py'>
/home/usuario/proyecto/random.py
Si la ruta apunta a tu proyecto y no a la instalación de Python, ya sabes que hay un archivo que ensombrece al módulo real. La solución es renombrar el archivo propio, por ejemplo a dados_utils.py, y eliminar el directorio __pycache__ que pudo quedar con la versión compilada. Con __pycache__ presente, a veces el error persiste un rato tras renombrar, lo que confunde todavía más.
rm -rf __pycache__
python simulador.py
Una buena costumbre es no llamar nunca a tus archivos con el nombre de un módulo estándar. Algunos nombres peligrosos que se ven con frecuencia en proyectos de principiantes son random.py, test.py, email.py, json.py, string.py, types.py, queue.py, logging.py y calendar.py.
Depuración paso a paso con herramientas del propio Python
Cuando el error no es evidente, conviene tener un pequeño procedimiento. Estos son los pasos que mejor funcionan en la práctica.
- Localiza la línea exacta del traceback y anota el nombre que se está llamando.
- Imprime el tipo y el valor de ese nombre justo antes de la llamada.
- Si es un módulo, revisa su atributo
__file__para saber de dónde viene. - Busca en el archivo todas las líneas donde se asigna o importa ese nombre.
- Comprueba que no existe en tu proyecto un archivo con el mismo nombre que el módulo.
El primer paso puede reforzarse con el depurador integrado. Insertar breakpoint() justo antes de la línea problemática abre una sesión interactiva de pdb en la que puedes inspeccionar el estado.
import tqdm
datos = range(3)
breakpoint()
for d in tqdm(datos):
print(d)
> /home/usuario/proyecto/progreso.py(6)<module>()
-> for d in tqdm(datos):
(Pdb) type(tqdm)
<class 'module'>
(Pdb) tqdm.__file__
'/home/usuario/proyecto/.venv/lib/python3.15/site-packages/tqdm/__init__.py'
(Pdb) dir(tqdm)
La función dir lista todos los nombres que contiene el módulo, y entre ellos verás el atributo tqdm, que es la clase que buscabas. Esa pequeña inspección suele resolver la duda en segundos.
Otra técnica rápida es la introspección sin depurador. La función inspect.getmodule y la comprobación con isinstance te permiten escribir una verificación defensiva que explique el problema con un mensaje claro.
import types
def exigir_invocable(objeto, nombre):
if isinstance(objeto, types.ModuleType):
raise TypeError(
f"'{nombre}' es un módulo; importa la función o usa "
f"{nombre}.<atributo>()"
)
if not callable(objeto):
raise TypeError(f"'{nombre}' no es invocable")
return objeto
No necesitas llenar tu código de comprobaciones como esta, pero puede ser útil en capas de plugins o cargadores dinámicos, donde un nombre procede de configuración y no de un import estático.
Imports dinámicos y plugins
Hay un escenario en el que el error aparece sin que nadie haya escrito un import mal: la carga dinámica de código. Con importlib.import_module obtienes un módulo, nunca una función, aunque el nombre de la cadena coincida con la función que esperas.
import importlib
ruta = "json"
cargado = importlib.import_module(ruta)
resultado = cargado('{"a": 1}')
Traceback (most recent call last):
File "cargador.py", line 6, in <module>
resultado = cargado('{"a": 1}')
TypeError: 'module' object is not callable
La función import_module devuelve el módulo. Para llegar a un atributo concreto debes pedirlo con getattr o con la notación de punto.
import importlib
modulo = importlib.import_module("json")
analizar = getattr(modulo, "loads")
print(analizar('{"a": 1}'))
En sistemas de plugins es habitual definir la convención de que cada módulo exponga una función con un nombre fijo, por ejemplo ejecutar. El cargador importa el módulo y llama a modulo.ejecutar(). Documentar esa convención evita que quien escribe un plugin exporte el módulo esperando que se invoque directamente.
Confusiones con paquetes y su archivo de inicialización
Los paquetes añaden una capa más. Un paquete es un directorio con un archivo __init__.py, y lo que importas con import paquete es el contenido de ese __init__.py. Si la función que quieres está en un submódulo, tendrás que importarla desde ahí o reexportarla.
Considera esta estructura de un proyecto pequeño.
informes/
├── __init__.py
├── resumen.py
└── exportar.py
Si resumen.py define la función resumen, entonces import informes.resumen te da el submódulo, no la función. Esto produce el mismo error al llamarlo.
import informes.resumen
informes.resumen("ventas")
La forma correcta de importar la función es esta.
from informes.resumen import resumen
resumen("ventas")
Si quieres ofrecer una interfaz más cómoda a quienes usen tu paquete, puedes reexportar la función en __init__.py. Así, el usuario escribe from informes import resumen y obtiene directamente la función. Pero cuidado con una trampa sutil: si dentro de __init__.py haces from .resumen import resumen, el nombre resumen del paquete pasa a referirse a la función y deja de referirse al submódulo, lo cual cambia el comportamiento de informes.resumen. Es una decisión de diseño que conviene tomar con conocimiento.
# informes/__init__.py
from .resumen import resumen
from .exportar import exportar_csv
__all__ = ["resumen", "exportar_csv"]
Con la lista __all__ indicas qué nombres forman la interfaz pública del paquete, y ayudas a los linters y a los editores a ofrecer sugerencias correctas.
Linters y verificadores de tipos que lo detectan antes de ejecutar
Lo ideal es que el error nunca llegue a producirse en tiempo de ejecución. Las herramientas de análisis estático saben que un módulo no es invocable y pueden avisarte mientras escribes. Varias merecen la pena.
Los verificadores de tipos como mypy y pyright analizan el código sin ejecutarlo y marcan llamadas sobre objetos que no admiten __call__. Con el ejemplo de random, el mensaje que verías sería parecido a este.
sorteo.py:3: error: Module not callable [operator]
Found 1 error in 1 file (checked 1 source file)
Pyright en el editor subraya la expresión con un texto similar, e indica que el tipo del objeto es Module. Esa retroalimentación inmediata ahorra el ciclo de ejecutar, leer el traceback y volver al código.
Los linters como Ruff y Pylint detectan problemas relacionados con los imports: nombres redefinidos, imports no usados, imports con asterisco y variables que sombrean módulos. Pylint, por ejemplo, tiene reglas para avisar de que un nombre importado se redefine, y Ruff incluye reglas equivalentes más una gran colección de comprobaciones sobre el orden y la forma de los imports. Una configuración mínima en pyproject.toml podría ser la siguiente.
[tool.ruff]
line-length = 88
[tool.ruff.lint]
select = ["E", "F", "I", "A", "N"]
Aquí F cubre los errores de pyflakes, como los nombres redefinidos o no usados, I ordena los imports, A avisa cuando un nombre propio tapa una función integrada y N revisa convenciones de nombres. Con esta combinación, muchos casos de sombreado quedan al descubierto en el momento de guardar el archivo.
Si trabajas en un equipo, integra estas comprobaciones en un hook de pre-commit o en tu integración continua. Un error que cuesta diez segundos detectar en el editor cuesta mucho más cuando llega a una revisión de código o a producción.
ruff check .
mypy .
Reglas de estilo para evitar el error de raíz
Más allá de las herramientas, unos pocos hábitos eliminan casi todos los casos. Reunirlos en un conjunto pequeño y repetible es más eficaz que depender de la memoria.
- Prefiere
import moduloy llama conmodulo.funcion()cuando el módulo es pequeño o el nombre del atributo puede resultar ambiguo. - Usa
from modulo import nombrecuando vas a utilizar pocas piezas muchas veces y el nombre es claro y único en tu archivo. - Evita el import con asterisco en código de producción.
- No llames a tus archivos como a módulos de la biblioteca estándar ni como a las librerías que instalas.
- Elige nombres de variables que no coincidan con módulos que importas.
- Si necesitas ambos, módulo y clase con el mismo nombre, renombra uno con
as.
La última regla merece un ejemplo, porque es una herramienta elegante y poco usada por quien empieza.
import datetime as dt
from datetime import datetime
inicio = datetime(2026, 1, 15)
fin = dt.date(2026, 3, 1)
print(fin - inicio.date())
Con el alias dt para el módulo, no hay ambigüedad entre el módulo y la clase. Lo mismo sirve para traer una función con un nombre que choca con otra: from random import random as azar te deja usar azar() sin conflicto, aunque conviene no abusar, porque demasiados alias degradan la legibilidad.
Un criterio útil para decidir entre los dos estilos de import es pensar en quien lee el código dentro de seis meses. Si al ver random() aislado tiene que subir al principio del archivo para saber qué es, quizá la forma con el punto sea más amable. Si el nombre ya es muy explícito, como sqrt o defaultdict, la importación directa no genera dudas.
Errores parecidos que no debes confundir
Algunos mensajes se parecen al que estamos tratando y tienen causas distintas. Reconocerlos te ahorra buscar en la dirección equivocada. Si quieres profundizar en la familia completa de fallos de tipo, tienes una explicación con casos reales en cómo resolver TypeError en Python con ejemplos prácticos, que cubre otras variantes como llamar a un entero o concatenar tipos incompatibles.
El primero es TypeError: 'int' object is not callable y sus parientes ('str', 'list', 'dict'). Aparece cuando un nombre que antes era una función se reasigna a un valor, por ejemplo al hacer sum = 10 y luego llamar a sum([1, 2]). El mecanismo es el mismo sombreado de nombres, aplicado a una función integrada.
total = sum([3, 4, 5])
print(total)
sum = 12
print(sum([1, 2]))
12
Traceback (most recent call last):
File "suma.py", line 5, in <module>
print(sum([1, 2]))
TypeError: 'int' object is not callable
El segundo es AttributeError: module 'x' has no attribute 'y'. Significa que el módulo se importó bien, pero el atributo no existe, ya sea por un error tipográfico, por una versión distinta de la librería o por un archivo propio que ensombrece al módulo real.
El tercero es ModuleNotFoundError, que ocurre antes de todo esto, cuando Python ni siquiera encuentra el módulo. Si esa es tu situación, la guía sobre la solución al problema común del error ModuleNotFoundError en Python explica cómo revisar entornos virtuales, rutas de búsqueda e instalaciones.
Esta distinción importa porque cada error ocurre en una fase diferente. El ModuleNotFoundError aparece al importar, el AttributeError al acceder a un nombre dentro del módulo, y el TypeError de módulo no invocable al usar el módulo con paréntesis. Saber en qué fase estás reduce mucho el campo de búsqueda.
Tipos de datos y por qué Python no te avisa antes
Una pregunta razonable es por qué Python no te avisa en el momento de la importación. La respuesta está en que es un lenguaje de tipado dinámico: los nombres son etiquetas que pueden apuntar a cualquier objeto, y el intérprete no comprueba qué tipo de objeto hay detrás hasta el instante de usarlo. Un nombre puede ser un módulo en una línea, una función en la siguiente y un entero después, y todo eso es legal.
Esta flexibilidad es potente, pero te traslada la responsabilidad de saber qué guarda cada nombre. Entender bien la diferencia entre tipos, y recordar que módulos, funciones y clases son todos objetos con su propio tipo, aclara mucho este error. Si quieres reforzar esa base, la guía completa para aprender Python pensando en tipos de datos repasa cómo funciona el sistema de tipos y cómo razonar sobre él.
Las anotaciones de tipos ayudan a recuperar parte de la seguridad perdida. Si anotas una función que recibe un invocable, el verificador de tipos puede avisar cuando le pases un módulo por error.
from collections.abc import Callable
def aplicar(operacion: Callable[[float], float], valor: float) -> float:
return operacion(valor)
import math
print(aplicar(math.sqrt, 49.0))
print(aplicar(math, 49.0))
La primera llamada es correcta. La segunda es un error que mypy o pyright marcarían sin ejecutar nada, porque math es un módulo y no cumple el tipo Callable. En tiempo de ejecución el segundo print fallaría con el mensaje que ya conocemos. Anotar parámetros que esperan funciones es una defensa barata y documenta la intención.
Un ejemplo completo, del fallo a la solución
Para atar todo, veamos un script pequeño que acumula varios de los problemas descritos, y arreglémoslo paso a paso. El programa simula tiradas de dados, registra la hora de cada una y muestra una barra de progreso.
import random
import datetime
import tqdm
def tirar(veces):
resultados = []
for _ in tqdm(range(veces)):
resultados.append(random.randint(1, 6))
return resultados
inicio = datetime()
datos = tirar(5)
print(datos, datetime.now() - inicio)
Este código contiene dos errores del mismo tipo. El primero está en tqdm(range(veces)), porque tqdm es el paquete. El segundo está en datetime(), porque datetime es el módulo y además datetime.now no existe en él. Python se detendrá en el primero que encuentre al ejecutar, y es habitual corregirlo y toparse enseguida con el segundo, lo que da la falsa impresión de que el error se resiste a desaparecer.
La versión corregida adopta un estilo coherente y aplica los hábitos descritos.
import random
from datetime import datetime
from tqdm import tqdm
def tirar(veces: int) -> list[int]:
resultados = []
for _ in tqdm(range(veces)):
resultados.append(random.randint(1, 6))
return resultados
inicio = datetime.now()
datos = tirar(5)
print(datos, datetime.now() - inicio)
Fíjate en los cambios. Se importa la clase datetime del módulo, de modo que datetime.now() funciona. Se importa la clase tqdm del paquete homónimo. Se mantiene import random porque se usa una sola función con el prefijo del módulo, lo que deja claro el origen de randint. Los imports están agrupados: biblioteca estándar primero y terceros después, como recomiendan las guías de estilo. Además, la función tiene anotaciones de tipos, que ayudan al verificador a ayudarte.
Una vez corregido, la salida será algo parecido a esto.
100%|██████████| 5/5 [00:00<00:00, 71234.05it/s]
[4, 1, 6, 3, 3] 0:00:00.001284
Casos reales en proyectos grandes
En proyectos de tamaño medio o grande, este error tiene sabores propios que conviene reconocer. Uno de ellos son los imports circulares. Cuando dos módulos se importan mutuamente, Python puede entregar un módulo a medio inicializar, y los nombres que esperabas todavía no existen. Con un from a import b en el módulo equivocado, el resultado puede ser un ImportError, pero con import a y uso posterior se obtienen módulos incompletos que luego fallan de formas extrañas.
Otro caso frecuente es el de los notebooks. En un cuaderno interactivo, el estado persiste entre celdas, y es fácil ejecutar una celda con from random import random y después otra con import random. Si luego vuelves a ejecutar la primera en un orden distinto, el nombre cambia de significado sin que el código haya cambiado. Reiniciar el kernel y ejecutar todo de arriba abajo es la prueba más simple para confirmar que el cuaderno es reproducible y que el error no se debe a un estado residual.
También ocurre con frecuencia al copiar fragmentos de documentación o de respuestas de foros. Un ejemplo que funciona en un contexto, con su from correspondiente en la cabecera del archivo, se pega sin ese import y falla. Conviene leer siempre las primeras líneas del fragmento, no solo la llamada.
Por último, hay que mencionar los entornos con varias versiones de una librería. Algunos paquetes cambiaron su interfaz entre versiones: lo que antes se importaba como módulo ahora es una clase, o al revés. Si tras una actualización un código que funcionaba empieza a fallar con este error, revisa las notas de cambios de la librería y fija versiones en tu archivo de dependencias para que el entorno sea reproducible.
python -m pip show tqdm
python -m pip freeze > requirements.txt
Lista de comprobación rápida cuando aparece el error
Cuando te encuentres con el mensaje, recorre mentalmente esta lista antes de cambiar nada al azar.
- ¿El nombre que llamo con paréntesis viene de un
import nombre? Entonces es un módulo y necesita el punto o un import distinto. - ¿Existe en mi proyecto un archivo o carpeta con el mismo nombre que el módulo? Renómbralo y borra
__pycache__. - ¿Reasigné ese nombre más arriba en el archivo, o lo traje con un import con asterisco?
- ¿La documentación de la librería usa
from paquete import nombre? Replica esa forma. - ¿Estoy en un notebook con celdas ejecutadas en desorden? Reinicia el kernel.
- ¿Mi linter o verificador de tipos tiene algo que decir sobre esa línea?
Con la práctica, este recorrido se vuelve automático y la mayoría de los casos se resuelven mirando únicamente la cabecera de imports. De hecho, una buena forma de ganar velocidad es leer siempre los imports antes que el resto del archivo: tardas unos segundos y sabes de qué nombres puedes fiarte.
Preguntas frecuentes sobre el error
Una duda habitual es si se puede hacer que un módulo sea invocable. Técnicamente es posible, aunque no suele recomendarse. Python permite reemplazar la entrada del módulo en sys.modules por un objeto de una clase que defina __call__, o asignar a __class__ del módulo una subclase de types.ModuleType con ese método. Algunos paquetes lo han hecho para ofrecer una interfaz cómoda, pero rompe las expectativas de quienes leen el código y confunde a los verificadores de tipos. Si tu objetivo es que import utilidad y utilidad() funcionen a la vez, es más claro ofrecer una función en el paquete y documentarla.
Otra pregunta es si existe diferencia de rendimiento entre import modulo y from modulo import nombre. En la práctica es despreciable. El módulo se carga una sola vez y queda en sys.modules; lo único que cambia es qué nombres enlazas en tu espacio local. Una llamada con el punto añade una búsqueda de atributo, pero el coste es mínimo salvo en bucles extremadamente ajustados, donde puedes asignar la función a una variable local antes del bucle. Elige el estilo por claridad, no por velocidad.
También se pregunta si el error cambia entre versiones de Python. El mensaje y su significado llevan siendo los mismos durante muchos años, y siguen vigentes en la serie actual. Lo que sí ha mejorado es la calidad de los mensajes de error en versiones recientes, que a menudo sugieren nombres parecidos cuando escribes mal un atributo, y los tracebacks, que ahora resaltan con más precisión la parte de la línea que falló. Pero la causa y la solución son idénticas.
Por último, mucha gente quiere saber si conviene usar siempre el estilo con punto para evitar sorpresas. Es una opción segura y perfectamente defendible, y de hecho varias guías de estilo la favorecen para módulos de la biblioteca estándar. La importación directa tiene su lugar para nombres inconfundibles y muy usados. Lo esencial es que el estilo sea consistente en todo el proyecto y que lo respalde un linter.
Conclusiones
El mensaje TypeError: 'module' object is not callable es una forma muy literal de decirte que llamaste a un módulo como si fuera una función. En casi todos los casos la causa es una de estas: usar import nombre cuando querías la función o clase que lleva el mismo nombre, reasignar o ensombrecer un nombre con otro import, o tener en tu proyecto un archivo con el mismo nombre que un módulo que quieres importar.
La solución es directa una vez entiendes que un módulo es un contenedor de nombres. Puedes acceder al objeto con la notación de punto, como en random.random(), o importarlo explícitamente con from modulo import nombre. Cuando el origen del problema es un archivo que tapa a la biblioteca estándar, basta con renombrarlo y limpiar la caché de bytecode.
Para que no vuelva a pasar, adopta unos pocos hábitos: evita los imports con asterisco, elige nombres de archivo y de variable que no choquen con módulos conocidos, usa alias con as cuando necesites convivir con nombres repetidos, y apóyate en linters y verificadores de tipos que te avisen mientras escribes. Con depuración básica, usando type, callable, __file__ y dir, puedes diagnosticar cualquier caso en pocos segundos. Lo que hoy parece un error molesto se convierte, con este conocimiento, en una pista fiable sobre cómo están organizados tus imports.
