Como posso obter uma lista de módulos Python instalados localmente?

998

Gostaria de obter uma lista dos módulos Python, que estão na minha instalação do Python (servidor UNIX).

Como você pode obter uma lista dos módulos Python instalados no seu computador?

Léo Léopold Hertz 준영
fonte
77
você pode apenas fazer >>> ajuda () e depois >>> módulos
Julius Naeumann
1
Existe uma alternativa? ajuda () trava para mim.
Paulo Carvalho
2
Muitas dessas respostas assumem que você tem acesso a uma linha de comando. Se você estiver usando o AWS Lambda, precisará fazer tudo de dentro do Python. Veja stackoverflow.com/a/54939905/117471
Bruno Bronosky

Respostas:

610

Solução

Não use com pip> 10.0!

Meus 50 centavos por obter uma pip freezelista-like de um script 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 um forro (muito longo):

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

Escopo

Esta solução aplica-se ao âmbito do sistema ou a um escopo ambiente virtual, e pacotes de coberturas instalado por setuptools, pipe ( God Forbid )easy_install .

Meu caso de uso

Eu adicionei o resultado dessa chamada ao meu servidor de balão, portanto, quando ligo, http://example.com/exampleServer/environmentrecebo a lista de pacotes instalados na virtualenv do servidor. Isso torna a depuração muito mais fácil.

Ressalvas

Percebi um comportamento estranho dessa técnica - quando o interpretador Python é chamado no mesmo diretório que um setup.pyarquivo, ele não lista o pacote instalado setup.py.

Passos para reproduzir:

Crie um ambiente 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) $ 
Clone um repositório git com 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.

Nós nos comportamos setup.pyem /tmp/behave:

(test_env) $ ls /tmp/behave/setup.py
/tmp/behave/setup.py
Instale o pacote python a partir do repositório 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

Se executarmos a solução acima mencionada de /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'

Se executarmos a solução acima mencionada de /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.5a1está ausente no segundo exemplo, porque o diretório ativo contém behaveo setup.pyarquivo

Não encontrei nenhuma referência a esse problema na documentação. Talvez eu deva abrir um bug para isso.

Adam Matan
fonte
5
Obrigado por esta resposta! Eu acho que é melhor responder à pergunta, porque eu pergunto módulos Python instalados "localmente". O congelamento de pip também nem sempre é o caminho a percorrer. Isso funciona melhor - eu acho.
Léo Léopold Hertz ·
3
@ Masi Acabei de adicionar uma explicação detalhada da ressalva desta solução. É de fato um estranho.
Adam Matan
21
Uma alternativa:import pkg_resources; installed_packages = [(d.project_name, d.version) for d in pkg_resources.working_set]
ebolyen
14
A partir do pip 10, essa resposta não funcionará mais. O comentário de @ebolyen mostra comandos alternativos que funcionam. Cheguei à mesma conclusão e publiquei o código revisado completo abaixo.
Big_Al_Tx
5
Nas versões recentes do pip, isso não funciona, gerando uma mensagem de erro dizendo AttributeError: module 'pip' has no attribute 'get_installed_distributions'.
hellogoodbye
1039
help('modules')

em um shell / prompt do Python.

ChristopheD
fonte
10
@dF pydoc modulesfunciona. Você deve enviá-lo como resposta.
Abizern
37
Me deu uma falha de seg!
zanbri
3
nobar, zanbri, @ Joe Frambach: no Ubuntu? Há um erro descrito aqui: bugs.launchpad.net/ubuntu/+source/python2.7/+bug/896836 #
ChristopheD
2
como posso obter informações extras sobre onde os módulos estão instalados e qual é a versão atual?
curioso
5
python -c 'help("modules")'
Kenorb
285

Agora, esses métodos eu me testei e recebi exatamente o que foi anunciado: todos os módulos.

Infelizmente, você realmente não se importa muito com o stdlib, sabe o que obtém com uma instalação em python.

Realmente, eu quero as coisas que eu instalado.

Surpreendentemente, o que realmente funcionou bem foi:

pip freeze

O que retornou:

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 "surpreendentemente" porque a ferramenta de instalação de pacotes é o local exato que se esperaria encontrar essa funcionalidade, embora não com o nome de "congelar", mas o empacotamento de python seja tão estranho que me surpreendo que essa ferramenta faça sentido. Pip 0.8.2, Python 2.7.

chiggsy
fonte
4
Eu acho que a ideia por trás do nome é que você obtenha um instantâneo "congelado" do que está instalado no momento, que você poderá posteriormente enviar ao pip para obter exatamente os mesmos módulos instalados em um ambiente diferente.
Ryan C. Thompson
Arash, você pode instalar o pip no Windows também! Primeiro instalar setuptools e depois usar easy_install para instalar pip :)
gawbul
Isso é excelente, mas parece que falta algumas das bibliotecas que instalei. Por exemplo, ele não lista o PyQt.
Junuxx
8
A partir do pip 1.3, há o comando list .
Piotr Dobrogost 13/03/2013
funciona. O que é uma bagunça python. Por que eles não conseguem se unir e encontrar soluções semelhantes às existentes no Rails? (Gemfile, Bundler, RVM)
Dimitris
106

Desde a versão 1.3 do pip, você tem acesso a:

pip list

O que parece ser um açúcar sintático para o "congelamento de pip". Ele listará todos os módulos específicos da sua instalação ou virtualenv, juntamente com seus números de versão. Infelizmente, ele não exibe o número da versão atual de nenhum módulo, nem lava a louça ou lustra os sapatos.

Bryce
fonte
4
Também há pip list --localpara distinguir entre virtualenve pacotes de sites globais, discutidos aqui .
Ioannis Filippidis
1
De longe o melhor. Ele também recupera as versões.
Aerijman 26/04/19
pip listé o mais simples e o melhor. Aqui estão as opções e detalhes.
Levi Baguley 15/01
86
  • Em ipythonvocê pode digitar " importTab".

  • No interpretador Python padrão, você pode digitar " help('modules')".

  • Na linha de comando, você pode usar .pydoc modules

  • Em um script, ligue pkgutil.iter_modules().

Johnsyweb
fonte
5
pkgutil.iter_modules()funciona, a solução pip acima não lista todos os pacotes, apenas os instalados via pip.
Metaperture
2
Impressionante! Eu acho que eles melhoraram a documentação, desde que a pergunta foi feita. O spam dos módulos pydoc pesquisa o spam nos documentos dos módulos. O último ponto parece fornecer as informações suficientes para usar o módulo. @metaperture Você pode, por exemplo, dar um exemplo de como você lista todos os módulos locais instalados (não a lista massiva de stlib by help ('modules')) por pkgutil.iter_modules () .
Léo Léopold Hertz,
2
@ LéoLéopoldHertz 준영 Tente este trecho: python -c 'import pkgutil;print [x[1] for x in list(pkgutil.iter_modules())]'. Ele deve despejar todos os nomes de módulos como uma lista Python realmente grande. O x[1]bit é usado para extrair o nome do módulo das tuplas geradas por pkgutil.iter_modules().
Philip Conrad
76

Eu apenas uso isso para ver os módulos usados ​​atualmente:

import sys as s
s.modules.keys()

que mostra todos os módulos em execução no seu python.

Para todos os módulos internos, use:

s.modules

Qual é um ditado que contém todos os módulos e objetos de importação.

Dan Evans
fonte
2
# Depois de importar o sys "import sys as s", você pode imprimir com: print sys.modules.keys ()
Dan Evans
Não sei por que minha postagem foi editada, mas obrigado por usar as informações que publiquei para corrigir os erros nas postagens anteriores. Você retornará erros se usar help () vs help (''). Isso vale para dir ('') & sys ('') etc. também. Espero que isso ajude e não seja removido.
Dan Evans
Ignorar minha última postagem, esta postagem não foi editada. Eu estava pensando em um post semelhante encontrado aqui: stackoverflow.com/questions/139180/… Desculpe pela confusão.
Dan Evans
7
Voto positivo, porque este é o único método que parece funcionar em sistemas restritos que não foram instalados pydocnem pipinstalados (um NAS no meu caso).
Thomas
1
Concordou com Thomas. Estou usando repl.it, por exemplo, que também é um tipo de ambiente restrito. help('modules')apenas trava sem resposta para mim. Mas essa abordagem sysfunciona perfeitamente
Sergiy Kolodyazhnyy
63

No shell normal, basta usar

pydoc modules
DrkNess
fonte
Parece que o acima funciona apenas em plataformas 'nix. De qualquer forma, localizei e executei o script, adaptando o comando da seguinte maneira: c: \ bin \ pythos_2.7 \ lib \ pydoc.py modules - essa lista levou uma eternidade para ser criada, o formato é péssimo e omite a versão instalada número. Vou passar.
David A. Gray
2
@ DavidA.Gray Apenas tentei isso em uma máquina Windows com Python 3 e, de fato, funciona. Usando o iniciador de janelas python, você pode fazer py -m pydoc modulesno cmd ou no Powershell.
VKK
pydoc modulesnão funcionou para mim no Windows 10 com o Python 3.6, mas a modificação do @VKK: py -m pydoc modulesfunciona no cmd / Powershell.
Martin Martin
41

A partir do pip 10, a resposta aceita não funcionará mais. A equipe de desenvolvimento removeu o acesso à get_installed_distributionsrotina. Há uma função alternativa no setuptoolspara fazer a mesma coisa. Aqui está uma versão alternativa que funciona com o 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)

Informe-me se também funcionará ou não nas versões anteriores do pip.

Big_Al_Tx
fonte
2
Eu tenho procurado por esta solução e estragado meu cérebro tentando descobrir pkg_resources. Se eu pudesse aprovar isso mais de uma vez, faria. Obrigado, @Big_Al_Tx! Atualização: Exceto .... quando eu faço um 'congelamento de pip' no meu ambiente virtual e o comparo com a saída disso, há pacotes ausentes. Alguma idéia de por que isso poderia / aconteceria?
numberwhun
@numberwhun - Estou feliz que isso funcionou para você. Sinto muito, mas não tenho uma resposta para a discrepância com pip freeze; a profundidade do meu conhecimento sobre esse tópico é bastante limitada. Eu meio que me atrapalhei até a solução quando a resposta aceita não funcionou para mim e tentei combiná-la com uma resposta relacionada setuptoolse fazê-la funcionar.
Big_Al_Tx
github.com/pypa/pip/issues/5243 - A conversa da equipe de desenvolvimento sobre o acesso removido ao get_installed_distributions routine.
26798 bl26
@ bl79 - Eu acho que é o lugar exato para onde eu recebi a referência setuptools.
Big_Al_Tx
@Big_Al_Tx: Bem, eu meio que trabalhei com a opção setuptools (que estava totalmente ofuscada para minhas necessidades) e fui com isso: installed_pkgs = subprocess.check_output (['pip', 'freeze']) Faz exatamente o que eu precisava fazer .... Yay !!
numberwhun
26

Se precisarmos listar os pacotes instalados no shell do Python, podemos usar o helpcomando da seguinte maneira

>>help('modules package')
Sadheesh
fonte
22

Eu normalmente uso pip listpara obter uma lista de pacotes (com versão).

Isso funciona em um ambiente virtual também, é claro. Para mostrar o que está instalado apenas no ambiente virtual (não nos pacotes globais), use pip list --local.

Aqui está a documentação mostrando todas as pip listopções disponíveis , com vários bons exemplos.

James
fonte
13

Pesquisa muito simples 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]
stuudent
fonte
existe alguma razão para usar while em vez de um loop for? Eu escrevi usando for m in iter_modules()e funcionou também.
João Ponte
13

no windows, insira isso no cmd

c:\python\libs>python -m pip freeze
Saurabh
fonte
Isso funcionou para mim usando: python3 -m pip freeze - para python 3.5.3.
Dpminusa
Isso funciona bem e você não precisa estar no diretório libs, bem como se as suas variáveis são definidas
mcy
12

Encontrei um python instalado personalizado 2.7 no OS X. Ele exigia que o X11 listasse os módulos instalados (usando a ajuda e o pydoc).

Para poder listar todos os módulos sem instalar o X11, executei o pydoc como servidor http, ou seja:

pydoc -p 12345

Então é possível direcionar o Safari http://localhost:12345/para ver todos os módulos.

Qiau
fonte
12

Tente esse

pip list

ou

pip freeze
Amit Gupta
fonte
Isso funciona a partir de um shell. Mas não no python
user7194913 26/02
12

Isso vai ajudar

No terminal ou IPython, digite:

help('modules')

então

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
fonte
Esta deve ser a resposta aceita! One line :)
AlmostPitt
9

Esta solução é primária com base em módulos importlibe pkgutilfunciona com o CPython 3.4 e o CPython 3.5, mas não tem suporte para o CPython 2.


Explicação

  1. sys.builtin_module_names - nomeia todos os módulos internos (veja minha resposta aqui )
  2. pkgutil.iter_modules() - retorna uma informação sobre todos os módulos disponíveis
  3. importlib.util.find_spec() - retorna uma informação sobre o módulo de importação, se existir
  4. BuiltinImporter- um importador de módulos internos ( docs )
  5. SourceFileLoader- um importador para um módulo Python padrão (por padrão, possui a extensão * .py) ( docs )
  6. ExtensionFileLoader- um importador de módulos como biblioteca compartilhada (escrita em C ou 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 o 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 o 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
fonte
Você pode por favor comparar a sua abordagem para a abordagem de Adam aqui stackoverflow.com/a/23885252/54964
Léo Léopold Hertz 준영
@ Léo Léopold Hertz, por que você precisa?
PADYMKO
Entender como sua abordagem é melhor / pior que a abordagem de Adam.
Léo Léopold Hertz ·
1
@ Léo Léopold Hertz. Uma resposta curta: tente você mesmo em uma produção e tire conclusões você mesmo. Resposta longa: a abordagem de Adam é baseada no pipsistema de gerenciamento de pacotes usado para instalar e gerenciar pacotes de software escritos em Python e, como resultado, pip.get_installed_distributions()retorna os módulos instalados com o pip. Minha resposta é inteiramente baseada na biblioteca padrão do Python e abrange todos os módulos disponíveis para importação. A maior desvantagem a minha resposta - não há um suporte para o do CPython 2.
PADYMKO
1
@ Léo Léopold Hertz você está enganado, ele faz. Eu testei no meu computador. Minha resposta contém um significado especial **truncated**, onde uma saída é truncada. Talvez você não tenha cuidado, mas se não o fizer, para me enviar uma informação sobre seu sistema e a implementação do Python, farei pesquisas adicionais para corrigi-lo.
PADYMKO 9/0317
9

Aviso: Adam Matan desencoraja esse uso no pip> 10.0. Leia também o comentário de @ sinoroc abaixo

Isso foi inspirado na resposta de Adam Matan (a aceita):

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 então imprime uma tabela na 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
-------------------------------------------  --------------  ------

que permite discernir facilmente quais pacotes você instalou com e sem sudo.


Uma observação à parte: notei que quando instalo um pacote uma vez sudoe uma vez sem, um tem precedência para que o outro não esteja sendo listado (apenas um local é mostrado). Acredito que apenas o diretório local é listado. Isso pode ser melhorado.

Daniel F
fonte
1
Não. Isso não é recomendado, veja aqui: pip.pypa.io/en/stable/user_guide/#using-pip-from-your-program
sinoroc
1
@sinoroc Obrigado por apontar isso. Os pontos 1 a 3 não parecem ser aplicáveis ​​a esta solução, pois esse script tem o único objetivo de usar pipuma vez e depois sair. Parece ser mais um problema que o comportamento pode mudar.
Daniel F
Concordado, as razões pelas quais não há API pública não se aplicam a esse trecho de código específico. Mas como o pip não é obrigado a garantir uma API pública, é livre alterar suas APIs internas, estrutura de código etc. em uma versão posterior, como já havia feito antes. É por isso que esse código tem uma tentativa / exceção, para capturar a reorganização de código interno anterior que deveria esclarecer que APIs internas são APIs internas e não públicas ( _internal). Em suma, obviamente funciona, mas é uma má prática. Existem alternativas melhores, algumas estão nas outras respostas a esta pergunta.
sinoroc 12/12/19
1
esse script não funcionará se o módulo "pip" não estiver lá.
Alexander Stohr
8

Além de usar pip freeze, tenho instalado a gema nos meus ambientes virtuais.

jdsantiagojr
fonte
6

Caso você tenha uma distribuição python anaconda instalada, você também pode usar

$conda list

além das soluções descritas acima.

Shreyas
fonte
Onde / como você administra esta linha?
precisa saber é o seguinte
Se você estiver em sua máquina UNIX / Mac OS X, abra o seu tipo de terminal e apenas conda install, ele deve funcionar :)
Shreyas
Estou em uma máquina com Windows 7. Encontrei-o no meu caminho, na verdade, mas o arquivo conda.exe está em AppData \ Local \ Continuum \ Anaconda \ Scripts.
precisa saber é o seguinte
6
  1. para obter todos os módulos disponíveis, execute sys.modules
  2. para obter todos os módulos instalados (leia-se: instalado por pip), você pode verpip.get_installed_distributions()

Para o segundo objetivo, exemplo de código:

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
fonte
O comando sys.modules não funciona no Python do OSX mais recente. NameError: o nome 'system' não está definido .
Léo Léopold Hertz ·
@Masi Você quis dizer /usr/bin/pythonou o que veio do python.org ? Para o primeiro, eu posso usar sys.modulessem problemas.
yegle
Quero dizer / usr / bin / python .
Léo Léopold Hertz,
@ Masi Não tenho certeza se você ainda está interessado neste problema. Aparentemente, você está usando em system.modulesvez de sys.modules.
yegle 3/09/14
Ri muito. Meu erro foi que originalmente não importava o sys -package. Então, executando import sys; sys.modules funcionam conforme o esperado.
Léo Léopold Hertz 준영
6

Para versão recente, como Pip 20

Execute o seguinte em seu editor python ou IPython

import pkg_resources; 
installed_packages = {d.project_name: d.version for d in pkg_resources.working_set}
print(installed_packages)

Leia outras respostas e reuniu esse combo, que é mais rápido e fácil dentro do Python

jabberwocky
fonte
4

O pip freeze faz tudo para encontrar pacotes, no entanto, pode-se simplesmente escrever o seguinte comando para listar todos os caminhos onde estão os pacotes python.

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

Há muitas maneiras de esfolar um gato.

  • A maneira mais simples é usar a pydocfunção diretamente do shell com:
    pydoc modules

  • Porém, para obter mais informações, use a ferramenta chamada pip-date, que também informa as datas da instalação.
    pip install pip-date


insira a descrição da imagem aqui

not2qubit
fonte
3

Existem muitas idéias, inicialmente estou pensando nessas duas:

pip

contras: nem sempre instalado

ajuda ('módulos')

contras: saída para o console; com módulos quebrados (veja ubuntu ...) pode segfault

Preciso de uma abordagem fácil, usando bibliotecas básicas e compatível com o antigo python 2.x

E eu vejo a luz: listmodules.py

Oculto no diretório de origem da documentação na 2.5, está um pequeno script que lista todos os módulos disponíveis para uma instalação do Python.

Prós:

usa apenas imp, sys, os, re, time

projetado para rodar no Python 1.5.2 e mais recente

o código-fonte é realmente compacto, então você pode facilmente mexer nele, por exemplo, para passar uma lista de exceções de módulos com erros (não tente importá-los)

Massimo
fonte
3

Eu precisava encontrar a versão específica dos pacotes disponíveis por padrão no AWS Lambda. Fiz isso com um mashup de idéias nesta página. Estou compartilhando para a posteridade.

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
                ],
    }

O que descobri é que a biblioteca boto3 fornecida estava desatualizada e não foi minha culpa que meu código estava falhando. Eu só precisava adicionar boto3 e botocore ao meu projeto. Mas sem isso eu teria batido minha cabeça pensando que meu código era ruim.

{
  "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
    },
...

O que eu descobri também foi diferente do que eles publicam oficialmente . No momento em que escrevi isso:

  • Sistema operacional - Amazon Linux
  • AMI - amzn-ami-hvm-2017.03.1.20170812-x86_64-gp2
  • Kernel do 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
fonte
1

Instalação

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

Saída de amostra:

multiprocessing
netrc
nntplib
ntpath
nturl2path
numbers
opcode
pickle
pickletools
pipes
pkgutil
Sachin Prabhu
fonte
1

Aqui está uma solução de código python que retornará uma lista de módulos instalados. Pode-se facilmente modificar o código para incluir números de versão.

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
fonte
-10

Da casca

ls site-packages

Se isso não for útil, você pode fazer isso.

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

E veja o que isso produz.

S.Lott
fonte
qual diretório de pacotes de sites? Isso pode ser melhor: ls / usr / {local /,} lib / python $ (python -V2> & 1 | cut -d "" -f2 | cut -d. -F1-2) / site-packages
vezult
Além disso, isso não mostrará módulos internos, ou módulos em um PYTHONPATH personalizado, ou aqueles instalados no setuptools "modo de desenvolvimento" etc.
dF.
Meus /usr/local/lib/python2.5/site-packages estão vazios, embora eu tenha instalado módulos.
Léo Léopold Hertz 준영
14
Parabéns por não excluir esta resposta com voto negativo. É útil para a comunidade ver por que uma resposta comum é considerada errada.
18712 Jeremy Stein
1
@JeremyStein A melhor estratégia (mais útil e provavelmente menos-rep danificar) seria provavelmente para editar a questão de explicar por que é errado, uma vez que este tem sido explicada nos comentários ...
Kyle Strand