web-dev-qa-db-fra.com

Installer le module python dans le code

J'ai besoin d'installer un paquet de PyPi directement dans mon script . Peut-être existe-t-il un module ou une fonctionnalité distutils (distribute, pip etc.) qui me permet d'exécuter quelque chose comme pypi.install('requests') et des requêtes seront installées dans mon virtualenv.

pythonpippython-modulepypi
194
chuwy

Vous pouvez également utiliser quelque chose comme:

import pip

def install(package):
    if hasattr(pip, 'main'):
        pip.main(['install', package])
    else:
        pip._internal.main(['install', package])

# Example
if __== '__main__':
    install('argh')
319
Rikard Anglerud

La solution de Rickard n’est pas prise en charge par l’équipe de développement de pip et échouera dans certains cas (par exemple, en multithread). De plus, depuis le pip 10, le code a été déplacé vers pip._internal afin de préciser que cela n'est pas pris en charge. Cette solution échouera donc avec une erreur d'importation sur "pip> = 10.0.0".

La solution de Quantum est le moyen préféré de résoudre le problème, mais sa mise en œuvre ne garantit pas qu'il appellera le bon pip.

Cette solution garantit qu’il appelle le pip de l’interpréteur python exécutant le code.

import subprocess
import sys

def install(package):
    subprocess.call([sys.executable, "-m", "pip", "install", package])

Il fait la même chose que la solution de Quantum, mais au lieu d'exécuter pip directement, il exécute le même exécutable python qui exécute le code et lui dit d'exécuter le module pip qu'il a installé et lui transmet le reste des arguments.

68
Aaron de Windt

Si vous souhaitez utiliser pip pour installer le package requis et l'importer après l'installation, vous pouvez utiliser ce code:

def install_and_import(package):
    import importlib
    try:
        importlib.import_module(package)
    except ImportError:
        import pip
        pip.main(['install', package])
    finally:
        globals()[package] = importlib.import_module(package)


install_and_import('transliterate')

Si vous avez installé un package en tant qu'utilisateur, vous pouvez rencontrer le problème suivant lequel vous ne pouvez pas simplement importer le package. Voir Comment actualiser sys.path? pour plus d'informations.

66
rominf

Cela devrait fonctionner:

import subprocess

def install(name):
    subprocess.call(['pip', 'install', name])
13
quantum

Vous définissez le module dépendant dans le fichier setup.py de votre propre paquet avec l'option "install_requires". 

Si votre package doit générer un script de console, vous pouvez utiliser le point d'entrée "console_scripts" afin de générer un script d'encapsuleur qui sera placé dans le dossier "bin" (par exemple, de votre environnement virtualenv).

7
Andreas Jung

J'espère que cette question est toujours valable ..__ J'ai fait ce qui précède comme ceci:

    import sys
    import os
    import site 

    try:
       import pip
    except ImportError:
       print "installing pip"
       cmd = "Sudo easy_install pip"
       os.system(cmd)
       reload(site)

    try: 
       import requests
    except ImportError:
       print "no lib requests"
       import pip
       cmd = "Sudo pip install requests"
       print "Requests package is missing\nPlease enter root password to install required package"
       os.system(cmd)
       reload(site)

le deuxième bloc try peut également être écrit dans la partie else du premier bloc try, cependant, dans ma déclaration de problème, je dois écrire deux blocs séparés.

3
Umesh Kaushik

Je suppose que nous avons un pip sur notre machine et que nous allons essayer d’attraper la dépendance spécifique qui manque. Essayez cette méthode et laissez-moi savoir ce que vous pensez.

import os
try: 
    import something
    .....
    .....
except ImportError as e:
    pip = lambda : os.system('pip install' + str(e)[15:])
    pip()

En outre, s'il vous plaît, envisagez d'utiliser le module pip si vous utilisez les fonctions lambda pour appliquer le mécanisme d'importateur "en connaissance de cause". Il suffit de suivre cet extrait de code :)

try:
    import somthing
    ..........
    ..........
except ImportError as e:
    # importing pip module to handle pip functionalites
    import pip
    # create a lambda that import using pip by module_error_name=e[15:]
    installer = lambda : pip.main(['install', str(e)[15:])
    # create a lambda that import a module by linear_lambda_call
    importer = lambda x : __import__(str(x)).import_module()
    # install the module
    installer()
    # import the module
    importer()
1
SysMurff

Pour moi, cela fonctionne (python 2.x), en supposant que toutes les exigences sont définies dans requirements.txt:

def pip_auto_install():
    """
    Automatically installs all requirements if pip is installed.
    """
    try:
        from pip._internal import main as pip_main
        pip_main(['install', '-r', 'requirements.txt'])
    except ImportError:
        print("Failed to import pip. Please ensure that pip is installed.")
        print("For further instructions see "
              "https://pip.pypa.io/en/stable/installing/")
        sys.exit(-1)
    except Exception as err:
        print("Failed to install pip requirements: " + err.message)
        sys.exit(-1)


pip_auto_install()
1
siom

Voici comment i installe tous les packages de mes projets _.

Juste ajoutez tous les noms à la liste et exécutez-le un avant d'exécuter le code principal.

Combiner cela avec l'utilisation de "venv" est génial!

"""call this module to setup your python packages via pip"""

from pip._internal import main as pip

pip_install_argument = "install"

# packages to install
packages_to_install = [
        "numpy",        # math magic 1
        "scipy",        # math magic 2
        ]

def install(packages):
    """installes given packages via pip

    Args:
        package names as list

    Returns:
        None

    """
    global pip_install_argument
    for package in packages:
        pip([pip_install_argument, package])

if __== '__main__':
    install(packages_to_install)
0
Felix Quehl

J'utilise le os.system pour émuler un terminal os qui importe un module, car vous pouvez alors utiliser ce module dans tous les autres scripts.

Par exemple, je crée un moteur de jeu qui s'exécute sur des scripts distincts ajoutés. La plupart de ces scripts utilisent Pygame. Si l'utilisateur ne dispose pas de pygame, le fichier de démarrage l'ajoutera à l'aide du code suivant:

import os
os.system('pip install pygame')

Malheureusement, je ne sais pas comment mettre pip sur la machine de l'utilisateur, donc cela dépend de l'utilisateur.

0
X0FloH

1er 

> Download
> https://github.com/GeoNode/geonode-win-installer/blob/master/python_deps/pip-9.0.1-py2.py3-none-any.whl

2ème 

extract .whl file and;  use winRar
copy extracted file and paste sitepackage [or python module container]

files are.. pip and pip-19.0.3.dist-info

3ème 

import pip
pip.main(['install','scpy'])

scpy or any package you want to install
0
Eyasu

Vous pouvez installer à l’aide du module sys un puits

import sys
!{sys.executable} -m pip install <package> --user
0
Tom J Muthirenthi

Comme le module pip importable ne fonctionne pas toujours, il existe une méthode plus robuste:

def PackageInstall(error):
    '''
    Finds out which package is missing and downloads it automatically after five seconds.

    Use example:

    try:
        import numpy as np
        import matplotlib.pyplot as plot

    except ImportError as error:
        PackageInstall(error)

    '''
    import time, subprocess, os, sys
    lib = str(error)[15:].replace('\'', '')
    print('>>>',str(error))
    print('>>> Download will start after five seconds')
    time.sleep(5)
    subprocess.call("pip install " + lib)

    print('>>> Restarting')
    os.startfile(__file__)
    sys.exit()

Cela fonctionne sous Windows.

0
Ville