28.3. "venv" --- 创建虚拟环境
*****************************

3.3 版新加入.

**源码：** Lib/venv/

======================================================================

The "venv" module provides support for creating lightweight "virtual
environments" with their own site directories, optionally isolated
from system site directories.  Each virtual environment has its own
Python binary (allowing creation of environments with various Python
versions) and can have its own independent set of installed Python
packages in its site directories.

有关 Python 虚拟环境的更多信息，请参阅 **PEP 405** 。

備註:

  从 Python 3.6 开始，不推荐使用 "pyvenv" 脚本，而是使用 "python3 -m
  venv" 来帮助防止任何关于虚拟环境将基于哪个 Python 解释器的混淆。


28.3.1. 创建虚拟环境
====================

通过执行 "venv" 指令来创建一个 虚拟环境:

   python3 -m venv /path/to/new/virtual/environment

Running this command creates the target directory (creating any parent
directories that don't exist already) and places a "pyvenv.cfg" file
in it with a "home" key pointing to the Python installation from which
the command was run.  It also creates a "bin" (or "Scripts" on
Windows) subdirectory containing a copy/symlink of the Python
binary/binaries (as appropriate for the platform or arguments used at
environment creation time). It also creates an (initially empty)
"lib/pythonX.Y/site-packages" subdirectory (on Windows, this is "Lib
\site-packages"). If an existing directory is specified, it will be
re-used.

3.6 版後已棄用: "pyvenv" 是 Python 3.3 和 3.4 中创建虚拟环境的推荐工具
，不过 在 Python 3.6 中已弃用。

3.5 版更變: 现在推荐使用 "venv" 来创建虚拟环境。

也參考: Python 软件包用户指南：创建和使用虚拟环境

在 Windows 上，调用 "venv" 命令如下:

   c:\>c:\Python35\python -m venv c:\path\to\myenv

或者，如果已经为 Python 安装 配置好 "PATH" 和 "PATHEXT" 变量:

   c:\>python -m venv c:\path\to\myenv

本命令如果以 "-h" 参数运行，将显示可用的选项:

   usage: venv [-h] [--system-site-packages] [--symlinks | --copies] [--clear]
               [--upgrade] [--without-pip]
               ENV_DIR [ENV_DIR ...]

   Creates virtual Python environments in one or more target directories.

   positional arguments:
     ENV_DIR               A directory to create the environment in.

   optional arguments:
     -h, --help            show this help message and exit
     --system-site-packages
                           Give the virtual environment access to the system
                           site-packages dir.
     --symlinks            Try to use symlinks rather than copies, when symlinks
                           are not the default for the platform.
     --copies              Try to use copies rather than symlinks, even when
                           symlinks are the default for the platform.
     --clear               Delete the contents of the environment directory if it
                           already exists, before environment creation.
     --upgrade             Upgrade the environment directory to use this version
                           of Python, assuming Python has been upgraded in-place.
     --without-pip         Skips installing or upgrading pip in the virtual
                           environment (pip is bootstrapped by default)

   Once an environment has been created, you may wish to activate it, e.g. by
   sourcing an activate script in its bin directory.

3.4 版更變: 默认安装 pip，并添加 "--without-pip" 和 "--copies" 选项

3.4 版更變: 在早期版本中，如果目标目录已存在，将引发错误，除非使用了 "
--clear" 或 "--upgrade" 选项。

生成的 "pyvenv.cfg" 文件还包括 "include-system-site-packages" 键，如果
运行 "venv" 带有 "--system-site-packages" 选项，则键值为 "true"，否则
为 "false"。

除非采用 "--without-pip" 选项，否则将会调用 "ensurepip" 将 "pip" 引导
到虚拟环境中。

可以向 "venv" 传入多个路径，此时将根据给定的选项，在所给的每个路径上创
建相同的虚拟环境。

创建虚拟环境后，可以使用虚拟环境的二进制目录中的脚本来“激活”该环境。不
同平台调用的脚本是不同的（须将 *<venv>* 替换为包含虚拟环境的目录路径）
：

+---------------+-------------------+-------------------------------------------+
| 平台          | Shell             | 用于激活虚拟环境的命令                    |
|===============|===================|===========================================|
| Posix         | bash/zsh          | $ source <venv>/bin/activate              |
+---------------+-------------------+-------------------------------------------+
|               | fish              | $ . <venv>/bin/activate.fish              |
+---------------+-------------------+-------------------------------------------+
|               | csh/tcsh          | $ source <venv>/bin/activate.csh          |
+---------------+-------------------+-------------------------------------------+
| Windows       | cmd.exe           | C:\> <venv>\Scripts\activate.bat          |
+---------------+-------------------+-------------------------------------------+
|               | PowerShell        | PS C:\> <venv>\Scripts\Activate.ps1       |
+---------------+-------------------+-------------------------------------------+

激活环境不是 *必须* 的，激活只是将虚拟环境的二进制目录添加到搜索路径中
，这样 "python" 命令将调用虚拟环境的 Python 解释器，可以运行其中已安装
的脚本，而不必输入其完整路径。但是，安装在虚拟环境中的所有脚本都应在不
激活的情况下可运行，并自动与虚拟环境的 Python 一起运行。

You can deactivate a virtual environment by typing "deactivate" in
your shell. The exact mechanism is platform-specific: for example, the
Bash activation script defines a "deactivate" function, whereas on
Windows there are separate scripts called "deactivate.bat" and
"Deactivate.ps1" which are installed when the virtual environment is
created.

3.4 版新加入: "fish" 和 "csh" 激活脚本。

備註:

  虚拟环境是一个 Python 环境，安装到其中的 Python 解释器、库和脚本与其
  他虚拟环境中的内容是隔离的，且（默认）与“系统级” Python（操作系统的
  一部分）中安装的库是隔离的。虚拟环境是一个目录树，其中包含 Python 可
  执行文件和其他文件，其他文件指示了这是一个是虚拟环境。Common
  installation tools such as "Setuptools" and "pip" work as expected
  with virtual environments. In other words, when a virtual
  environment is active, they install Python packages into the virtual
  environment without needing to be told to do so explicitly.当虚拟环
  境被激活（即虚拟环境的 Python 解释器正在运行），属性 "sys.prefix" 和
  "sys.exec_prefix" 指向的是虚拟环境的基础目录，而 "sys.base_prefix"
  和 "sys.base_exec_prefix" 指向非虚拟环境的 Python 安装，即曾用于创建
  虚拟环境的那个 Python 安装。如果虚拟环境没有被激活，则 "sys.prefix"
  与 "sys.base_prefix" 相同，且 "sys.exec_prefix" 与
  "sys.base_exec_prefix" 相同（它们均指向非虚拟环境的 Python 安装）。
  When a virtual environment is active, any options that change the
  installation path will be ignored from all distutils configuration
  files to prevent projects being inadvertently installed outside of
  the virtual environment.When working in a command shell, users can
  make a virtual environment active by running an "activate" script in
  the virtual environment's executables directory (the precise
  filename is shell-dependent), which prepends the virtual
  environment's directory for executables to the "PATH" environment
  variable for the running shell. There should be no need in other
  circumstances to activate a virtual environment—scripts installed
  into virtual environments have a "shebang" line which points to the
  virtual environment's Python interpreter. This means that the script
  will run with that interpreter regardless of the value of "PATH". On
  Windows, "shebang" line processing is supported if you have the
  Python Launcher for Windows installed (this was added to Python in
  3.3 - see **PEP 397** for more details). Thus, double-clicking an
  installed script in a Windows Explorer window should run the script
  with the correct interpreter without there needing to be any
  reference to its virtual environment in "PATH".


28.3.2. API
===========

上述的高级方法使用了一个简单的 API，该 API 提供了一种机制，第三方虚拟
环境创建者可以根据其需求自定义环境创建过程，该 API 为 "EnvBuilder" 类
。

class venv.EnvBuilder(system_site_packages=False, clear=False, symlinks=False, upgrade=False, with_pip=False, prompt=None)

   "EnvBuilder" 类在实例化时接受以下关键字参数：

   * "system_site_packages" -- 一个布尔值，要求系统 Python 的 site-
     packages 对环境可用（默认为 "False"）。

   * "clear" -- 一个布尔值，如果为 true，则在创建环境前将删除目标目录
     的现有内容。

   * "symlinks" -- a Boolean value indicating whether to attempt to
     symlink the Python binary (and any necessary DLLs or other
     binaries, e.g. "pythonw.exe"), rather than copying.

   * "upgrade" -- 一个布尔值，如果为 true，则将使用当前运行的 Python
     去升级一个现有的环境，这主要在原位置的 Python 更新后使用（默认为
     "False"）。

   * "with_pip" -- 一个布尔值，如果为 true，则确保在虚拟环境中已安装
     pip。这使用的是带有 "--default-pip" 选项的 "ensurepip"。

   * "prompt" -- a String to be used after virtual environment is
     activated (defaults to "None" which means directory name of the
     environment would be used).

   3.4 版更變: 添加 "with_pip" 参数

   3.6 版新加入: 添加 "prompt" 参数

   Creators of third-party virtual environment tools will be free to
   use the provided "EnvBuilder" class as a base class.

   返回的 env-builder 是一个对象，包含一个 "create" 方法：

   create(env_dir)

      This method takes as required argument the path (absolute or
      relative to the current directory) of the target directory which
      is to contain the virtual environment.  The "create" method will
      either create the environment in the specified directory, or
      raise an appropriate exception.

      The "create" method of the "EnvBuilder" class illustrates the
      hooks available for subclass customization:

         def create(self, env_dir):
             """
             Create a virtualized Python environment in a directory.
             env_dir is the target directory to create an environment in.
             """
             env_dir = os.path.abspath(env_dir)
             context = self.ensure_directories(env_dir)
             self.create_configuration(context)
             self.setup_python(context)
             self.setup_scripts(context)
             self.post_setup(context)

      每个方法 "ensure_directories()", "create_configuration()",
      "setup_python()", "setup_scripts()" 和 "post_setup()" 都可以被重
      写。

   ensure_directories(env_dir)

      创建环境目录和所有必需的目录，并返回一个上下文对象。该对象只是一
      个容器，保存属性（如路径），供其他方法使用。允许目录已经存在，如
      果指定了 "clear" 或 "upgrade" 就允许在现有环境目录上进行操作。

   create_configuration(context)

      在环境中创建 "pyvenv.cfg" 配置文件。

   setup_python(context)

      Creates a copy of the Python executable (and, under Windows,
      DLLs) in the environment. On a POSIX system, if a specific
      executable "python3.x" was used, symlinks to "python" and
      "python3" will be created pointing to that executable, unless
      files with those names already exist.

   setup_scripts(context)

      将适用于平台的激活脚本安装到虚拟环境中。

   post_setup(context)

      占位方法，可以在第三方实现中重写，用于在虚拟环境中预安装软件包，
      或是其他创建后要执行的步骤。

   此外，"EnvBuilder" 提供了如下实用方法，可以从子类的
   "setup_scripts()" 或 "post_setup()" 调用，用来将自定义脚本安装到虚
   拟环境中。

   install_scripts(context, path)

      *path* 是一个目录的路径，该目录应包含子目录 "common", "posix",
      "nt"，每个子目录存有发往对应环境中 bin 目录的脚本。在下列占位符
      替换完毕后，将复制 "common" 的内容和与 "os.name" 对应的子目录：

      * "__VENV_DIR__" 会被替换为环境目录的绝对路径。

      * "__VENV_NAME__" 会被替换为环境名称（环境目录的最后一个字段）。

      * "__VENV_PROMPT__" 会被替换为提示符（用括号括起来的环境名称紧跟
        着一个空格）。

      * "__VENV_BIN_NAME__" 会被替换为 bin 目录的名称（ "bin" 或
        "Scripts" ）。

      * "__VENV_PYTHON__" 会被替换为环境可执行文件的绝对路径。

      允许目录已存在（用于升级现有环境时）。

有一个方便实用的模块级别的函数:

venv.create(env_dir, system_site_packages=False, clear=False, symlinks=False, with_pip=False)

   通过关键词参数来创建一个 "EnvBuilder"，并且使用 *env_dir* 参数来调
   用它的 "create()" 方法。

   3.4 版更變: 添加 "with_pip" 参数


28.3.3. 一个扩展 "EnvBuilder" 的例子
====================================

下面的脚本展示了如何通过实现一个子类来扩展 "EnvBuilder"。这个子类会安
装 setuptotols 和 pip 的到被创建的虚拟环境中。

   import os
   import os.path
   from subprocess import Popen, PIPE
   import sys
   from threading import Thread
   from urllib.parse import urlparse
   from urllib.request import urlretrieve
   import venv

   class ExtendedEnvBuilder(venv.EnvBuilder):
       """
       This builder installs setuptools and pip so that you can pip or
       easy_install other packages into the created virtual environment.

       :param nodist: If True, setuptools and pip are not installed into the
                      created virtual environment.
       :param nopip: If True, pip is not installed into the created
                     virtual environment.
       :param progress: If setuptools or pip are installed, the progress of the
                        installation can be monitored by passing a progress
                        callable. If specified, it is called with two
                        arguments: a string indicating some progress, and a
                        context indicating where the string is coming from.
                        The context argument can have one of three values:
                        'main', indicating that it is called from virtualize()
                        itself, and 'stdout' and 'stderr', which are obtained
                        by reading lines from the output streams of a subprocess
                        which is used to install the app.

                        If a callable is not specified, default progress
                        information is output to sys.stderr.
       """

       def __init__(self, *args, **kwargs):
           self.nodist = kwargs.pop('nodist', False)
           self.nopip = kwargs.pop('nopip', False)
           self.progress = kwargs.pop('progress', None)
           self.verbose = kwargs.pop('verbose', False)
           super().__init__(*args, **kwargs)

       def post_setup(self, context):
           """
           Set up any packages which need to be pre-installed into the
           virtual environment being created.

           :param context: The information for the virtual environment
                           creation request being processed.
           """
           os.environ['VIRTUAL_ENV'] = context.env_dir
           if not self.nodist:
               self.install_setuptools(context)
           # Can't install pip without setuptools
           if not self.nopip and not self.nodist:
               self.install_pip(context)

       def reader(self, stream, context):
           """
           Read lines from a subprocess' output stream and either pass to a progress
           callable (if specified) or write progress information to sys.stderr.
           """
           progress = self.progress
           while True:
               s = stream.readline()
               if not s:
                   break
               if progress is not None:
                   progress(s, context)
               else:
                   if not self.verbose:
                       sys.stderr.write('.')
                   else:
                       sys.stderr.write(s.decode('utf-8'))
                   sys.stderr.flush()
           stream.close()

       def install_script(self, context, name, url):
           _, _, path, _, _, _ = urlparse(url)
           fn = os.path.split(path)[-1]
           binpath = context.bin_path
           distpath = os.path.join(binpath, fn)
           # Download script into the virtual environment's binaries folder
           urlretrieve(url, distpath)
           progress = self.progress
           if self.verbose:
               term = '\n'
           else:
               term = ''
           if progress is not None:
               progress('Installing %s ...%s' % (name, term), 'main')
           else:
               sys.stderr.write('Installing %s ...%s' % (name, term))
               sys.stderr.flush()
           # Install in the virtual environment
           args = [context.env_exe, fn]
           p = Popen(args, stdout=PIPE, stderr=PIPE, cwd=binpath)
           t1 = Thread(target=self.reader, args=(p.stdout, 'stdout'))
           t1.start()
           t2 = Thread(target=self.reader, args=(p.stderr, 'stderr'))
           t2.start()
           p.wait()
           t1.join()
           t2.join()
           if progress is not None:
               progress('done.', 'main')
           else:
               sys.stderr.write('done.\n')
           # Clean up - no longer needed
           os.unlink(distpath)

       def install_setuptools(self, context):
           """
           Install setuptools in the virtual environment.

           :param context: The information for the virtual environment
                           creation request being processed.
           """
           url = 'https://bitbucket.org/pypa/setuptools/downloads/ez_setup.py'
           self.install_script(context, 'setuptools', url)
           # clear up the setuptools archive which gets downloaded
           pred = lambda o: o.startswith('setuptools-') and o.endswith('.tar.gz')
           files = filter(pred, os.listdir(context.bin_path))
           for f in files:
               f = os.path.join(context.bin_path, f)
               os.unlink(f)

       def install_pip(self, context):
           """
           Install pip in the virtual environment.

           :param context: The information for the virtual environment
                           creation request being processed.
           """
           url = 'https://raw.github.com/pypa/pip/master/contrib/get-pip.py'
           self.install_script(context, 'pip', url)

   def main(args=None):
       compatible = True
       if sys.version_info < (3, 3):
           compatible = False
       elif not hasattr(sys, 'base_prefix'):
           compatible = False
       if not compatible:
           raise ValueError('This script is only for use with '
                            'Python 3.3 or later')
       else:
           import argparse

           parser = argparse.ArgumentParser(prog=__name__,
                                            description='Creates virtual Python '
                                                        'environments in one or '
                                                        'more target '
                                                        'directories.')
           parser.add_argument('dirs', metavar='ENV_DIR', nargs='+',
                               help='A directory in which to create the
                                    'virtual environment.')
           parser.add_argument('--no-setuptools', default=False,
                               action='store_true', dest='nodist',
                               help="Don't install setuptools or pip in the "
                                    "virtual environment.")
           parser.add_argument('--no-pip', default=False,
                               action='store_true', dest='nopip',
                               help="Don't install pip in the virtual "
                                    "environment.")
           parser.add_argument('--system-site-packages', default=False,
                               action='store_true', dest='system_site',
                               help='Give the virtual environment access to the '
                                    'system site-packages dir.')
           if os.name == 'nt':
               use_symlinks = False
           else:
               use_symlinks = True
           parser.add_argument('--symlinks', default=use_symlinks,
                               action='store_true', dest='symlinks',
                               help='Try to use symlinks rather than copies, '
                                    'when symlinks are not the default for '
                                    'the platform.')
           parser.add_argument('--clear', default=False, action='store_true',
                               dest='clear', help='Delete the contents of the '
                                                  'virtual environment '
                                                  'directory if it already '
                                                  'exists, before virtual '
                                                  'environment creation.')
           parser.add_argument('--upgrade', default=False, action='store_true',
                               dest='upgrade', help='Upgrade the virtual '
                                                    'environment directory to '
                                                    'use this version of '
                                                    'Python, assuming Python '
                                                    'has been upgraded '
                                                    'in-place.')
           parser.add_argument('--verbose', default=False, action='store_true',
                               dest='verbose', help='Display the output '
                                                  'from the scripts which '
                                                  'install setuptools and pip.')
           options = parser.parse_args(args)
           if options.upgrade and options.clear:
               raise ValueError('you cannot supply --upgrade and --clear together.')
           builder = ExtendedEnvBuilder(system_site_packages=options.system_site,
                                          clear=options.clear,
                                          symlinks=options.symlinks,
                                          upgrade=options.upgrade,
                                          nodist=options.nodist,
                                          nopip=options.nopip,
                                          verbose=options.verbose)
           for d in options.dirs:
               builder.create(d)

   if __name__ == '__main__':
       rc = 1
       try:
           main()
           rc = 0
       except Exception as e:
           print('Error: %s' % e, file=sys.stderr)
       sys.exit(rc)

This script is also available for download online.
