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 módulos Python instalados en su computadora?
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 módulos Python instalados en su computadora?
Respuestas:
Mis 50 centavos para obtener una pip freeze
lista similar de 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 revestimiento (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']
Esta solución se aplica al ámbito de aplicación del sistema o a un ámbito entorno virtual, y los paquetes de cubiertas instalado por setuptools
, pip
y ( God Forbid ) easy_install
.
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 virtualenv del servidor. Hace que la depuración sea mucho más fácil.
He notado un comportamiento extraño de esta técnica: cuando se invoca el intérprete de Python en el mismo directorio que un setup.py
archivo, no enumera el paquete instalado por setup.py
.
$ cd /tmp
$ virtualenv test_env
New python executable in test_env/bin/python
Installing setuptools, pip...done.
$ source test_env/bin/activate
(test_env) $
Clonar 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.
Nos hemos comportado setup.py
en /tmp/behave
:
(test_env) $ ls /tmp/behave/setup.py
/tmp/behave/setup.py
Instale el paquete python desde el repositorio git
(test_env) $ cd /tmp/behave && pip 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
/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'
/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 behave
el setup.py
archivo 's .
No pude encontrar ninguna referencia a este problema en la documentación. Quizás deba abrir un error para ello.
import pkg_resources; installed_packages = [(d.project_name, d.version) for d in pkg_resources.working_set]
AttributeError: module 'pip' has no attribute 'get_installed_distributions'
.
help('modules')
en un shell / indicador de Python.
pydoc modules
funciona. Debe enviarlo como respuesta.
python -c 'help("modules")'
Ahora, estos métodos los probé yo mismo y obtuve exactamente lo que se anunciaba: todos los módulos.
Por desgracia, realmente no te importa mucho el stdlib, sabes lo que obtienes con una instalación de Python.
Realmente, quiero las cosas que he instalado.
Lo que en realidad, sorprendentemente, funcionó bien fue:
pip freeze
Que volvió:
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 bajo el nombre 'congelar', pero el empaque de Python es tan extraño, que estoy asombrado de que esta herramienta tenga sentido. Pip 0.8.2, Python 2.7.
Desde pip versión 1.3, tienes acceso a:
pip list
Que parece ser azúcar sintáctico para "congelación de pepita". Enumerará 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 tus zapatos.
pip list --local
para distinguir entre virtualenv
paquetes de sitios globales y, discutidos aquí .
pip list
Es el más simple y el mejor. Aquí están las opciones y detalles.
En ipython
puedes escribir " import
Tab".
En el intérprete estándar de Python, puede escribir " help('modules')
".
En la línea de comandos, puede usar .pydoc
modules
En un guión, llame pkgutil.iter_modules()
.
pkgutil.iter_modules()
funciona, la solución pip anterior no enumera todos los paquetes, solo los instalados a través de pip.
python -c 'import pkgutil;print [x[1] for x in list(pkgutil.iter_modules())]'
. Debería volcar todos los nombres de los módulos como una gran lista de Python. El x[1]
bit se utiliza para extraer el nombre del módulo de las tuplas generadas por pkgutil.iter_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 integrados, use:
s.modules
Que es un dict que contiene todos los módulos y objetos de importación.
pydoc
ni pip
instalados (un NAS en mi caso).
help('modules')
simplemente cuelga sin respuesta para mí. Pero este enfoque sys
funciona perfectamente
En shell normal solo use
pydoc modules
py -m pydoc modules
en cmd o Powershell.
pydoc modules
no funcionó para mí en Windows 10 con Python 3.6, pero la modificación @VKK: py -m pydoc modules
funciona en cmd / Powershell.
A partir del pip 10, la respuesta aceptada ya no funcionará. El equipo de desarrollo ha eliminado el acceso a la get_installed_distributions
rutina. Hay una función alternativa 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)
Avíseme si también funcionará o no en versiones anteriores de pip.
pip freeze
; La profundidad de mi conocimiento sobre este tema es bastante limitada. De alguna manera busqué la solución cuando la respuesta aceptada no funcionó para mí y traté de combinarla con una respuesta relacionada setuptools
y la puse a funcionar.
get_installed_distributions routine
.
setuptools
.
Normalmente uso 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 pip list
opciones 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]
for m in iter_modules()
y funcionó también.
Me encontré con un python 2.7 personalizado instalado en OS X. Se requería X11 para enumerar los módulos instalados (tanto usando ayuda como pydoc).
Para poder enumerar todos los módulos sin instalar X11, ejecuté pydoc como servidor http, es decir:
pydoc -p 12345
Entonces es posible dirigir Safari http://localhost:12345/
para ver todos los módulos.
Prueba estos
pip list
o
pip freeze
En terminal o IPython, escriba:
help('modules')
entonces
In [1]: import #import press-TAB
Display all 631 possibilities? (y or n)
ANSI audiodev markupbase
AptUrl audioop markupsafe
ArgImagePlugin avahi marshal
BaseHTTPServer axi math
Bastion base64 md5
BdfFontFile bdb mhlib
BmpImagePlugin binascii mimetools
BufrStubImagePlugin binhex mimetypes
CDDB bisect mimify
CDROM bonobo mmap
CGIHTTPServer brlapi mmkeys
Canvas bsddb modulefinder
CommandNotFound butterfly multifile
ConfigParser bz2 multiprocessing
ContainerIO cPickle musicbrainz2
Cookie cProfile mutagen
Crypto cStringIO mutex
CurImagePlugin cairo mx
DLFCN calendar netrc
DcxImagePlugin cdrom new
Dialog cgi nis
DiscID cgitb nntplib
DistUpgrade checkbox ntpath
Esta solución se basa principalmente en módulos importlib
y pkgutil
funciona con CPython 3.4 y CPython 3.5, pero no es compatible con CPython 2.
Explicación
sys.builtin_module_names
- nombra todos los módulos integrados (mira mi respuesta aquí )pkgutil.iter_modules()
- devuelve información sobre todos los módulos disponiblesimportlib.util.find_spec()
- devuelve información sobre la importación del módulo, si existeBuiltinImporter
- un importador de módulos integrados ( docs )SourceFileLoader
- un importador para un módulo Python estándar (por defecto tiene la extensión * .py) ( docs )ExtensionFileLoader
- un importador de módulos como biblioteca compartida (escrito en C o C ++)Código 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*******************************)
pip
sistema de administración de paquetes utilizado para instalar y administrar paquetes de software escritos en Python y un resultado pip.get_installed_distributions()
devuelve módulos instalados con el pip. Mi respuesta se basa completamente en la biblioteca estándar de Python y cubre todos los módulos disponibles para importar. Mi mayor inconveniente es mi respuesta: no hay soporte para el CPython 2.
**truncated**
, donde se trunca una salida. Tal vez no tenga cuidado, pero si no lo hace, así que para enviarme una información sobre su sistema y la implementación de Python, haré una investigación adicional para solucionarlo.
Advertencia: Adam Matan desaconseja este uso en pip> 10.0. Además, lea el comentario de @ sinoroc a continuación
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 instaló con y sin sudo
.
Una nota a un lado: He notado que cuando instalo un paquete una vez a través sudo
y una vez sin él, uno tiene prioridad para que el otro no aparezca en la lista (solo se muestra una ubicación). Creo que solo aparece el que está en el directorio local. Esto podría mejorarse.
pip
una vez y luego salir. Parece ser más un problema que el comportamiento podría cambiar.
_internal
). En general, obviamente funciona, pero es una mala práctica. Hay mejores alternativas, algunas están en las otras respuestas a esta pregunta.
Además de usar pip freeze
, he estado instalando yema en mis entornos virtuales.
En caso de que tenga instalada una distribución anaconda python , también puede usar
$conda list
Además de las soluciones descritas anteriormente.
conda install
, debería funcionar :)
sys.modules
pip
), puede mirarpip.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
/usr/bin/python
o el de python.org ? Para el primero, puedo usar sys.modules
sin problemas.
system.modules
lugar de sys.modules
.
Ejecute lo siguiente en su editor de Python o IPython
import pkg_resources;
installed_packages = {d.project_name: d.version for d in pkg_resources.working_set}
print(installed_packages)
Lea otras respuestas y reúna este combo, que es más rápido y fácil dentro de Python
pip freeze lo hace todo buscando paquetes, sin embargo, uno simplemente puede 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']
Hay muchas ideas, inicialmente estoy reflexionando sobre estas dos:
pipa
contras: no siempre instalado
ayuda ('módulos')
contras: salida a la consola; con módulos rotos (ver ubuntu ...) puede segfault
Necesito un enfoque fácil, usando bibliotecas básicas y compatible con python 2.x antiguo
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 más reciente
el código fuente es realmente compacto, por lo que puede modificarlo fácilmente, por ejemplo, para pasar una lista de excepción de módulos defectuosos (no intente importarlos)
Necesitaba encontrar la versión específica de los paquetes disponibles de forma predeterminada en AWS Lambda. Lo hice con una combinación 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 boto3 proporcionada estaba desactualizada y no fue mi culpa que mi código fallara. 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 publicaron oficialmente . Al 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
Instalación
pip install pkgutil
Código
import pkgutil
for i in pkgutil.iter_modules(None): # returns a tuple (path, package_name, ispkg_flag)
print(i[1]) #or you can append it to a list
Salida de muestra:
multiprocessing
netrc
nntplib
ntpath
nturl2path
numbers
opcode
pickle
pickletools
pipes
pkgutil
Aquí hay una solución de código de Python que devolverá una lista de módulos instalados. Uno puede modificar fácilmente el código para incluir números de versión.
import subprocess
import sys
from pprint import pprint
installed_packages = reqs = subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).decode('utf-8')
installed_packages = installed_packages.split('\r\n')
installed_packages = [pkg.split('==')[0] for pkg in installed_packages if pkg != '']
pprint(installed_packages)
Para cualquiera que se pregunte cómo llamar pip list
desde un programa Python, puede usar lo siguiente:
import pip
pip.main(['list]) # this will print all the packages
De la cáscara
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 mira lo que eso produce.