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

lista de modulos de python (21)

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 (demasiado largo) un trazador de líneas:

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 alcance del sistema o al alcance 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 repositorio 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 repositorio 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.

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?

Si estás usando Python 3

Acabo de probar en Ubuntu, y parece que ha funcionado

Debian / Ubuntu: sudo apt-get install python3-matplotlib

Fedora: sudo dnf install python3-matplotlib

Red Hat: sudo yum install python3-matplotlib

Arco: sudo pacman -S python-matplotlib

Fuente: https://matplotlib.org/users/installing.html

para obtener todos los módulos disponibles, ejecute sys.modules
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

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.

Ahora, estos métodos los probé yo mismo, 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.

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

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.

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

pip list

Que parece ser azúcar sintáctica 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 los platos ni lustra los zapatos.

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.

En shell normal solo uso

pydoc modules

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 admite el CPython 2.

Explicación

sys.builtin_module_names : nombra todos los módulos incorporados (vea mi respuesta here )
pkgutil.iter_modules() : devuelve información sobre todos los módulos disponibles
importlib.util.find_spec() : devuelve información sobre el módulo de importación, si existe
BuiltinImporter - un importador para módulos incorporados ( docs )
SourceFileLoader : un importador para un módulo estándar de Python (por defecto tiene la extensión * .py) ( docs )
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: <class ''_frozen_importlib.BuiltinImporter''> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ _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: <class ''_frozen_importlib_external.SourceFileLoader''> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ __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: <class ''_frozen_importlib_external.ExtensionFileLoader''> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ _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: <class ''_frozen_importlib.BuiltinImporter''> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ _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: <class ''_frozen_importlib.SourceFileLoader''> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ __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: <class ''_frozen_importlib.ExtensionFileLoader''> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ _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*******************************)

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 fuente de documentación en 2.5 hay un pequeño script que enumera 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)

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.

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

Esto funciona también en un entorno virtual, por supuesto.

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

>>help(''modules package'')

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.

en windows, ingrese esto en cmd

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

pkgutil.iter_modules() 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]

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'']

help(''modules'')

en un shell / prompt de Python.

En ipython puedes escribir " import pestaña ".
En el intérprete estándar de Python, puede escribir " help(''modules'') ".
En la línea de comandos, puede usar los modules pydoc .
En un script, llame a pkgutil.iter_modules() .