Ich möchte eine Liste der Python-Module erhalten, die sich in meiner Python-Installation befinden (UNIX-Server).
Wie können Sie eine Liste der auf Ihrem Computer installierten Python-Module erhalten?
Ich möchte eine Liste der Python-Module erhalten, die sich in meiner Python-Installation befinden (UNIX-Server).
Wie können Sie eine Liste der auf Ihrem Computer installierten Python-Module erhalten?
Antworten:
Meine 50 Cent für das Abrufen einer pip freeze
ähnlichen Liste aus einem Python-Skript:
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)
Als (zu langer) Einzeiler:
sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()])
Geben:
['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']
Diese Lösung gilt für das System Umfang oder in einen virtuellen Umgebung Umfang und Abdeckungen Pakete installiert durch setuptools
, pip
und ( Gott bewahre ) easy_install
.
Ich habe das Ergebnis dieses Aufrufs zu meinem http://example.com/exampleServer/environment
Flask-Server hinzugefügt. Wenn ich ihn mit aufrufe, wird die Liste der auf der virtuellen Umgebung des Servers installierten Pakete angezeigt. Dies erleichtert das Debuggen erheblich.
Ich habe ein seltsames Verhalten dieser Technik festgestellt. Wenn der Python-Interpreter im selben Verzeichnis wie eine setup.py
Datei aufgerufen wird , wird das von installierte Paket nicht aufgelistet 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) $
Klonen Sie ein Git-Repo mit 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.
Wir haben uns verhalten setup.py
in /tmp/behave
:
(test_env) $ ls /tmp/behave/setup.py
/tmp/behave/setup.py
Installieren Sie das Python-Paket vom Git-Repo
(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
aus dem zweiten Beispiel fehlt, weil das Arbeitsverzeichnis enthält behave
‚s - setup.py
Datei.
Ich konnte in der Dokumentation keinen Hinweis auf dieses Problem finden. Vielleicht werde ich einen Fehler dafür öffnen.
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')
in einer Python-Shell / Eingabeaufforderung.
pydoc modules
funktioniert. Sie sollten es als Antwort einreichen.
python -c 'help("modules")'
Nun, diese Methoden habe ich selbst ausprobiert und genau das bekommen, was beworben wurde: Alle Module.
Leider interessiert Sie die stdlib nicht besonders, Sie wissen, was Sie mit einer Python-Installation erhalten.
Wirklich, ich möchte das Zeug, das ich installiert habe.
Was eigentlich überraschenderweise gut funktionierte, war:
pip freeze
Was zurückkam:
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
Ich sage "überraschend", weil das Paketinstallations-Tool genau der Ort ist, an dem man diese Funktionalität erwarten würde, obwohl nicht unter dem Namen "Einfrieren", aber die Python-Verpackung ist so seltsam, dass ich verblüfft bin, dass dieses Tool Sinn macht. Pip 0.8.2, Python 2.7.
Seit Pip Version 1.3 haben Sie Zugriff auf:
pip list
Das scheint syntaktischer Zucker für "Pip Freeze" zu sein. Es werden alle Module aufgelistet, die für Ihre Installation oder virtuelle Umgebung spezifisch sind, zusammen mit ihren Versionsnummern. Leider zeigt es weder die aktuelle Versionsnummer eines Moduls an, noch spült es Ihr Geschirr oder glänzt Ihre Schuhe.
pip list --local
zur Unterscheidung zwischen virtualenv
und globalen Site-Paketen, die hier diskutiert werden .
pip list
ist das einfachste und das beste. Hier sind die Optionen und Details.
In können ipython
Sie " import
Tab" eingeben.
Im Standard-Python-Interpreter können Sie " help('modules')
" eingeben.
In der Befehlszeile können Sie verwenden .pydoc
modules
Rufen Sie in einem Skript auf pkgutil.iter_modules()
.
pkgutil.iter_modules()
funktioniert, die obige Pip-Lösung listet nicht alle Pakete auf, sondern nur die, die über pip installiert wurden.
python -c 'import pkgutil;print [x[1] for x in list(pkgutil.iter_modules())]'
. Es sollte alle Modulnamen als eine wirklich große Python-Liste ausgeben. Das x[1]
Bit wird verwendet, um den Modulnamen aus den von generierten Tupeln zu ziehen pkgutil.iter_modules()
.
Ich benutze dies nur, um aktuell verwendete Module zu sehen:
import sys as s
s.modules.keys()
Hier werden alle Module angezeigt, die auf Ihrem Python ausgeführt werden.
Verwenden Sie für alle eingebauten Module:
s.modules
Welches ist ein Diktat, das alle Module und Importobjekte enthält.
pydoc
noch pip
installiert sind (in meinem Fall ein NAS).
help('modules')
hängt einfach ohne Antwort für mich. Aber dieser Ansatz sys
funktioniert perfekt
In normaler Schale einfach verwenden
pydoc modules
py -m pydoc modules
in cmd oder Powershell arbeiten.
pydoc modules
funktionierte bei mir in Windows 10 mit Python 3.6 nicht, aber @ VKK-Modifikation: py -m pydoc modules
funktioniert in cmd / Powershell.
Ab Pip 10 funktioniert die akzeptierte Antwort nicht mehr. Das Entwicklungsteam hat den Zugriff auf die get_installed_distributions
Routine entfernt. Es gibt eine alternative Funktion, setuptools
um dasselbe zu tun. Hier ist eine alternative Version, die mit Pip 10 funktioniert:
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)
Bitte lassen Sie mich wissen, ob es auch in früheren Versionen von pip funktioniert oder nicht.
pip freeze
; Die Tiefe meines Wissens zu diesem Thema ist eher begrenzt. Ich habe mich irgendwie auf den Weg zur Lösung gemacht, als die akzeptierte Antwort für mich nicht funktionierte und ich versuchte, sie mit einer Antwort zu kombinieren setuptools
und sie zum Laufen zu bringen.
get_installed_distributions routine
.
setuptools
.
Ich benutze normalerweise pip list
, um eine Liste von Paketen (mit Version) zu erhalten.
Dies funktioniert natürlich auch in einer virtuellen Umgebung. Verwenden Sie, um anzuzeigen, was nur in der virtuellen Umgebung (nicht in globalen Paketen) installiert ist pip list --local
.
Hier finden Sie eine Dokumentation mit allen verfügbaren pip list
Optionen sowie einige gute Beispiele.
Sehr einfache Suche mit 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()
und es hat auch funktioniert.
Ich bin auf ein benutzerdefiniertes Python 2.7 unter OS X gestoßen. X11 musste die installierten Module auflisten (sowohl mit Hilfe als auch mit Pydoc).
Um alle Module auflisten zu können, ohne X11 zu installieren, habe ich pydoc als http-Server ausgeführt, dh:
pydoc -p 12345
Dann ist es möglich, Safari anzuweisen, http://localhost:12345/
alle Module anzuzeigen.
Probiere diese
pip list
oder
pip freeze
Geben Sie in Terminal oder IPython Folgendes ein:
help('modules')
dann
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
Diese Lösung basiert hauptsächlich auf Modulen importlib
und pkgutil
funktioniert mit CPython 3.4 und CPython 3.5, unterstützt jedoch CPython 2 nicht.
Erläuterung
sys.builtin_module_names
- benennt alle eingebauten Module (siehe meine Antwort hier )pkgutil.iter_modules()
- gibt Informationen zu allen verfügbaren Modulen zurückimportlib.util.find_spec()
- gibt Informationen zum Importieren des Moduls zurück, falls vorhandenBuiltinImporter
- ein Importeur für eingebaute Module ( docs )SourceFileLoader
- ein Importer für ein Standard-Python-Modul (standardmäßig mit der Erweiterung * .py) ( docs )ExtensionFileLoader
- ein Importer für Module als gemeinsam genutzte Bibliothek (geschrieben auf C oder C ++)Vollständiger Code
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()
Verwendungszweck
Für den CPython3.5 (abgeschnitten)
$ 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*******************************)
Für den CPython3.4 (abgeschnitten)
$ 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
Paketverwaltungssystem, mit dem in Python geschriebene Softwarepakete installiert und verwaltet werden. Das Ergebnis pip.get_installed_distributions()
gibt Module zurück, die mit dem Pip installiert wurden. Meine Antwort basiert vollständig auf der Standardbibliothek von Python und deckt alle für den Import verfügbaren Module ab. Ein größter Nachteil meiner Antwort - keine Unterstützung für die CPython 2.
**truncated**
, bei der eine Ausgabe abgeschnitten wird. Vielleicht sind Sie nicht vorsichtig, aber wenn dies nicht der Fall ist. Um mir Informationen über Ihr System und die Python-Implementierung zu senden, werde ich zusätzliche Nachforschungen anstellen, um das Problem zu beheben.
Warnung: Adam Matan rät von dieser Verwendung in pip> 10.0 ab. Lesen Sie auch den Kommentar von @ sinoroc unten
Dies wurde von Adam Matans Antwort (der akzeptierten) inspiriert :
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))
die dann eine Tabelle in Form von druckt
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
------------------------------------------- -------------- ------
So können Sie leicht erkennen, welche Pakete Sie mit und ohne installiert haben sudo
.
Abgesehen von einem Hinweis: Ich habe festgestellt, dass bei der einmaligen Installation eines Pakets über sudo
und einmal ohne Vorrang ein Paket Vorrang hat, sodass das andere Paket nicht aufgeführt wird (nur ein Speicherort wird angezeigt). Ich glaube, dass dann nur der im lokalen Verzeichnis aufgeführt ist. Dies könnte verbessert werden.
pip
einmal zu verwenden und dann zu beenden. Es scheint eher ein Problem zu sein, dass sich das Verhalten ändern könnte.
_internal
). Alles in allem funktioniert es offensichtlich, ist aber eine schlechte Praxis. Es gibt bessere Alternativen, einige finden sich in den anderen Antworten auf diese Frage.
Abgesehen von der Verwendung habe pip freeze
ich Eigelb in meinen virtuellen Umgebungen installiert .
Falls Sie eine Anaconda-Python-Distribution installiert haben, können Sie diese auch verwenden
$conda list
zusätzlich zu den oben beschriebenen Lösungen.
conda install
, es sollte funktionieren :)
sys.modules
pip
) zu erhalten, können Sie sich ansehenpip.get_installed_distributions()
Für den zweiten Zweck Beispielcode:
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
oder die von python.org ? Für den ersteren kann ich sys.modules
problemlos verwenden.
system.modules
anstelle von sys.modules
.
Führen Sie Folgendes in Ihrem Python-Editor oder IPython aus
import pkg_resources;
installed_packages = {d.project_name: d.version for d in pkg_resources.working_set}
print(installed_packages)
Lesen Sie andere Antworten und haben Sie diese Kombination zusammengestellt, die in Python am schnellsten und einfachsten ist
pip freeze macht alles, um Pakete zu finden, aber man kann einfach den folgenden Befehl schreiben, um alle Pfade aufzulisten, in denen sich Python-Pakete befinden.
>>> import site; site.getsitepackages()
['/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages']
Es gibt viele Ideen, anfangs denke ich über diese beiden nach:
Pip
Nachteile: nicht immer installiert
Hilfe ('Module')
Nachteile: Ausgabe an die Konsole; mit defekten modulen (siehe ubuntu ...) kann segfault
Ich brauche einen einfachen Ansatz, der grundlegende Bibliotheken verwendet und mit dem alten Python 2.x kompatibel ist
Und ich sehe das Licht: listmodules.py
Im Quellverzeichnis der Dokumentation in 2.5 ist ein kleines Skript versteckt, das alle verfügbaren Module für eine Python-Installation auflistet.
Vorteile:
verwendet nur imp, sys, os, re, time
Entwickelt für Python 1.5.2 und höher
Der Quellcode ist sehr kompakt, so dass Sie leicht daran basteln können, um beispielsweise eine Ausnahmeliste mit fehlerhaften Modulen zu übergeben (versuchen Sie nicht, sie zu importieren).
Ich musste die spezifische Version der Pakete finden, die standardmäßig in AWS Lambda verfügbar sind. Ich habe dies mit einem Mashup von Ideen von dieser Seite getan. Ich teile es für die Nachwelt.
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
],
}
Was ich entdeckte, war, dass die bereitgestellte boto3-Bibliothek veraltet war und es nicht meine Schuld war, dass mein Code fehlschlug. Ich musste meinem Projekt nur boto3 und botocore hinzufügen. Aber ohne das hätte ich mir den Kopf geschlagen, weil ich dachte, mein Code sei schlecht.
{
"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
},
...
Was ich entdeckte, war auch anders als das, was sie offiziell veröffentlichen . Zum Zeitpunkt des Schreibens dieses:
- Betriebssystem - Amazon Linux
- AMI - amzn-ami-hvm-2017.03.1.20170812-x86_64-gp2
- Linux-Kernel - 4.14.77-70.59.amzn1.x86_64
- AWS SDK für JavaScript - 2.290.0 \
- SDK für 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
Beispielausgabe:
multiprocessing
netrc
nntplib
ntpath
nturl2path
numbers
opcode
pickle
pickletools
pipes
pkgutil
Hier ist eine Python-Codelösung, die eine Liste der installierten Module zurückgibt. Man kann den Code leicht ändern, um Versionsnummern einzuschließen.
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)
Für alle, die sich fragen, wie sie pip list
von einem Python-Programm aus aufrufen sollen , können Sie Folgendes verwenden:
import pip
pip.main(['list]) # this will print all the packages
Aus der Schale
ls site-packages
Wenn das nicht hilfreich ist, können Sie dies tun.
import sys
import os
for p in sys.path:
print os.listdir( p )
Und sehen, was das bringt.