998

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?

python module pip Léo Léopold Hertz 준영
fuente

77

simplemente puede hacer >>> ayuda () y luego >>> módulos

Julius Naeumann

1

¿Hay una alternativa? help () me cuelga.

Paulo Carvalho

2

Muchas de estas respuestas suponen que tiene acceso a una línea de comando. Si está utilizando AWS Lambda, debe hacerlo todo desde Python. Ver stackoverflow.com/a/54939905/117471

Bruno Bronosky

610

Solución

¡No utilizar con pip> 10.0!

Mis 50 centavos para obtener una pip freezelista 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']

Alcance

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, pipy ( God Forbid ) 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 virtualenv del servidor. Hace que la depuración sea mucho más fácil.

Advertencias

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.pyarchivo, no enumera el paquete instalado por setup.py.

Pasos para reproducir:

Crea 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) $

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.pyen /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

Si ejecutamos la solución mencionada anteriormente 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 mencionada anteriormente 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.5a1falta en el segundo ejemplo, porque el directorio de trabajo contiene behaveel setup.pyarchivo 's .

No pude encontrar ninguna referencia a este problema en la documentación. Quizás deba abrir un error para ello.

Adam Matan
fuente

55

Gracias por esta respuesta! Creo que responde mejor la pregunta porque pregunto módulos Python instalados "localmente". La congelación de pepitas tampoco es siempre el camino a seguir. Esto funciona mejor, creo.

Léo Léopold Hertz 준영

3

@Masi acaba de agregar una explicación detallada de la advertencia de esta solución. De hecho es extraño.

Adam Matan

21

Una alternativa:import pkg_resources; installed_packages = [(d.project_name, d.version) for d in pkg_resources.working_set]

Ebolyen

14

A partir del pip 10, esta respuesta ya no funcionará. El comentario de @ebolyen muestra comandos alternativos que funcionan. Llegué a la misma conclusión y publiqué el código revisado completo a continuación.

Big_Al_Tx

55

En versiones recientes de pip, esto no funcionará, produciendo un mensaje de error que dice AttributeError: module 'pip' has no attribute 'get_installed_distributions'.

HelloGoodbye

1040

help('modules')

en un shell / indicador de Python.

ChristopheD
fuente

10

@dF pydoc modulesfunciona. Debe enviarlo como respuesta.

Abizern el

37

Me dio una falla seg!

zanbri

3

nobar, zanbri, @ Joe Frambach: en Ubuntu? Aquí se describe un error: bugs.launchpad.net/ubuntu/+source/python2.7/+bug/896836

ChristopheD

2

¿Cómo puedo obtener información adicional sobre dónde están instalados los módulos y cuál es la versión actual?

curioso

55

python -c 'help("modules")'

kenorb

285

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.

chiggsy
fuente

44

Supongo que la idea detrás del nombre es que obtienes una instantánea "congelada" de lo que está instalado en este momento, que luego puedes volver a alimentar en pip para obtener exactamente los mismos módulos instalados en un entorno diferente.

Ryan C. Thompson

Arash, ¡también puedes instalar pip en Windows! Primero instale setuptools y luego use easy_install para instalar pip :)

gawbul

Esto es excelente, pero parece perder algunas de las bibliotecas que instalé. Por ejemplo, no enumera PyQt.

Junuxx

8

A partir del pip 1.3 está el comando de lista .

Piotr Dobrogost

funciona. Qué desastre es Python. ¿Por qué no pueden actuar juntos y encontrar soluciones similares a las que existen en Rails? (Gemfile, bundler, rvm)

Dimitris

106

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.

Bryce
fuente

44

También hay pip list --localpara distinguir entre virtualenvpaquetes de sitios globales y, discutidos aquí .

Ioannis Filippidis

1

De lejos el mejor. También recupera las versiones.

aerijman

pip listEs el más simple y el mejor. Aquí están las opciones y detalles.

Levi Baguley

86

En ipythonpuedes escribir " importTab".
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().

Johnsyweb
fuente

55

pkgutil.iter_modules()funciona, la solución pip anterior no enumera todos los paquetes, solo los instalados a través de pip.

metaperture

2

¡Increíble! Creo que han mejorado la documentación, ya que se hizo la pregunta. pydoc modules spam busca spam en documentos de módulos. El último punto parece darle la información suficiente para usar el módulo. @metaperture ¿Puede, por favor, dar un ejemplo de cómo enumera todos los módulos locales instalados (no la lista masiva de stlib por ayuda ('módulos')) por pkgutil.iter_modules () .

Léo Léopold Hertz 준영

2

@ LéoLéopoldHertz 준영 Prueba este fragmento: 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().

Philip Conrad

76

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.

Dan Evans
fuente

2

# Después de importar sys "import sys as s" puede imprimir con: print sys.modules.keys ()

Dan Evans

No estoy seguro de por qué se editó mi publicación, pero gracias por usar la información que publiqué para corregir los errores en publicaciones anteriores. Devolverá errores si usa help () vs help (''). Esto también se aplica a dir ('') y sys (''), etc. Espero que esto ayude y no se elimine.

Dan Evans

Ignora mi última publicación, esta publicación no fue editada. Estaba pensando en una publicación similar que se encuentra aquí: stackoverflow.com/questions/139180/… Perdón por la confusión.

Dan Evans

77

Upvoted, porque este es el único método que parece funcionar en sistemas restringidos que no tienen pydocni pipinstalados (un NAS en mi caso).

Thomas

1

De acuerdo con Thomas. Estoy usando repl.it, por ejemplo, que también es un tipo de entorno restringido. help('modules')simplemente cuelga sin respuesta para mí. Pero este enfoque sysfunciona perfectamente

Sergiy Kolodyazhnyy

63

En shell normal solo use

pydoc modules

DrkNess
fuente

Parece que lo anterior solo funciona en plataformas 'nix. En cualquier caso, encontré y ejecuté el script, adaptando el comando de la siguiente manera: c: \ bin \ pythos_2.7 \ lib \ pydoc.py modules: esa lista tardó una eternidad en compilarse, el formato apesta y omite la versión instalada número. Pasaré.

David A. Gray

2

@ DavidA.Gray Acabo de probar esto en una máquina Windows con Python 3, y de hecho funciona. Usando el iniciador de ventanas de Python puedes hacerlo py -m pydoc modulesen cmd o Powershell.

VKK

pydoc modulesno funcionó para mí en Windows 10 con Python 3.6, pero la modificación @VKK: py -m pydoc modulesfunciona en cmd / Powershell.

Martin

41

A partir del pip 10, la respuesta aceptada ya no funcionará. El equipo de desarrollo ha eliminado el acceso a la get_installed_distributionsrutina. Hay una función alternativa setuptoolspara 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.

Big_Al_Tx
fuente

2

He estado buscando esta solución y destrozando mi cerebro tratando de descubrir pkg_resources. Si pudiera votar esto más de una vez, lo haría. ¡Gracias, @Big_Al_Tx! Actualización: Excepto ... cuando hago un 'congelamiento de pip' en mi entorno virtual y lo comparo con el resultado de esto, faltan paquetes. ¿Alguna idea de por qué eso podría / sucedería?

numberwhun

@numberwhun - Me alegra que esto haya funcionado para ti. Lo siento, pero no tengo una respuesta para la discrepancia con 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 setuptoolsy la puse a funcionar.

Big_Al_Tx

github.com/pypa/pip/issues/5243 - La charla del equipo de desarrollo sobre el acceso eliminado a get_installed_distributions routine.

bl79

@ bl79 - Creo que ese es el lugar exacto donde obtuve la referencia setuptools.

Big_Al_Tx

@Big_Al_Tx: Bueno, trabajé en torno a la opción setuptools (que era muy difícil de ofuscar para mis necesidades) y seguí con esto: installed_pkgs = subprocess.check_output (['pip', 'freeze']) Hace exactamente lo que yo lo necesitaba hacer ... ¡¡Yay !!

numberwhun

26

Si necesitamos enumerar los paquetes instalados en el shell de Python, podemos usar el helpcomando de la siguiente manera

>>help('modules package')

Sadheesh
fuente

22

Normalmente uso pip listpara 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 listopciones disponibles , con varios buenos ejemplos.

James
fuente

13

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]

estudiante
fuente

¿Hay alguna razón para usar while en lugar de un bucle for? Escribí usando for m in iter_modules()y funcionó también.

Joao Ponte

13

en windows, ingrese esto en cmd

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

Saurabh
fuente

Esto funcionó para mí usando: python3 -m pip freeze - para python 3.5.3.

dpminusa

Esto funciona bien y no necesita estar en el directorio libs también si sus variables están definidas

mcy

12

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.

Qiau
fuente

12

Prueba estos

pip list

o

pip freeze

Amit Gupta
fuente

Esto funciona desde una cáscara. Pero no dentro de Python

user7194913

12

Esto ayudará

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

X personificado
fuente

¡Esta debería ser la respuesta aceptada! Una línea :)

AlmostPitt

9

Esta solución se basa principalmente en módulos importliby pkgutilfunciona 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 disponibles
importlib.util.find_spec() - devuelve información sobre la importación del módulo, si existe
BuiltinImporter- 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*******************************)

PADYMKO
fuente

¿Puede comparar su enfoque con el enfoque de Adam aquí stackoverflow.com/a/23885252/54964

Léo Léopold Hertz 준영

@ Léo Léopold Hertz, ¿por qué lo necesitas?

PADYMKO

Para entender cómo su enfoque es mejor / peor que el enfoque de Adam.

Léo Léopold Hertz 준영

1

@ Léo Léopold Hertz. Una respuesta corta: pruébelo usted mismo en una producción y saque conclusiones usted mismo. Respuesta larga: el enfoque de Adam se basa en el pipsistema 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.

PADYMKO

1

@ Léo Léopold Hertz te equivocas, lo hace. Lo probé en mi computadora. Mi respuesta contiene un significado especial **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.

PADYMKO

9

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 sudoy 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.

Daniel F
fuente

1

No. Esto no se recomienda, ver aquí: pip.pypa.io/en/stable/user_guide/#using-pip-from-your-program

sinoroc

1

@sinoroc Gracias por señalar esto. Los puntos 1 a 3 no parecen ser aplicables a esta solución, ya que este script tiene el único propósito de usar pipuna vez y luego salir. Parece ser más un problema que el comportamiento podría cambiar.

Daniel F

De acuerdo, las razones por las que no hay una API pública no se aplican a este código en particular. Pero dado que pip no está obligado a garantizar una API pública, es libre de cambiar sus API internas, estructura de código, etc. en una versión posterior, como ya lo hizo antes. Esta es la razón por la cual este código tiene una prueba / excepto, para detectar la reorganización del código interno anterior que estaba destinada a aclarar que las API internas son API internas, no públicas ( _internal). En general, obviamente funciona, pero es una mala práctica. Hay mejores alternativas, algunas están en las otras respuestas a esta pregunta.

sinoroc

1

este script no funcionará si el módulo "pip" no está allí.

Alexander Stohr

8

Además de usar pip freeze, he estado instalando yema en mis entornos virtuales.

jdsantiagojr
fuente

6

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

$conda list

Además de las soluciones descritas anteriormente.

Shreyas
fuente

¿Dónde / cómo ejecutas esta línea?

HuckIt

Si está en su máquina UNIX / Mac OS X, abra su terminal y simplemente escriba conda install, debería funcionar :)

Shreyas

Estoy en una máquina con Windows 7. Lo encontré en mi camino en realidad, pero conda.exe está en AppData \ Local \ Continuum \ Anaconda \ Scripts.

HuckIt

6

para obtener todos los módulos disponibles, ejecute sys.modules
para obtener todos los módulos instalados (léase: instalado por 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

yegle
fuente

El comando sys.modules no funciona en el último Python de OSX. NameError: el nombre 'sistema' no está definido .

Léo Léopold Hertz 준영

@ Masi ¿Querías decir /usr/bin/pythono el de python.org ? Para el primero, puedo usar sys.modulessin problemas.

yegle

Me refiero a / usr / bin / python .

Léo Léopold Hertz 준영

@Masi No estoy seguro si todavía está interesado en este problema. Aparentemente estás usando en system.moduleslugar de sys.modules.

yegle

Jajaja Mi error fue que originalmente no importé el paquete sys. Entonces, en lugar de ejecutar import sys; sys.modules funcionan como se esperaba.

Léo Léopold Hertz 준영

6

Para versiones recientes como Pip 20

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

jabberwocky
fuente

4

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

Pavan Gupta
fuente

4

Hay muchas maneras de pelar un gato.

La forma más simple es usar la pydocfunción 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

not2qubit
fuente

3

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)

Massimo
fuente

3

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

Bruno Bronosky
fuente

1

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

Sachin Prabhu
fuente

1

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)

Eli
fuente

-1

Para cualquiera que se pregunte cómo llamar pip listdesde un programa Python, puede usar lo siguiente:

import pip
pip.main(['list])  # this will print all the packages

Marcelo Villa-Piñeros
fuente

No. Esto no es recomendable, consulte aquí: pip.pypa.io/en/stable/user_guide/#using-pip-from-your-program

sinoroc

-10

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.

S.Lott
fuente

¿Qué directorio de paquetes de sitio? Esto podría mejorar: ls / usr / {local /,} lib / python $ (python -V 2> & 1 | cut -d "" -f2 | cut -d. -F1-2) / site-packages

vezult

Además, esto no mostrará los módulos integrados, o los módulos en un PYTHONPATH personalizado, o los instalados en el "modo de desarrollo" de las herramientas de configuración, etc.

dF.

Mi /usr/local/lib/python2.5/site-packages está vacío, aunque he instalado módulos.

Léo Léopold Hertz 준영

14

Felicitaciones por no eliminar esta respuesta rechazada. Es útil para la comunidad poder ver por qué una respuesta común se considera incorrecta.

Jeremy Stein

1

@JeremyStein Una mejor estrategia (más útil y probablemente menos dañina para los representantes) probablemente sería editar la pregunta para explicar por qué está mal, una vez que esto se haya explicado en los comentarios ...

Kyle Strand

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

Respuestas:

Solución

¡No utilizar con pip> 10.0!

Alcance

Mi caso de uso

Advertencias

Pasos para reproducir:

Si ejecutamos la solución mencionada anteriormente desde `/tmp`

Si ejecutamos la solución mencionada anteriormente desde `/tmp/behave`

Esto ayudará

Para versiones recientes como Pip 20

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

Respuestas:

Solución

¡No utilizar con pip> 10.0!

Alcance

Mi caso de uso

Advertencias

Pasos para reproducir:

Si ejecutamos la solución mencionada anteriormente desde /tmp

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

Esto ayudará

Para versiones recientes como Pip 20

Si ejecutamos la solución mencionada anteriormente desde `/tmp`

Si ejecutamos la solución mencionada anteriormente desde `/tmp/behave`