Quelle est la bonne façon d'installer pip, virtualenv et distribuer pour Python?

vous pouvez le faire sans installer n'importe quoi dans python lui-même.

Vous n'avez pas besoin de sudo ou de privilèges.

vous n'avez pas besoin d'éditer des fichiers.

installez virtualenv dans un environnement virtuel bootstrap. Utilisez l'environnement virtuel pour en créer davantage. Puisque virtualenv est livré avec pip et distribute, vous obtenez tout à partir d'une installation.

1. Télécharger virtualenv:
   • http://pypi.python.org/pypi/virtualenv
   • https://pypi.python.org/packages/source/v/virtualenv/virtualenv-12.0.7.tar.gz (ou quelle est la dernière version!)
2. Décompresser l'archive source
3. utilisez l'Archive Non empaquetée pour créer un environnement virtuel propre. Cet environnement virtuel sera utilisé pour" bootstrap " autres. Tous vos environnements virtuels contiendront automatiquement pip et distribueront.
4. avec pip, installez virtualenv dans cet environnement bootstrap.
5. Utilisez cet environnement bootstrap pour en créer plus!

voici un exemple dans bash:

# Select current version of virtualenv:
VERSION=12.0.7
# Name your first "bootstrap" environment:
INITIAL_ENV=bootstrap
# Set to whatever python interpreter you want for your first environment:
PYTHON=$(which python)
URL_BASE=https://pypi.python.org/packages/source/v/virtualenv

# --- Real work starts here ---
curl -O $URL_BASE/virtualenv-$VERSION.tar.gz
tar xzf virtualenv-$VERSION.tar.gz
# Create the first "bootstrap" environment.
$PYTHON virtualenv-$VERSION/virtualenv.py $INITIAL_ENV
# Don't need this anymore.
rm -rf virtualenv-$VERSION
# Install virtualenv into the environment.
$INITIAL_ENV/bin/pip install virtualenv-$VERSION.tar.gz

Maintenant, vous pouvez utiliser votre environnement "bootstrap" pour en créer plus:

# Create a second environment from the first:
$INITIAL_ENV/bin/virtualenv py-env1
# Create more:
$INITIAL_ENV/bin/virtualenv py-env2

Aller de noix!

Note

cela suppose que vous n'utilisez pas une version vraiment ancienne de virtualenv. Les anciennes versions nécessitaient les drapeaux --no-site-packges (et selon la version de Python, --distribute ). Maintenant, vous pouvez créer votre environnement bootstrap avec juste python virtualenv.py path-to-bootstrap ou python3 virtualenv.py path-to-bootstrap .

je pense que glyphe veut dire faire quelque chose comme ça:

1. créer un répertoire ~/.local , s'il n'existe pas déjà.
2. dans votre ~/.bashrc , assurez-vous que ~/.local/bin est sur PATH et que ~/.local est sur PYTHONPATH .

3. créer un fichier ~/.pydistutils.cfg qui contient

   [install]
   prefix=~/.local
   

   c'est un fichier standard au format ConfigParser.

4. Télécharger distribute_setup.py et exécuter python distribute_setup.py (pas de sudo ). S'il se plaint d'un répertoire site-packages inexistant, créez-le manuellement:

   mkdir-p ~/.local/lib / python2.7 / site-packages /

5. exécuter which easy_install pour vérifier qu'il vient de ~/.local/bin

6. Exécuter pip install virtualenv
7. Exécuter pip install virtualenvwrapper
8. créez un dossier contenant env virtuel, dites ~/.virtualenvs

9. Dans ~/.bashrc ajouter

   export WORKON_HOME
   source ~/.local/bin/virtualenvwrapper.sh
   

C'est tout, pas du tout d'utilisation de sudo et votre environnement Python est dans ~/.local , complètement séparé du Python de L'OS. Avertissement: Je ne suis pas sûr de la compatibilité de virtualenvwrapper dans ce scénario - Je ne pouvais pas le tester sur mon système :-)

si vous suivez les étapes conseillées dans plusieurs tutoriels que j'ai lié dans cette réponse , vous peut obtenir l'effet désiré sans les étapes "manuelles" quelque peu compliquées dans les réponses de Walker et Vinay. Si vous êtes sur Ubuntu:

sudo apt-get install python-pip python-dev

L'équivalent est obtenu dans OS X en utilisant homebrew pour installer python (plus de détails ici ).

brew install python

avec pip installé, vous peut l'utiliser pour récupérer les paquets restants (vous pouvez omettre sudo dans OS X, car vous utilisez votre installation python locale).

sudo pip install virtualenvwrapper

(ce sont les seuls paquets dont vous avez besoin installés globalement et je doute qu'ils puissent entrer en conflit avec quoi que ce soit au niveau du système d'exploitation. Si vous voulez être super-sûr, vous pouvez garder les versions de la distro sudo apt-get install virtualenvwrapper )

Note: dans Ubuntu 14.04 je reçois des quelques erreurs avec pip installer , donc j'utilise pip3 install virtualenv virtualenvwrapper et j'ajoute VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3 à mon fichier .bashrc/.zshrc .

vous ajoutez ensuite à votre .bashrc fichier

export WORKON_HOME
source /usr/local/bin/virtualenvwrapper.sh

et la source

. ~/.bashrc

c'est en gros ça. Maintenant la seule décision est de savoir si vous voulez créer un virtualenv pour inclure des paquets au niveau du système

mkvirtualenv --system-site-packages foo

où vos paquets système existants ne doivent pas être réinstallés, ils sont symlinkés aux versions de l'interpréteur de système. Note: vous pouvez toujours installer de nouveaux paquets et mettre à niveau les paquets inclus à partir du système existants sans sudo-Je l'ai testé et cela fonctionne sans aucune perturbation de l'interpréteur système.

kermit@hocus-pocus:~$ sudo apt-get install python-pandas
kermit@hocus-pocus:~$ mkvirtualenv --system-site-packages s
(s)kermit@hocus-pocus:~$ pip install --upgrade pandas
(s)kermit@hocus-pocus:~$ python -c "import pandas; print(pandas.__version__)"
0.10.1
(s)kermit@hocus-pocus:~$ deactivate
kermit@hocus-pocus:~$ python -c "import pandas; print(pandas.__version__)"
0.8.0

l'alternative, si vous voulez un environnement complètement séparé, est

mkvirtualenv --no-site-packages bar

ou étant donné que c'est l'option par défaut, il suffit de

mkvirtualenv bar

le résultat est que vous avez un nouveau virtualenv où vous pouvez installer librement et sans effort vos paquets préférés

pip install flask

Python 3.4 onward

Python 3.3 ajoute le module venv , et Python 3.4 ajoute le module ensurepip . Cela rend bootstrapping pip aussi facile que:

python-m ensurepip

peut-être précédé d'un appel à venv pour le faire dans un environnement virtuel.

le PEP garanti est décrit dans PEP 453 .

Sur Ubuntu:

sudo apt-get install python-virtualenv

le paquet python-pip est une dépendance, il sera donc également installé.

j'ai fait cette procédure pour que nous l'utilisions au travail.

cd ~
curl -s https://pypi.python.org/packages/source/p/pip/pip-1.3.1.tar.gz | tar xvz
cd pip-1.3.1
python setup.py install --user
cd ~
rm -rf pip-1.3.1

$HOME/.local/bin/pip install --user --upgrade pip distribute virtualenvwrapper

# Might want these three in your .bashrc
export PATH=$PATH:$HOME/.local/bin
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS="--distribute"
source $HOME/.local/bin/virtualenvwrapper.sh

mkvirtualenv mypy
workon mypy
pip install --upgrade distribute
pip install pudb # Or whatever other nice package you might want.

points-Clés pour la sécurité à l'esprit:

1. curl n'ssl de validation. pas wget.
2. à partir de pip 1.3.1, pip effectue également la validation ssl.
3. moins d'utilisateurs peuvent télécharger la PyPI tarball qu'une GitHub tarball.

mise à jour: à partir de juillet 2013 ce projet n'est plus maintenu. L'auteur suggère d'utiliser pyenv . (pyenv n'a pas de support intégré pour virtualenv, mais joue gentiment avec.)

Pythonbrew est un gestionnaire de version pour python et est fourni avec le support de virtualenv.

après avoir installé pythonbrew et un la version de python utilisant venvs est vraiment facile:

# Initializes the virtualenv 
pythonbrew venv init

# Create a virtual/sandboxed environment 
pythonbrew venv create mycoolbundle  

# Use it 
pythonbrew venv use mycoolbundle

il n'y a pas de problème à faire sudo python setup.py installez, si vous êtes sûr que c'est ce que vous voulez faire.

la différence est qu'il va utiliser le site-packages directory de votre OS comme une destination pour .fichiers py à copier.

donc, si vous voulez que pip soit accessible os large, c'est probablement la voie à suivre. Je ne dis pas que les autres voies sont mauvaises, mais c'est probablement assez juste.

Installer ActivePython . Elle inclut pip, virtualenv et Distribute.

j'ai rencontré le même problème récemment. Mon problème était donc d'installer virtualenv avec pip sans installer distribute dans mon répertoire global ou user site-packages. Pour ce faire, j'ai téléchargé manuellement distribuer, pip et virtualenv, et pour chacun j'ai couru "python setup.py installer --prefix ~/.local/python-private" (avec un réglage temporaire de PYTHONPATH=~/.local / python-private) pour que les scripts de configuration puissent trouver distribuer). J'ai déplacé le script virtualenv dans un autre répertoire que j'ai sur mon chemin et je l'ai édité pour que les modules distribute et virtualenv puissent être trouvés sur sys.chemin. Tada: Je n'ai pas installé quoi que ce soit dans /usr, /usr/local ou dans mon répertoire utilisateur site-paquets, mais je peux exécuter virtualenv n'importe où, et dans ce virtualenv j'obtiens pip.

j'ai eu divers problèmes (voir ci-dessous) installer des modules SSL mis à jour, même à l'intérieur d'un virtualenv, en plus des anciennes versions de Python fournies par OS, donc j'utilise maintenant pyenv .

pyenv rend très facile l'installation d'une nouvelle version de Python et supporte virtualenvs. 1519190920 plus facile que les recettes pour virtualenv énumérées dans d'autres réponses:

• Sur Mac, type brew install pyenv et sur Linux, utiliser pyenv-installer
• cela vous permet de prendre en charge virtualenv ainsi que la commutation de version Python (si nécessaire)
• fonctionne bien avec Python 2 ou 3, peut avoir plusieurs versions installées à la fois

cela fonctionne très bien pour isoler la version "new Python" et virtualenv du système Python. Parce que vous pouvez facilement utiliser un Python plus récent (post 2.7.9), les modules SSL sont déjà mis à niveau, et bien sûr, comme toute configuration virtualenv moderne, vous êtes isolé des modules système Python.

quelques jolis tutoriels:

• utilisant pyenv et virtualenv - lors de la sélection d'une version Python, il est plus facile d'utiliser pyenv global 3.6.1 (global to current user) ou pyenv local 2.7.13 (local to current directory).
• pyenv notions de base et de l'utilisation avec virtualenv

le plugin pyenv-virtualenv est maintenant construit en type pyenv commands | grep virtualenv à vérifier. Je n'utiliserais pas le plugin pyenv-virtualenvwrapper pour commencer - voyez comment vous vous en sortez avec pyenv-virtualenv qui est plus intégré dans pyenv, car cela couvre la plupart de ce que virtualenvwrapper fait.

pyenv est modelé sur rbenv (un bon outil pour la commutation de version Ruby) et sa seule dépendance est bash.

• pyenv n'a aucun lien avec le nom très similaire pyvenv - qui est un équivalent virtualenv qui fait partie des versions récentes de Python 3, et ne gère pas la commutation de version de Python

mises en garde

deux avertissements à propos de pyenv:

1. Il ne fonctionne qu'à partir d'un bash ou similaire shell - ou, plus précisément, la pyenv-virtualenv plugin n'aime pas dash , qui est /bin/sh sur Ubuntu ou Debian.
2. il doit être exécuté à partir d'un interpréteur de connexion interactif (par exemple bash --login à l'aide d'un terminal), ce qui n'est pas toujours facile à réaliser avec des outils d'automatisation comme .

par conséquent pyenv est le meilleur pour l'utilisation interactive, et moins bon pour les serveurs de script.

problèmes du module SSL

l'Une des raisons d'utiliser pyenv est qu'il y a souvent des problèmes de mise à niveau des modules SSL Python lorsque vous utilisez des versions Python fournies par un système plus ancien:

• Ubuntu 14.04 comprend Python 2.7.6 qui exige un effort considérable mettre à niveau vers la droite SSL modules de sorte qu'il gère SNI (server name indication) en tant que client. (J'ai écrit quelques scénarios possibles pour ce qui était assez douloureux et encore cassé dans certains cas.)
• les modules SSL mis à jour seront plus importants que Python.org les sites passent aux SDF 1.2 seulement en 2017 et 2018.

• vous pouvez le faire sans installer quoi que ce soit dans python lui-même.

• vous n'avez pas besoin de sudo ou de privilèges.

• vous n'avez pas besoin de trouver la dernière version d'un virtualenv fichier tar

• vous n'avez pas besoin de modifier les informations de version dans un script bash pour garder les choses à jour.

• Vous n'avez pas besoin de curl / wget ou tar installé, ni pip ou easy_install

• cela fonctionne pour 2.7 ainsi que pour 3.X

Enregistrer la suite de /tmp/initvenv.py :

à partir de avenir importer print_function

import os, sys, shutil, tempfile, subprocess, tarfile, hashlib

try:
    from urllib2 import urlopen
except ImportError:
    from urllib.request import urlopen

tmp_dir = tempfile.mkdtemp(prefix='initvenv_')
try:
    # read the latest version from PyPI
    f = urlopen("https://pypi.python.org/pypi/virtualenv/")
    # retrieve the .tar.gz file
    tar_found = False
    url = None
    sha256 = None
    for line in f.read().splitlines():
        if isinstance(line, bytes):
            line = line.decode('utf-8')
        if tar_found:
            if 'sha256' in line:
                sha256 = line.split('data-clipboard-text')[1].split('"')[1]
                break
            continue
        if not tar_found and 'tar.gz">' not in line:
            continue
        tar_found = True
        for url in line.split('"'):
            if url.startswith('https'):
                break
    else:
        print('tar.gz not found')
        sys.exit(1)
    file_name = url.rsplit('/', 1)[1]
    print(file_name)
    os.chdir(tmp_dir)
    data = urlopen(url).read()
    data_sha256 = hashlib.sha256(data).hexdigest()
    if sha256 != data_sha256:
        print('sha256 not correct')
        print(sha256)
        print(data_sha256)
        sys.exit(1)
    with open(file_name, 'wb') as fp:
        fp.write(data)
    tar = tarfile.open(file_name)
    tar.extractall()
    tar.close()
    os.chdir(file_name.replace('.tar.gz', ''))
    print(subprocess.check_output([sys.executable, 'virtualenv.py'] +
                                  [sys.argv[1]]).decode('utf-8'), end='')
    if len(sys.argv) > 2:
        print(subprocess.check_output([
            os.path.join(sys.argv[1], 'bin', 'pip'), 'install', 'virtualenv'] +

            sys.argv[2:]).decode('utf-8'), end='')
except:
    raise
finally:
    shutil.rmtree(tmp_dir)  # always clean up

et l'utiliser comme

python_binary_to_use_in_venv /tmp/initvenv.py your_venv_name [optional packages]

par exemple (si vous avez vraiment besoin de la couche de compatibilité distribute pour setuptools )

python /tmp/initvenv.py venv distribute

veuillez noter que, avec les anciennes versions de python, cela pourrait vous donner InsecurePlatformWarning s1.

une fois que vous avez votre virtualenv (nom par exemple venv ) , vous pouvez configurer un autre virtualenv en utilisant le virtualenv juste installé:

venv/bin/virtualenv venv2

virtualenvwrapper

I nous vous recommandons de jeter un oeil à virtualenvwrapper ainsi, après une configuration unique:

% /opt/python/2.7.10/bin/python /tmp/initvenv.py venv virtualenvwrapper

et l'activation (peut être fait à partir de votre script de connexion):

% source venv/bin/virtualenvwrapper.sh

vous pouvez faire des choses comme:

% mktmpenv 
New python executable in tmp-17bdc3054a46b2b/bin/python
Installing setuptools, pip, wheel...done.
This is a temporary environment. It will be deleted when you run 'deactivate'.
(tmp-17bdc3054a46b2b)% 

1 _{Je n'ai pas trouvé le moyen de supprimer l'avertissement. Il pourrait être résolu dans pip et / ou request , mais les développeurs pointent vers l'un l'autre comme cause. J'ai reçu la recommandation, souvent non réaliste, de mettre à jour la version python que j'utilisais pour la dernière version. Je suis sûr que ça casserait E. g mon Linux Mint 17 install. Heureusement pip Cache Les paquets, de sorte que l'avertissement est fait une seule fois par paquet installer.}

il y a de bonnes instructions sur le site officiel Virtualenv. https://pypi.python.org/pypi/virtualenv

fondamentalement ce que j'ai fait, c'est Installer pip avec sudo easy_install pip , puis utilisé sudo pip install virtualenv puis créé un environnement avec: virtualenv my_env (nommez-le ce que vous voulez), suivant que j'ai fait: virtualenv --distribute my_env ; qui a installé distribute et pip dans mon virtualenv.

Encore une fois, suivez les instructions sur la page virtualenv .

une sorte de tracas, venant de Ruby ;p

Voici une bonne façon d'installer virtualenvwrapper(mise à jour de ce ).

télécharger virtualenv-1.11.4 (vous pouvez trouver la dernière à ici ), Unzip it, ouvrir terminal

# Create a bootstrapenv and activate it:
$ cd ~
$ python <path to unzipped folder>/virtualenv.py bootstrapenv
$ source bootstrapenv/bin/activate

# Install virtualenvwrapper:
$ pip install virtualenvwrapper
$ mkdir -p ~/bootstrapenv/Envs

# append it to file `.bashrc`
$ vi ~/.bashrc
  source ~/bootstrapenv/bin/activate
  export WORKON_HOME=~/bootstrapenv/Envs
  source ~/bootstrapenv/bin/virtualenvwrapper.sh

# run it now.
$ source ~/.bashrc

C'est ça, Maintenant vous pouvez utiliser mkvirtualenv env1 , lsvirtualenv ..etc

Note: Vous pouvez supprimer virtualenv-1.11.4 et virtualenv-1.11.4.zip des dossiers de téléchargement.

la bonne nouvelle est que vous avez installé python3.4, pyvenv est déjà installé. Donc, Juste

pyvenv project_dir
source project_dir/bin/activate
python --version   
python 3.4.*

maintenant dans cet env virtuel, vous pouvez utiliser pip pour installer des modules pour ce projet.

quittez cet env virtuel, juste

deactivate