¿Cómo puedo obtener una lista de los módulos de Python instalados localmente?

Me gustaría obtener una lista de los módulos de Python, que están en mi instalación de Python (servidor UNIX).

¿Cómo puede obtener una lista de los módulos de Python instalados en su computadora?

Solución

Mis 50 centavos para obtener una lista similar a la pip freeze desde un script de Python:

 import pip installed_packages = pip.get_installed_distributions() installed_packages_list = sorted(["%s==%s" % (i.key, i.version) for i in installed_packages]) print(installed_packages_list) 

Como un forro (demasiado largo):

 sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()]) 

Dando

 ['behave==1.2.4', 'enum34==1.0', 'flask==0.10.1', 'itsdangerous==0.24', 'jinja2==2.7.2', 'jsonschema==2.3.0', 'markupsafe==0.23', 'nose==1.3.3', 'parse-type==0.3.4', 'parse==1.6.4', 'prettytable==0.7.2', 'requests==2.3.0', 'six==1.6.1', 'vioozer-metadata==0.1', 'vioozer-users-server==0.1', 'werkzeug==0.9.4'] 

Alcance

Esta solución se aplica al scope del sistema o al scope de un entorno virtual, y cubre los paquetes instalados por setuptools , pip y ( god easy_install ) easy_install .

Mi caso de uso

Agregué el resultado de esta llamada a mi servidor de matraz, así que cuando lo llamo con http://example.com/exampleServer/environment , obtengo la lista de paquetes instalados en el virtualenv del servidor. Hace mucho más fácil la depuración.

Advertencias

He notado un comportamiento extraño de esta técnica: cuando se invoca al intérprete de Python en el mismo directorio que un archivo setup.py , no se muestra el paquete instalado por setup.py .

Pasos para reproducir:

Crear un entorno virtual.

 $ cd /tmp $ virtualenv test_env New python executable in test_env/bin/python Installing setuptools, pip...done. $ source test_env/bin/activate (test_env) $ 

setup.py un repository git con setup.py

 (test_env) $ git clone https://github.com/behave/behave.git Cloning into 'behave'... remote: Reusing existing pack: 4350, done. remote: Total 4350 (delta 0), reused 0 (delta 0) Receiving objects: 100% (4350/4350), 1.85 MiB | 418.00 KiB/s, done. Resolving deltas: 100% (2388/2388), done. Checking connectivity... done. 

Tenemos setup.py de setup.py en /tmp/behave :

 (test_env) $ ls /tmp/behave/setup.py /tmp/behave/setup.py 

Instala el paquete python desde el repository de git.

 (test_env) $ cd /tmp/behave && python setup.py install running install ... Installed /private/tmp/test_env/lib/python2.7/site-packages/enum34-1.0-py2.7.egg Finished processing dependencies for behave==1.2.5a1 

Si ejecutamos la mencionada solución desde /tmp

 >>> import pip >>> sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()]) ['behave==1.2.5a1', 'enum34==1.0', 'parse-type==0.3.4', 'parse==1.6.4', 'six==1.6.1'] >>> import os >>> os.getcwd() '/private/tmp' 

Si ejecutamos la solución antes mencionada desde /tmp/behave

 >>> import pip >>> sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()]) ['enum34==1.0', 'parse-type==0.3.4', 'parse==1.6.4', 'six==1.6.1'] >>> import os >>> os.getcwd() '/private/tmp/behave' 

behave==1.2.5a1 falta en el segundo ejemplo, porque el directorio de trabajo contiene el archivo setup.py .

No pude encontrar ninguna referencia a este problema en la documentación. Tal vez debería abrir un error para ello.

 help('modules') 

en un shell / prompt de Python.

Ahora, estos métodos los probé y obtuve exactamente lo que se anunciaba: Todos los módulos.

Lamentablemente, realmente no te importa mucho el stdlib, sabes lo que obtienes con una instalación de python.

Realmente, quiero las cosas que instalé.

Lo que realmente, sorprendentemente, funcionó bien fue:

 pip freeze 

El cual regresó:

 Fabric==0.9.3 apache-libcloud==0.4.0 bzr==2.3b4 distribute==0.6.14 docutils==0.7 greenlet==0.3.1 ipython==0.10.1 iterpipes==0.4 libxml2-python==2.6.21 

Digo “sorprendentemente” porque la herramienta de instalación de paquetes es el lugar exacto en el que uno esperaría encontrar esta funcionalidad, aunque no con el nombre ‘congelar’, pero el empaque de Python es tan extraño, que me sorprende que esta herramienta tenga sentido. Pip 0.8.2, Python 2.7.

  • En ipython puede escribir ” import pestaña “.

  • En el intérprete de Python estándar, puede escribir ” help('modules') “.

  • En la línea de comandos, puede usar los modules pydoc .

  • En un script, llame a pkgutil.iter_modules() .

Desde la versión 1.3 de pip, tienes acceso a:

 pip list 

Lo que parece ser azúcar sintáctico para “congelar pip”. Enumera todos los módulos específicos de su instalación o virtualenv, junto con sus números de versión. Desafortunadamente, no muestra el número de versión actual de ningún módulo, ni lava sus platos ni lustra sus zapatos.

En shell normal solo uso

 pydoc modules 

Solo uso esto para ver los módulos utilizados actualmente:

 import sys as s s.modules.keys() 

que muestra todos los módulos que se ejecutan en su python.

Para todos los módulos incorporados use:

 s.modules 

Que es un dict que contiene todos los módulos y objetos de importación.

A partir de la pip 10, la respuesta aceptada ya no funcionará. El equipo de desarrollo ha eliminado el acceso a la rutina get_installed_distributions . Hay una función alternativa en las setuptools de setuptools para hacer lo mismo. Aquí hay una versión alternativa que funciona con pip 10:

 import pkg_resources installed_packages = pkg_resources.working_set installed_packages_list = sorted(["%s==%s" % (i.key, i.version) for i in installed_packages]) print(installed_packages_list) 

Por favor, hágamelo saber si funcionará o no en versiones anteriores de pip, también.

Si necesitamos listar los paquetes instalados en el shell de Python, podemos usar el comando de help siguiente manera

 >>help('modules package') 

Normalmente uso la pip list para obtener una lista de paquetes (con versión).

Esto también funciona en un entorno virtual, por supuesto. Para mostrar lo que está instalado solo en el entorno virtual (no en paquetes globales), use pip list -local .

Aquí hay documentación que muestra todas las opciones de pip list disponibles, con varios buenos ejemplos.

Búsqueda muy simple usando pkgutil.iter_modules

 from pkgutil import iter_modules a=iter_modules() while True: try: x=a.next() except: break if 'searchstr' in x[1]: print x[1] 

Me encontré con un python 2.7 instalado a medida en OS X. Se requería que X11 listara los módulos instalados (ambos usando ayuda y pydoc).

Para poder listar todos los módulos sin instalar X11, ejecuté pydoc como servidor http, es decir:

 pydoc -p 12345 

Entonces es posible dirigir Safari a http://localhost:12345/ para ver todos los módulos.

en windows, ingresa esto en cmd

 c:\python\libs>python -m pip freeze 

Aparte de usar pip freeze , he estado instalando yolk en mis entornos virtuales.

  1. para obtener todos los módulos disponibles, ejecute sys.modules
  2. para obtener todos los módulos instalados (lea: instalado por pip ), puede mirar pip.get_installed_distributions()

Para el segundo propósito, código de ejemplo:

 import pip for package in pip.get_installed_distributions(): name = package.project_name # SQLAlchemy, Django, Flask-OAuthlib key = package.key # sqlalchemy, django, flask-oauthlib module_name = package._get_metadata("top_level.txt") # sqlalchemy, django, flask_oauthlib location = package.location # virtualenv lib directory etc. version = package.version # version number 

Esta solución se basa principalmente en los módulos importlib y pkgutil y funciona con CPython 3.4 y CPython 3.5, pero no tiene soporte para el CPython 2.


Explicación

  1. sys.builtin_module_names : nombra todos los módulos incorporados (vea mi respuesta aquí )
  2. pkgutil.iter_modules() : devuelve información sobre todos los módulos disponibles
  3. importlib.util.find_spec() : devuelve información sobre el módulo de importación, si existe
  4. BuiltinImporter – un importador para módulos incorporados ( docs )
  5. SourceFileLoader : un importador para un módulo estándar de Python (por defecto tiene la extensión * .py) ( docs )
  6. ExtensionFileLoader : un importador de módulos como biblioteca compartida (escrito en C o C ++)

Codigo completo

 import sys import os import shutil import pkgutil import importlib import collections if sys.version_info.major == 2: raise NotImplementedError('CPython 2 is not supported yet') def main(): # name this file (module) this_module_name = os.path.basename(__file__).rsplit('.')[0] # dict for loaders with their modules loaders = collections.OrderedDict() # names`s of build-in modules for module_name in sys.builtin_module_names: # find an information about a module by name module = importlib.util.find_spec(module_name) # add a key about a loader in the dict, if not exists yet if module.loader not in loaders: loaders[module.loader] = [] # add a name and a location about imported module in the dict loaders[module.loader].append((module.name, module.origin)) # all available non-build-in modules for module_name in pkgutil.iter_modules(): # ignore this module if this_module_name == module_name[1]: continue # find an information about a module by name module = importlib.util.find_spec(module_name[1]) # add a key about a loader in the dict, if not exists yet loader = type(module.loader) if loader not in loaders: loaders[loader] = [] # add a name and a location about imported module in the dict loaders[loader].append((module.name, module.origin)) # pretty print line = '-' * shutil.get_terminal_size().columns for loader, modules in loaders.items(): print('{0}\n{1}: {2}\n{0}'.format(line, len(modules), loader)) for module in modules: print('{0:30} | {1}'.format(module[0], module[1])) if __name__ == '__main__': main() 

Uso

Para el CPython3.5 (truncado)

 $ python3.5 python_modules_info.py ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 30:  ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ _ast | built-in _codecs | built-in _collections | built-in _functools | built-in _imp | None _io | built-in _locale | built-in _operator | built-in _signal | built-in _sre | built-in _stat | built-in _string | built-in _symtable | built-in _thread | built-in (****************************truncated*******************************) ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 227:  ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ __future__ | /usr/local/lib/python3.5/__future__.py _bootlocale | /usr/local/lib/python3.5/_bootlocale.py _collections_abc | /usr/local/lib/python3.5/_collections_abc.py _compat_pickle | /usr/local/lib/python3.5/_compat_pickle.py _compression | /usr/local/lib/python3.5/_compression.py _dummy_thread | /usr/local/lib/python3.5/_dummy_thread.py _markupbase | /usr/local/lib/python3.5/_markupbase.py _osx_support | /usr/local/lib/python3.5/_osx_support.py _pydecimal | /usr/local/lib/python3.5/_pydecimal.py _pyio | /usr/local/lib/python3.5/_pyio.py _sitebuiltins | /usr/local/lib/python3.5/_sitebuiltins.py (****************************truncated*******************************) ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 64:  ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ _bisect | /usr/local/lib/python3.5/lib-dynload/_bisect.cpython-35m-x86_64-linux-gnu.so _bz2 | /usr/local/lib/python3.5/lib-dynload/_bz2.cpython-35m-x86_64-linux-gnu.so _codecs_cn | /usr/local/lib/python3.5/lib-dynload/_codecs_cn.cpython-35m-x86_64-linux-gnu.so _codecs_hk | /usr/local/lib/python3.5/lib-dynload/_codecs_hk.cpython-35m-x86_64-linux-gnu.so _codecs_iso2022 | /usr/local/lib/python3.5/lib-dynload/_codecs_iso2022.cpython-35m-x86_64-linux-gnu.so (****************************truncated*******************************) 

Para el CPython3.4 (truncado)

 $ python3.4 python_modules_info.py ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 54:  ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ _ast | built-in _bisect | built-in _codecs | built-in _collections | built-in _datetime | built-in _elementtree | built-in _functools | built-in _heapq | built-in _imp | None _io | built-in _locale | built-in _md5 | built-in _operator | built-in _pickle | built-in _posixsubprocess | built-in _random | built-in (****************************truncated*******************************) ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 246:  ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ __future__ | /usr/lib/python3.4/__future__.py _bootlocale | /usr/lib/python3.4/_bootlocale.py _collections_abc | /usr/lib/python3.4/_collections_abc.py _compat_pickle | /usr/lib/python3.4/_compat_pickle.py _dummy_thread | /usr/lib/python3.4/_dummy_thread.py _markupbase | /usr/lib/python3.4/_markupbase.py _osx_support | /usr/lib/python3.4/_osx_support.py _pyio | /usr/lib/python3.4/_pyio.py (****************************truncated*******************************) ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 44:  ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ _bz2 | /usr/lib/python3.4/lib-dynload/_bz2.cpython-34m-x86_64-linux-gnu.so _codecs_cn | /usr/lib/python3.4/lib-dynload/_codecs_cn.cpython-34m-x86_64-linux-gnu.so _codecs_hk | /usr/lib/python3.4/lib-dynload/_codecs_hk.cpython-34m-x86_64-linux-gnu.so _codecs_iso2022 | /usr/lib/python3.4/lib-dynload/_codecs_iso2022.cpython-34m-x86_64-linux-gnu.so _codecs_jp | /usr/lib/python3.4/lib-dynload/_codecs_jp.cpython-34m-x86_64-linux-gnu.so _codecs_kr | /usr/lib/python3.4/lib-dynload/_codecs_kr.cpython-34m-x86_64-linux-gnu.so _codecs_tw | /usr/lib/python3.4/lib-dynload/_codecs_tw.cpython-34m-x86_64-linux-gnu.so _crypt | /usr/lib/python3.4/lib-dynload/_crypt.cpython-34m-x86_64-linux-gnu.so (****************************truncated*******************************) 

pip freeze lo hace todo para encontrar paquetes, sin embargo, uno puede simplemente escribir el siguiente comando para enumerar todas las rutas donde están los paquetes de Python.

 >>> import site; site.getsitepackages() ['/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages'] 

Esto fue inspirado por la respuesta de Adam Matan (la aceptada):

 import tabulate try: from pip import get_installed_distributions except: from pip._internal.utils.misc import get_installed_distributions tabpackages = [] for _, package in sorted([('%s %s' % (i.location, i.key), i) for i in get_installed_distributions()]): tabpackages.append([package.location, package.key, package.version]) print(tabulate.tabulate(tabpackages)) 

que luego imprime una tabla en forma de

 19:33 pi@rpi-v3 [iot-wifi-2] ~/python$ python installed_packages.py ------------------------------------------- -------------- ------ /home/pi/.local/lib/python2.7/site-packages enum-compat 0.0.2 /home/pi/.local/lib/python2.7/site-packages enum34 1.1.6 /home/pi/.local/lib/python2.7/site-packages pexpect 4.2.1 /home/pi/.local/lib/python2.7/site-packages ptyprocess 0.5.2 /home/pi/.local/lib/python2.7/site-packages pygatt 3.2.0 /home/pi/.local/lib/python2.7/site-packages pyserial 3.4 /usr/local/lib/python2.7/dist-packages bluepy 1.1.1 /usr/local/lib/python2.7/dist-packages click 6.7 /usr/local/lib/python2.7/dist-packages click-datetime 0.2 /usr/local/lib/python2.7/dist-packages construct 2.8.21 /usr/local/lib/python2.7/dist-packages pyaudio 0.2.11 /usr/local/lib/python2.7/dist-packages tabulate 0.8.2 ------------------------------------------- -------------- ------ 

lo que le permite discernir fácilmente qué paquetes ha instalado con y sin sudo .


Una nota aparte: he notado que cuando instalo un paquete una vez a través de sudo y una vez sin, uno tiene prioridad para que el otro no esté en la lista (solo se muestra una ubicación). Creo que solo aparece el que está en el directorio local. Esto podría mejorarse.

En caso de que tenga instalada una distribución python de anaconda , también puede usar

 $conda list 

además de las soluciones descritas anteriormente.

Hay muchas ideas, inicialmente estoy reflexionando sobre estas dos:

pipa

contras: no siempre instalado

ayuda (‘modulos’)

contras: salida a consola; con módulos rotos (ver ubuntu …) puede segfault

Necesito un enfoque fácil, usando bibliotecas básicas y compatibles con el antiguo python 2.x

Y veo la luz: listmodules.py

Oculto en el directorio de origen de la documentación en 2.5 hay un pequeño script que lista todos los módulos disponibles para una instalación de Python.

Pros:

usa solo imp, sys, os, re, time

diseñado para ejecutarse en Python 1.5.2 y posteriores

El código fuente es realmente compacto, por lo que puede hacer pequeños retoques con él, por ejemplo, para pasar una lista de excepciones de módulos con errores (no intente importarlos)

Hay muchas formas de despellejar a un gato.

  • La forma más sencilla es usar la función pydoc directamente desde el shell con:
    pydoc modules

  • Pero para obtener más información, use la herramienta llamada pip-date que también le informa las fechas de instalación.
    pip install pip-date


introduzca la descripción de la imagen aquí

Necesitaba encontrar la versión específica de los paquetes disponibles de forma predeterminada en AWS Lambda. Lo hice con una mezcla de ideas de esta página. Lo estoy compartiendo para la posteridad.

 import pkgutil __version__ = '0.1.1' def get_ver(name): try: return str(__import__(name).__version__) except: return None def lambda_handler(event, context): return { 'statusCode': 200, 'body': [{ 'path': m.module_finder.path, 'name': m.name, 'version': get_ver(m.name), } for m in list(pkgutil.iter_modules()) #if m.module_finder.path == "/var/runtime" # Uncomment this if you only care about a certain path ], } 

Lo que descubrí es que la biblioteca de boto3 provista estaba muy desactualizada y no era mi culpa que mi código estuviera fallando. Solo necesitaba agregar boto3 y botocore a mi proyecto. Pero sin esto, me habría estado golpeando la cabeza pensando que mi código era malo.

 { "statusCode": 200, "body": [ { "path": "/var/task", "name": "lambda_function", "version": "0.1.1" }, { "path": "/var/runtime", "name": "bootstrap", "version": null }, { "path": "/var/runtime", "name": "boto3", "version": "1.9.42" }, { "path": "/var/runtime", "name": "botocore", "version": "1.12.42" }, { "path": "/var/runtime", "name": "dateutil", "version": "2.7.5" }, { "path": "/var/runtime", "name": "docutils", "version": "0.14" }, { "path": "/var/runtime", "name": "jmespath", "version": "0.9.3" }, { "path": "/var/runtime", "name": "lambda_runtime_client", "version": null }, { "path": "/var/runtime", "name": "lambda_runtime_exception", "version": null }, { "path": "/var/runtime", "name": "lambda_runtime_marshaller", "version": null }, { "path": "/var/runtime", "name": "s3transfer", "version": "0.1.13" }, { "path": "/var/runtime", "name": "six", "version": "1.11.0" }, { "path": "/var/runtime", "name": "test_bootstrap", "version": null }, { "path": "/var/runtime", "name": "test_lambda_runtime_client", "version": null }, { "path": "/var/runtime", "name": "test_lambda_runtime_marshaller", "version": null }, { "path": "/var/runtime", "name": "urllib3", "version": "1.24.1" }, { "path": "/var/lang/lib/python3.7", "name": "__future__", "version": null }, ... 

Lo que descubrí también fue diferente de lo que publican oficialmente . En el momento de escribir esto:

  • Sistema operativo – Amazon Linux
  • AMI – amzn-ami-hvm-2017.03.1.20170812-x86_64-gp2
  • Kernel de Linux – 4.14.77-70.59.amzn1.x86_64
  • AWS SDK para JavaScript – 2.290.0 \
  • SDK para Python (Boto 3) – 3-1.7.74 botocore-1.10.74

De la concha

 ls site-packages 

Si eso no es útil, puedes hacer esto.

 import sys import os for p in sys.path: print os.listdir( p ) 

Y ver qué produce.