Je voudrais obtenir une liste des modules Python, qui se trouvent dans mon installation Python (serveur UNIX).
Comment obtenir une liste des modules Python installés sur votre ordinateur?
Je voudrais obtenir une liste des modules Python, qui se trouvent dans mon installation Python (serveur UNIX).
Comment obtenir une liste des modules Python installés sur votre ordinateur?
Réponses:
Mes 50 cents pour obtenir une pip freeze
liste similaire à un 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)
En tant que doublure (trop longue):
sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()])
Donnant:
['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']
Cette solution applique à la portée du système ou à un champ d'environnement virtuel, et couvre les paquets installés par setuptools
, pip
et ( à Dieu ne plaise ) easy_install
.
J'ai ajouté le résultat de cet appel à mon serveur flask, donc quand je l'appelle avec, http://example.com/exampleServer/environment
j'obtiens la liste des packages installés sur virtualenv du serveur. Cela facilite beaucoup le débogage.
J'ai remarqué un comportement étrange de cette technique - lorsque l'interpréteur Python est invoqué dans le même répertoire qu'un setup.py
fichier, il ne répertorie pas le package installé par 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) $
Cloner un dépôt git avec 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.
Nous nous sommes comportés setup.py
en /tmp/behave
:
(test_env) $ ls /tmp/behave/setup.py
/tmp/behave/setup.py
Installez le paquet python à partir du dépôt 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 absent du deuxième exemple, car le répertoire de travail contient behave
le setup.py
fichier de.
Je n'ai trouvé aucune référence à ce problème dans la documentation. Je vais peut-être ouvrir un bug pour cela.
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')
dans un shell / invite Python.
pydoc modules
fonctionne. Vous devez le soumettre comme réponse.
python -c 'help("modules")'
Maintenant, ces méthodes, je les ai essayées moi-même et j'ai obtenu exactement ce qui était annoncé: tous les modules.
Hélas, vraiment vous ne vous souciez pas beaucoup du stdlib, vous savez ce que vous obtenez avec une installation python.
Vraiment, je veux les trucs que j'ai installés.
Ce qui, en fait, étonnamment, a très bien fonctionné était:
pip freeze
Qui a renvoyé:
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
Je dis "étonnamment" parce que l'outil d'installation de package est l'endroit exact auquel on s'attendrait à trouver cette fonctionnalité, bien que ce ne soit pas sous le nom de "gel", mais le packaging en python est si bizarre, que je suis sidéré que cet outil ait du sens. Pip 0.8.2, Python 2.7.
Depuis pip version 1.3, vous avez accès à:
pip list
Ce qui semble être du sucre syntaxique pour le "pip freeze". Il répertorie tous les modules spécifiques à votre installation ou virtualenv, ainsi que leurs numéros de version. Malheureusement, il n'affiche le numéro de version actuel d'aucun module, ni ne lave votre vaisselle ni ne fait briller vos chaussures.
pip list --local
une distinction entre virtualenv
les packages de sites globaux et discutés ici .
pip list
est le plus simple et le meilleur. Voici les options et les détails.
Dans, ipython
vous pouvez taper " import
Tab".
Dans l'interpréteur Python standard, vous pouvez taper " help('modules')
".
Sur la ligne de commande, vous pouvez utiliser .pydoc
modules
Dans un script, appelez pkgutil.iter_modules()
.
pkgutil.iter_modules()
fonctionne, la solution pip ci-dessus ne répertorie pas tous les packages, seulement ceux installés via pip.
python -c 'import pkgutil;print [x[1] for x in list(pkgutil.iter_modules())]'
. Il devrait vider tous les noms de modules en une seule très grande liste Python. Le x[1]
bit est utilisé pour extraire le nom du module des tuples générés par pkgutil.iter_modules()
.
Je l'utilise juste pour voir les modules actuellement utilisés:
import sys as s
s.modules.keys()
qui montre tous les modules fonctionnant sur votre python.
Pour tous les modules intégrés, utilisez:
s.modules
C'est un dict contenant tous les modules et les objets d'importation.
pydoc
ni pip
installé ni installé (un NAS dans mon cas).
help('modules')
se bloque sans réponse pour moi. Mais cette approche sys
fonctionne parfaitement
Dans une coque normale, utilisez simplement
pydoc modules
py -m pydoc modules
en cmd ou Powershell.
pydoc modules
n'a pas fonctionné pour moi dans Windows 10 avec Python 3.6, mais modification @VKK: py -m pydoc modules
fonctionne dans cmd / Powershell.
Depuis le pip 10, la réponse acceptée ne fonctionnera plus. L'équipe de développement a supprimé l'accès à la get_installed_distributions
routine. Il y a une fonction alternative dans le setuptools
pour faire la même chose. Voici une version alternative qui fonctionne avec 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)
Veuillez me faire savoir si cela fonctionnera ou non dans les versions précédentes de pip.
pip freeze
; la profondeur de mes connaissances sur ce sujet est plutôt limitée. J'ai en quelque sorte cherché mon chemin vers la solution lorsque la réponse acceptée ne fonctionnait pas pour moi et j'ai essayé de la combiner avec une réponse liée à setuptools
et de la faire fonctionner.
get_installed_distributions routine
.
setuptools
.
J'utilise normalement pip list
pour obtenir une liste de packages (avec version).
Cela fonctionne aussi dans un environnement virtuel. Pour afficher ce qui est installé uniquement dans l'environnement virtuel (pas les packages globaux), utilisez pip list --local
.
Voici une documentation montrant toutes les pip list
options disponibles , avec plusieurs bons exemples.
Recherche très simple à l'aide de 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()
et cela a également fonctionné.
J'ai rencontré un python 2.7 installé sur OS X. Il fallait X11 pour répertorier les modules installés (à l'aide de l'aide et de pydoc).
Pour pouvoir lister tous les modules sans installer X11 j'ai exécuté pydoc en tant que serveur http, c'est-à-dire:
pydoc -p 12345
Ensuite, il est possible de diriger Safari http://localhost:12345/
pour voir tous les modules.
Essayez-les
pip list
ou
pip freeze
Dans le terminal ou IPython, tapez:
help('modules')
puis
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
Cette solution est principalement basée sur des modules importlib
et pkgutil
fonctionne avec CPython 3.4 et CPython 3.5, mais ne prend pas en charge CPython 2.
Explication
sys.builtin_module_names
- nomme tous les modules intégrés (regardez ma réponse ici )pkgutil.iter_modules()
- retourne une information sur tous les modules disponiblesimportlib.util.find_spec()
- retourne une information sur l'importation du module, s'il existeBuiltinImporter
- un importateur de modules intégrés ( docs )SourceFileLoader
- un importateur pour un module Python standard (par défaut a l'extension * .py) ( docs )ExtensionFileLoader
- un importateur de modules comme bibliothèque partagée (écrit sur le C ou C ++)Code complet
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()
Usage
Pour le CPython3.5 (tronqué)
$ 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*******************************)
Pour le CPython3.4 (tronqué)
$ 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
système de gestion des packages utilisé pour installer et gérer les packages logiciels écrits en Python et un résultat pip.get_installed_distributions()
renvoie les modules installés avec le pip. Ma réponse est entièrement basée sur la bibliothèque standard de Python et couvre tous les modules disponibles pour l'importation. Un plus gros inconvénient de ma réponse - pas de support pour le CPython 2.
**truncated**
, où une sortie est tronquée. Peut-être que vous ne faites pas attention, mais si ce n'est pas le cas, alors pour m'envoyer des informations sur votre système et la mise en œuvre de Python, je ferai des recherches supplémentaires pour le corriger.
Attention: Adam Matan déconseille cette utilisation dans pip> 10.0. Lisez également le commentaire de @ sinoroc ci-dessous
Cela a été inspiré par la réponse d' Adam Matan (la réponse acceptée):
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))
qui imprime ensuite un tableau sous forme 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
------------------------------------------- -------------- ------
ce qui vous permet ensuite de discerner facilement les packages que vous avez installés avec et sans sudo
.
Une note de côté: j'ai remarqué que lorsque j'installe un paquet une fois via sudo
et une fois sans, l'un a priorité afin que l'autre ne soit pas répertorié (un seul emplacement est affiché). Je crois que seul celui du répertoire local est alors répertorié. Cela pourrait être amélioré.
pip
une fois puis de quitter. Il semble que ce soit davantage un problème que le comportement puisse changer.
_internal
). Dans l'ensemble, cela fonctionne évidemment, mais c'est une mauvaise pratique. Il existe de meilleures alternatives, certaines sont dans les autres réponses à cette question.
Mis à part l'utilisation, pip freeze
j'ai installé le jaune d'oeuf dans mes environnements virtuels.
Dans le cas où une distribution python anaconda est installée, vous pouvez également utiliser
$conda list
en plus des solutions décrites ci-dessus.
conda install
, cela devrait fonctionner :)
sys.modules
pip
), vous pouvez regarderpip.get_installed_distributions()
Pour le deuxième objectif, exemple de code:
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 celui qui vient de python.org ? Pour l'ancien, je peux l'utiliser sys.modules
sans problème.
system.modules
au lieu de sys.modules
.
Exécutez ce qui suit dans votre éditeur python ou IPython
import pkg_resources;
installed_packages = {d.project_name: d.version for d in pkg_resources.working_set}
print(installed_packages)
Lisez d'autres réponses et rassemblez ce combo, qui est le plus rapide et le plus simple à l' intérieur de Python
pip freeze fait tout pour trouver des packages, mais il suffit d'écrire la commande suivante pour répertorier tous les chemins d'accès aux packages python.
>>> import site; site.getsitepackages()
['/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages']
Il existe de nombreuses façons d'écorcher un chat.
La manière la plus simple est d'utiliser la pydoc
fonction directement depuis le shell avec:
pydoc modules
Mais pour plus d'informations, utilisez l'outil appelé pip-date qui vous indique également les dates d'installation.
pip install pip-date
Il y a beaucoup d'idées, au départ je réfléchis sur ces deux:
pépin
inconvénients: pas toujours installé
aide («modules»)
inconvénients: sortie sur console; avec des modules cassés (voir ubuntu ...) peut segfault
J'ai besoin d'une approche simple, utilisant des bibliothèques de base et compatible avec l'ancien python 2.x
Et je vois la lumière: listmodules.py
Un petit script qui répertorie tous les modules disponibles pour une installation Python est caché dans le répertoire source de la documentation en 2.5.
Avantages:
utilise uniquement imp, sys, os, re, time
conçu pour fonctionner sur Python 1.5.2 et plus récent
le code source est vraiment compact, vous pouvez donc facilement le bricoler, par exemple pour passer une liste d'exceptions de modules buggy (n'essayez pas de les importer)
J'avais besoin de trouver la version spécifique des packages disponibles par défaut dans AWS Lambda. Je l'ai fait avec un mélange d'idées de cette page. Je le partage pour la postérité.
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
],
}
Ce que j'ai découvert, c'est que la bibliothèque boto3 fournie était bien dépassée et que ce n'était pas ma faute si mon code échouait. J'avais juste besoin d'ajouter boto3 et botocore à mon projet. Mais sans cela, je me serais cogné la tête en pensant que mon code était mauvais.
{
"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
},
...
Ce que j'ai découvert était également différent de ce qu'ils publient officiellement . Au moment de la rédaction de ceci:
- Système d'exploitation - Amazon Linux
- AMI - amzn-ami-hvm-2017.03.1.20170812-x86_64-gp2
- Noyau Linux - 4.14.77-70.59.amzn1.x86_64
- SDK AWS pour JavaScript - 2.290.0 \
- SDK pour Python (Boto 3) - 3-1.7.74 botocore-1.10.74
Installation
pip install pkgutil
Code
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
Exemple de sortie:
multiprocessing
netrc
nntplib
ntpath
nturl2path
numbers
opcode
pickle
pickletools
pipes
pkgutil
Voici une solution de code python qui renverra une liste des modules installés. On peut facilement modifier le code pour inclure les numéros de version.
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)
Pour ceux qui se demandent comment appeler à pip list
partir d'un programme Python, vous pouvez utiliser ce qui suit:
import pip
pip.main(['list]) # this will print all the packages
De la coquille
ls site-packages
Si cela ne vous aide pas, vous pouvez le faire.
import sys
import os
for p in sys.path:
print os.listdir( p )
Et voyez ce que cela produit.