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?
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?
Respostas:
Meus 50 centavos por obter uma pip freeze
lista-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']
Esta solução aplica-se ao âmbito do sistema ou a um escopo ambiente virtual, e pacotes de coberturas instalado por setuptools
, pip
e ( God Forbid )easy_install
.
Eu adicionei o resultado dessa chamada ao meu servidor de balão, portanto, quando ligo, http://example.com/exampleServer/environment
recebo a lista de pacotes instalados na virtualenv do servidor. Isso torna a depuração muito mais fácil.
Percebi um comportamento estranho dessa técnica - quando o interpretador Python é chamado no mesmo diretório que um setup.py
arquivo, ele não lista o pacote instalado 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) $
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.py
em /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
/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
está ausente no segundo exemplo, porque o diretório ativo contém behave
o setup.py
arquivo
Não encontrei nenhuma referência a esse problema na documentação. Talvez eu deva abrir um bug para isso.
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')
em um shell / prompt do Python.
pydoc modules
funciona. Você deve enviá-lo como resposta.
python -c 'help("modules")'
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.
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.
pip list --local
para distinguir entre virtualenv
e pacotes de sites globais, discutidos aqui .
pip list
é o mais simples e o melhor. Aqui estão as opções e detalhes.
Em ipython
você pode digitar " import
Tab".
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()
.
pkgutil.iter_modules()
funciona, a solução pip acima não lista todos os pacotes, apenas os instalados via pip.
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()
.
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.
pydoc
nem pip
instalados (um NAS no meu caso).
help('modules')
apenas trava sem resposta para mim. Mas essa abordagem sys
funciona perfeitamente
No shell normal, basta usar
pydoc modules
py -m pydoc modules
no cmd ou no Powershell.
pydoc modules
não funcionou para mim no Windows 10 com o Python 3.6, mas a modificação do @VKK: py -m pydoc modules
funciona no cmd / Powershell.
A partir do pip 10, a resposta aceita não funcionará mais. A equipe de desenvolvimento removeu o acesso à get_installed_distributions
rotina. Há uma função alternativa no setuptools
para 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.
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 setuptools
e fazê-la funcionar.
get_installed_distributions routine
.
setuptools
.
Eu normalmente uso pip list
para 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 list
opções disponíveis , com vários bons exemplos.
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]
for m in iter_modules()
e funcionou também.
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.
Tente esse
pip list
ou
pip freeze
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
Esta solução é primária com base em módulos importlib
e pkgutil
funciona com o CPython 3.4 e o CPython 3.5, mas não tem suporte para o CPython 2.
Explicação
sys.builtin_module_names
- nomeia todos os módulos internos (veja minha resposta aqui )pkgutil.iter_modules()
- retorna uma informação sobre todos os módulos disponíveisimportlib.util.find_spec()
- retorna uma informação sobre o módulo de importação, se existirBuiltinImporter
- um importador de módulos internos ( docs )SourceFileLoader
- um importador para um módulo Python padrão (por padrão, possui a extensão * .py) ( docs )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*******************************)
pip
sistema 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.
**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.
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 sudo
e 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.
pip
uma vez e depois sair. Parece ser mais um problema que o comportamento pode mudar.
_internal
). Em suma, obviamente funciona, mas é uma má prática. Existem alternativas melhores, algumas estão nas outras respostas a esta pergunta.
Além de usar pip freeze
, tenho instalado a gema nos meus ambientes virtuais.
Caso você tenha uma distribuição python anaconda instalada, você também pode usar
$conda list
além das soluções descritas acima.
conda install
, ele deve funcionar :)
sys.modules
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
/usr/bin/python
ou o que veio do python.org ? Para o primeiro, eu posso usar sys.modules
sem problemas.
system.modules
vez de sys.modules
.
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
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']
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)
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
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
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)
Para quem pip list
quiser saber como chamar de um programa Python, use o seguinte:
import pip
pip.main(['list]) # this will print all the packages
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.