windows.rst 44.4 KB
Newer Older
1 2 3 4 5 6 7 8 9
.. highlightlang:: none

.. _using-on-windows:

*************************
 Using Python on Windows
*************************

.. sectionauthor:: Robert Lehmann <lehmannro@gmail.com>
10
.. sectionauthor:: Steve Dower <steve.dower@microsoft.com>
11 12 13 14 15 16 17

This document aims to give an overview of Windows-specific behaviour you should
know about when using Python on Microsoft Windows.

Installing Python
=================

18 19
Unlike most Unix systems and services, Windows does not include a system
supported installation of Python. To make Python available, the CPython team
20
has compiled Windows installers (MSI packages) with every `release
21
<https://www.python.org/download/releases/>`_ for many years. These installers
22 23 24 25
are primarily intended to add a per-user installation of Python, with the
core interpreter and library being used by a single user. The installer is also
able to install for all users of a single machine, and a separate ZIP file is
available for application-local distributions.
26

27 28 29 30 31
Supported Versions
------------------

As specified in :pep:`11`, a Python release only supports a Windows platform
while Microsoft considers the platform under extended support. This means that
32 33
Python |version| supports Windows Vista and newer. If you require Windows XP
support then please install Python 3.4.
34

35 36 37
Installation Steps
------------------

38 39 40
Four Python |version| installers are available for download - two each for the
32-bit and 64-bit versions of the interpreter. The *web installer* is a small
initial download, and it will automatically download the required components as
41 42 43 44 45
necessary. The *offline installer* includes the components necessary for a
default installation and only requires an internet connection for optional
features. See :ref:`install-layout-option` for other ways to avoid downloading
during installation.

46
After starting the installer, one of two options may be selected:
47 48 49

.. image:: win_installer.png

50
If you select "Install Now":
51

52
* You will *not* need to be an administrator (unless a system update for the
53 54
  C Runtime Library is required or you install the :ref:`launcher` for all
  users)
55
* Python will be installed into your user directory
56
* The :ref:`launcher` will be installed according to the option at the bottom
57
  of the first page
58
* The standard library, test suite, launcher and pip will be installed
59 60
* If selected, the install directory will be added to your :envvar:`PATH`
* Shortcuts will only be visible for the current user
61 62 63 64 65

Selecting "Customize installation" will allow you to select the features to
install, the installation location and other options or post-install actions.
To install debugging symbols or binaries, you will need to use this option.

66 67 68 69 70 71 72
To perform an all-users installation, you should select "Customize
installation". In this case:

* You may be required to provide administrative credentials or approval
* Python will be installed into the Program Files directory
* The :ref:`launcher` will be installed into the Windows directory
* Optional features may be selected during installation
73
* The standard library can be pre-compiled to bytecode
74 75 76
* If selected, the install directory will be added to the system :envvar:`PATH`
* Shortcuts are available for all users

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
.. _max-path:

Removing the MAX_PATH Limitation
--------------------------------

Windows historically has limited path lengths to 260 characters. This meant that
paths longer than this would not resolve and errors would result.

In the latest versions of Windows, this limitation can be expanded to
approximately 32,000 characters. Your administrator will need to activate the
"Enable Win32 long paths" group policy, or set the registry value
``HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem@LongPathsEnabled``
to ``1``.

This allows the :func:`open` function, the :mod:`os` module and most other
path functionality to accept and return paths longer than 260 characters when
using strings. (Use of bytes as paths is deprecated on Windows, and this feature
is not available when using bytes.)

After changing the above option, no further configuration is required.

.. versionchanged:: 3.6

   Support for long paths was enabled in Python.

102 103 104 105 106 107 108 109 110 111 112
.. _install-quiet-option:

Installing Without UI
---------------------

All of the options available in the installer UI can also be specified from the
command line, allowing scripted installers to replicate an installation on many
machines without user interaction.  These options may also be set without
suppressing the UI in order to change some of the defaults.

To completely hide the installer UI and install Python silently, pass the
113 114
``/quiet`` option. To skip past the user interaction but still display
progress and errors, pass the ``/passive`` option. The ``/uninstall``
115 116 117 118 119 120 121 122 123 124
option may be passed to immediately begin removing Python - no prompt will be
displayed.

All other options are passed as ``name=value``, where the value is usually
``0`` to disable a feature, ``1`` to enable a feature, or a path. The full list
of available options is shown below.

+---------------------------+--------------------------------------+--------------------------+
| Name                      | Description                          | Default                  |
+===========================+======================================+==========================+
125
| InstallAllUsers           | Perform a system-wide installation.  | 0                        |
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
+---------------------------+--------------------------------------+--------------------------+
| TargetDir                 | The installation directory           | Selected based on        |
|                           |                                      | InstallAllUsers          |
+---------------------------+--------------------------------------+--------------------------+
| DefaultAllUsersTargetDir  | The default installation directory   | :file:`%ProgramFiles%\\\ |
|                           | for all-user installs                | Python X.Y` or :file:`\  |
|                           |                                      | %ProgramFiles(x86)%\\\   |
|                           |                                      | Python X.Y`              |
+---------------------------+--------------------------------------+--------------------------+
| DefaultJustForMeTargetDir | The default install directory for    | :file:`%LocalAppData%\\\ |
|                           | just-for-me installs                 | Programs\\PythonXY` or   |
|                           |                                      | :file:`%LocalAppData%\\\ |
|                           |                                      | Programs\\PythonXY-32`   |
+---------------------------+--------------------------------------+--------------------------+
| DefaultCustomTargetDir    | The default custom install directory | (empty)                  |
|                           | displayed in the UI                  |                          |
+---------------------------+--------------------------------------+--------------------------+
| AssociateFiles            | Create file associations if the      | 1                        |
|                           | launcher is also installed.          |                          |
+---------------------------+--------------------------------------+--------------------------+
| CompileAll                | Compile all ``.py`` files to         | 0                        |
147
|                           | ``.pyc``.                            |                          |
148 149 150 151 152
+---------------------------+--------------------------------------+--------------------------+
| PrependPath               | Add install and Scripts directories  | 0                        |
|                           | tho :envvar:`PATH` and ``.PY`` to    |                          |
|                           | :envvar:`PATHEXT`                    |                          |
+---------------------------+--------------------------------------+--------------------------+
153 154 155
| Shortcuts                 | Create shortcuts for the interpreter,| 1                        |
|                           | documentation and IDLE if installed. |                          |
+---------------------------+--------------------------------------+--------------------------+
156 157 158 159 160 161 162 163 164 165 166 167
| Include_doc               | Install Python manual                | 1                        |
+---------------------------+--------------------------------------+--------------------------+
| Include_debug             | Install debug binaries               | 0                        |
+---------------------------+--------------------------------------+--------------------------+
| Include_dev               | Install developer headers and        | 1                        |
|                           | libraries                            |                          |
+---------------------------+--------------------------------------+--------------------------+
| Include_exe               | Install :file:`python.exe` and       | 1                        |
|                           | related files                        |                          |
+---------------------------+--------------------------------------+--------------------------+
| Include_launcher          | Install :ref:`launcher`.             | 1                        |
+---------------------------+--------------------------------------+--------------------------+
168 169 170
| InstallLauncherAllUsers   | Installs :ref:`launcher` for all     | 1                        |
|                           | users.                               |                          |
+---------------------------+--------------------------------------+--------------------------+
171 172 173 174 175 176 177 178 179 180 181 182 183
| Include_lib               | Install standard library and         | 1                        |
|                           | extension modules                    |                          |
+---------------------------+--------------------------------------+--------------------------+
| Include_pip               | Install bundled pip and setuptools   | 1                        |
+---------------------------+--------------------------------------+--------------------------+
| Include_symbols           | Install debugging symbols (`*`.pdb)  | 0                        |
+---------------------------+--------------------------------------+--------------------------+
| Include_tcltk             | Install Tcl/Tk support and IDLE      | 1                        |
+---------------------------+--------------------------------------+--------------------------+
| Include_test              | Install standard library test suite  | 1                        |
+---------------------------+--------------------------------------+--------------------------+
| Include_tools             | Install utility scripts              | 1                        |
+---------------------------+--------------------------------------+--------------------------+
184 185 186
| LauncherOnly              | Only installs the launcher. This     | 0                        |
|                           | will override most other options.    |                          |
+---------------------------+--------------------------------------+--------------------------+
187 188
| SimpleInstall             | Disable most install UI              | 0                        |
+---------------------------+--------------------------------------+--------------------------+
189 190 191
| SimpleInstallDescription  | A custom message to display when the | (empty)                  |
|                           | simplified install UI is used.       |                          |
+---------------------------+--------------------------------------+--------------------------+
192 193 194 195

For example, to silently install a default, system-wide Python installation,
you could use the following command (from an elevated command prompt)::

196
    python-3.6.0.exe /quiet InstallAllUsers=1 PrependPath=1 Include_test=0
197 198

To allow users to easily install a personal copy of Python without the test
199 200
suite, you could provide a shortcut with the following command. This will
display a simplified initial page and disallow customization::
201

202
    python-3.6.0.exe InstallAllUsers=0 Include_launcher=0 Include_test=0
203
        SimpleInstall=1 SimpleInstallDescription="Just for me, no test suite."
204 205 206 207 208

(Note that omitting the launcher also omits file associations, and is only
recommended for per-user installs when there is also a system-wide installation
that included the launcher.)

209 210 211 212 213 214 215 216 217 218 219 220 221 222
The options listed above can also be provided in a file named ``unattend.xml``
alongside the executable. This file specifies a list of options and values.
When a value is provided as an attribute, it will be converted to a number if
possible. Values provided as element text are always left as strings. This
example file sets the same options and the previous example::

    <Options>
        <Option Name="InstallAllUsers" Value="no" />
        <Option Name="Include_launcher" Value="0" />
        <Option Name="Include_test" Value="no" />
        <Option Name="SimpleInstall" Value="yes" />
        <Option Name="SimpleInstallDescription">Just for me, no test suite</Option>
    </Options>

223 224 225 226 227 228 229 230 231 232 233 234 235 236
.. _install-layout-option:

Installing Without Downloading
------------------------------

As some features of Python are not included in the initial installer download,
selecting those features may require an internet connection.  To avoid this
need, all possible components may be downloaded on-demand to create a complete
*layout* that will no longer require an internet connection regardless of the
selected features. Note that this download may be bigger than required, but
where a large number of installations are going to be performed it is very
useful to have a locally cached copy.

Execute the following command from Command Prompt to download all possible
237
required files.  Remember to substitute ``python-3.6.0.exe`` for the actual
238 239 240 241 242
name of your installer, and to create layouts in their own directories to
avoid collisions between files with the same name.

::

243
    python-3.6.0.exe /layout [optional target directory]
244 245 246

You may also specify the ``/quiet`` option to hide the progress display.

247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
Modifying an install
--------------------

Once Python has been installed, you can add or remove features through the
Programs and Features tool that is part of Windows. Select the Python entry and
choose "Uninstall/Change" to open the installer in maintenance mode.

"Modify" allows you to add or remove features by modifying the checkboxes -
unchanged checkboxes will not install or remove anything. Some options cannot be
changed in this mode, such as the install directory; to modify these, you will
need to remove and then reinstall Python completely.

"Repair" will verify all the files that should be installed using the current
settings and replace any that have been removed or modified.

"Uninstall" will remove Python entirely, with the exception of the
:ref:`launcher`, which has its own entry in Programs and Features.
264 265 266

Other Platforms
---------------
267 268

With ongoing development of Python, some platforms that used to be supported
Christian Heimes's avatar
Christian Heimes committed
269
earlier are no longer supported (due to the lack of users or developers).
270 271 272
Check :pep:`11` for details on all unsupported platforms.

* `Windows CE <http://pythonce.sourceforge.net/>`_ is still supported.
273
* The `Cygwin <https://cygwin.com/>`_ installer offers to install the Python
274
  interpreter as well (cf. `Cygwin package source
275 276 277 278
  <ftp://ftp.uni-erlangen.de/pub/pc/gnuwin32/cygwin/mirrors/cygnus/
  release/python>`_, `Maintainer releases
  <http://www.tishler.net/jason/software/python/>`_)

279
See `Python for Windows <https://www.python.org/downloads/windows/>`_
280
for detailed information about platforms with pre-compiled installers.
281 282 283

.. seealso::

284
   `Python on XP <http://dooling.com/index.php/2006/03/14/python-on-xp-7-minutes-to-hello-world/>`_
285 286 287
      "7 Minutes to "Hello World!""
      by Richard Dooling, 2006

288
   `Installing on Windows <http://www.diveintopython.net/installing_python/windows.html>`_
289
      in "`Dive into Python: Python from novice to pro
290
      <http://www.diveintopython.net/>`_"
291 292 293
      by Mark Pilgrim, 2004,
      ISBN 1-59059-356-1

294
   `For Windows users <https://python.swaroopch.com/installation.html#installation-on-windows>`_
295
      in "Installing Python"
296
      in "`A Byte of Python <https://python.swaroopch.com/>`_"
297 298 299 300 301 302 303 304 305 306
      by Swaroop C H, 2003


Alternative bundles
===================

Besides the standard CPython distribution, there are modified packages including
additional functionality.  The following is a list of popular versions and their
key features:

307
`ActivePython <https://www.activestate.com/activepython/>`_
308 309
    Installer with multi-platform compatibility, documentation, PyWin32

310
`Anaconda <https://www.continuum.io/downloads/>`_
311 312 313 314 315 316
    Popular scientific modules (such as numpy, scipy and pandas) and the
    ``conda`` package manager.

`Canopy <https://www.enthought.com/products/canopy/>`_
    A "comprehensive Python analysis environment" with editors and other
    development tools.
317

318 319 320 321 322 323
`WinPython <https://winpython.github.io/>`_
    Windows-specific distribution with prebuilt scientific packages and
    tools for building packages.

Note that these packages may not include the latest versions of Python or
other libraries, and are not maintained or supported by the core Python team.
324

325 326 327 328 329


Configuring Python
==================

330 331 332 333 334
To run Python conveniently from a command prompt, you might consider changing
some default environment variables in Windows.  While the installer provides an
option to configure the PATH and PATHEXT variables for you, this is only
reliable for a single, system-wide installation.  If you regularly use multiple
versions of Python, consider using the :ref:`launcher`.
335 336


337 338
.. _setting-envvars:

339 340 341
Excursus: Setting environment variables
---------------------------------------

342 343 344 345 346
Windows allows environment variables to be configured permanently at both the
User level and the System level, or temporarily in a command prompt.

To temporarily set environment variables, open Command Prompt and use the
:command:`set` command::
347

348
    C:\>set PATH=C:\Program Files\Python 3.6;%PATH%
349 350
    C:\>set PYTHONPATH=%PYTHONPATH%;C:\My_python_lib
    C:\>python
351

352 353
These changes will apply to any further commands executed in that console, and
will be inherited by any applications started from the console.
354

355 356 357 358 359 360 361 362 363
Including the variable name within percent signs will expand to the existing
value, allowing you to add your new value at either the start or the end.
Modifying :envvar:`PATH` by adding the directory containing
:program:`python.exe` to the start is a common way to ensure the correct version
of Python is launched.

To permanently modify the default environment variables, click Start and search
for 'edit environment variables', or open System properties, :guilabel:`Advanced
system settings` and click the :guilabel:`Environment Variables` button.
364 365 366 367
In this dialog, you can add or modify User and System variables. To change
System variables, you need non-restricted access to your machine
(i.e. Administrator rights).

368
.. note::
369

370 371
    Windows will concatenate User variables *after* System variables, which may
    cause unexpected results when modifying :envvar:`PATH`.
372

373 374
    The :envvar:`PYTHONPATH` variable is used by all versions of Python 2 and
    Python 3, so you should not permanently configure this variable unless it
375
    only includes code that is compatible with all of your installed Python
376
    versions.
377 378 379

.. seealso::

380
    https://support.microsoft.com/kb/100843
381 382
      Environment variables in Windows NT

383
    https://technet.microsoft.com/en-us/library/cc754250.aspx
384 385
      The SET command, for temporarily modifying environment variables

386
    https://technet.microsoft.com/en-us/library/cc755104.aspx
387 388
      The SETX command, for permanently modifying environment variables

389
    https://support.microsoft.com/kb/310519
390 391
      How To Manage Environment Variables in Windows XP

392
    https://www.chem.gla.ac.uk/~louis/software/faq/q1.html
393 394
      Setting Environment variables, Louis J. Farrugia

395 396
.. _windows-path-mod:

397 398 399
Finding the Python executable
-----------------------------

400
.. versionchanged:: 3.5
401

402
Besides using the automatically created start menu entry for the Python
403
interpreter, you might want to start Python in the command prompt. The
404
installer has an option to set that up for you.
405

406 407
On the first page of the installer, an option labelled "Add Python to PATH"
may be selected to have the installer add the install location into the
408 409
:envvar:`PATH`.  The location of the :file:`Scripts\\` folder is also added.
This allows you to type :command:`python` to run the interpreter, and
Zachary Ware's avatar
Zachary Ware committed
410
:command:`pip` for the package installer. Thus, you can also execute your
411 412 413
scripts with command line options, see :ref:`using-on-cmdline` documentation.

If you don't enable this option at install time, you can always re-run the
414 415 416 417 418 419
installer, select Modify, and enable it.  Alternatively, you can manually
modify the :envvar:`PATH` using the directions in :ref:`setting-envvars`.  You
need to set your :envvar:`PATH` environment variable to include the directory
of your Python installation, delimited by a semicolon from other entries.  An
example variable could look like this (assuming the first two entries already
existed)::
420

421
    C:\WINDOWS\system32;C:\WINDOWS;C:\Program Files\Python 3.6
422

423 424 425 426 427 428 429
.. _launcher:

Python Launcher for Windows
===========================

.. versionadded:: 3.3

430 431
The Python launcher for Windows is a utility which aids in locating and
executing of different Python versions.  It allows scripts (or the
432 433 434
command-line) to indicate a preference for a specific Python version, and
will locate and execute that version.

435 436 437 438 439
Unlike the :envvar:`PATH` variable, the launcher will correctly select the most
appropriate version of Python. It will prefer per-user installations over
system-wide ones, and orders by language version rather than using the most
recently installed version.

440 441 442 443 444 445
Getting started
---------------

From the command-line
^^^^^^^^^^^^^^^^^^^^^

446 447
.. versionchanged:: 3.6

448 449 450 451
System-wide installations of Python 3.3 and later will put the launcher on your
:envvar:`PATH`. The launcher is compatible with all available versions of
Python, so it does not matter which version is installed. To check that the
launcher is available, execute the following command in Command Prompt:
452 453 454 455 456

::

  py

457
You should find that the latest version of Python you have installed is
458 459 460
started - it can be exited as normal, and any additional command-line
arguments specified will be sent directly to Python.

461 462 463
If you have multiple versions of Python installed (e.g., 2.7 and |version|) you
will have noticed that Python |version| was started - to launch Python 2.7, try
the command:
464 465 466

::

467
  py -2.7
468

469 470
If you want the latest version of Python 2.x you have installed, try the
command:
471 472 473

::

474
  py -2
475

476
You should find the latest version of Python 2.x starts.
477

478 479 480 481 482 483 484 485 486 487
If you see the following error, you do not have the launcher installed:

::

  'py' is not recognized as an internal or external command,
  operable program or batch file.

Per-user installations of Python do not add the launcher to :envvar:`PATH`
unless the option was selected on installation.

488 489 490
Virtual environments
^^^^^^^^^^^^^^^^^^^^

491 492
.. versionadded:: 3.5

493 494 495 496 497 498 499
If the launcher is run with no explicit Python version specification, and a
virtual environment (created with the standard library :mod:`venv` module or
the external ``virtualenv`` tool) active, the launcher will run the virtual
environment's interpreter rather than the global one.  To run the global
interpreter, either deactivate the virtual environment, or explicitly specify
the global Python version.

500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
From a script
^^^^^^^^^^^^^

Let's create a test Python script - create a file called ``hello.py`` with the
following contents

::

    #! python
    import sys
    sys.stdout.write("hello from Python %s\n" % (sys.version,))

From the directory in which hello.py lives, execute the command:

::

   py hello.py

You should notice the version number of your latest Python 2.x installation
is printed.  Now try changing the first line to be:

::

    #! python3

Re-executing the command should now print the latest Python 3.x information.
As with the above command-line examples, you can specify a more explicit
version qualifier.  Assuming you have Python 2.6 installed, try changing the
first line to ``#! python2.6`` and you should find the 2.6 version
information printed.

531 532 533 534 535
Note that unlike interactive use, a bare "python" will use the latest
version of Python 2.x that you have installed.  This is for backward
compatibility and for compatibility with Unix, where the command ``python``
typically refers to Python 2.

536 537 538 539
From file associations
^^^^^^^^^^^^^^^^^^^^^^

The launcher should have been associated with Python files (i.e. ``.py``,
540
``.pyw``, ``.pyc`` files) when it was installed.  This means that
541 542 543 544 545 546 547 548 549 550 551 552
when you double-click on one of these files from Windows explorer the launcher
will be used, and therefore you can use the same facilities described above to
have the script specify the version which should be used.

The key benefit of this is that a single launcher can support multiple Python
versions at the same time depending on the contents of the first line.

Shebang Lines
-------------

If the first line of a script file starts with ``#!``, it is known as a
"shebang" line.  Linux and other Unix like operating systems have native
553 554 555
support for such lines and they are commonly used on such systems to indicate
how a script should be executed.  This launcher allows the same facilities to
be used with Python scripts on Windows and the examples above demonstrate their
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
use.

To allow shebang lines in Python scripts to be portable between Unix and
Windows, this launcher supports a number of 'virtual' commands to specify
which interpreter to use.  The supported virtual commands are:

* ``/usr/bin/env python``
* ``/usr/bin/python``
* ``/usr/local/bin/python``
* ``python``

For example, if the first line of your script starts with

::

  #! /usr/bin/python

The default Python will be located and used.  As many Python scripts written
to work on Unix will already have this line, you should find these scripts can
be used by the launcher without modification.  If you are writing a new script
on Windows which you hope will be useful on Unix, you should use one of the
shebang lines starting with ``/usr``.

579 580 581 582 583 584 585 586 587 588
Any of the above virtual commands can be suffixed with an explicit version
(either just the major version, or the major and minor version) - for example
``/usr/bin/python2.7`` - which will cause that specific version to be located
and used.

The ``/usr/bin/env`` form of shebang line has one further special property.
Before looking for installed Python interpreters, this form will search the
executable :envvar:`PATH` for a Python executable. This corresponds to the
behaviour of the Unix ``env`` program, which performs a :envvar:`PATH` search.

589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
Arguments in shebang lines
--------------------------

The shebang lines can also specify additional options to be passed to the
Python interpreter.  For example, if you have a shebang line:

::

  #! /usr/bin/python -v

Then Python will be started with the ``-v`` option

Customization
-------------

Customization via INI files
^^^^^^^^^^^^^^^^^^^^^^^^^^^

607 608 609 610 611 612
Two .ini files will be searched by the launcher - ``py.ini`` in the current
user's "application data" directory (i.e. the directory returned by calling the
Windows function SHGetFolderPath with CSIDL_LOCAL_APPDATA) and ``py.ini`` in the
same directory as the launcher. The same .ini files are used for both the
'console' version of the launcher (i.e. py.exe) and for the 'windows' version
(i.e. pyw.exe)
613

614 615 616
Customization specified in the "application directory" will have precedence over
the one next to the executable, so a user, who may not have write access to the
.ini file next to the launcher, can override commands in that global .ini file)
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677

Customizing default Python versions
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

In some cases, a version qualifier can be included in a command to dictate
which version of Python will be used by the command. A version qualifier
starts with a major version number and can optionally be followed by a period
('.') and a minor version specifier. If the minor qualifier is specified, it
may optionally be followed by "-32" to indicate the 32-bit implementation of
that version be used.

For example, a shebang line of ``#!python`` has no version qualifier, while
``#!python3`` has a version qualifier which specifies only a major version.

If no version qualifiers are found in a command, the environment variable
``PY_PYTHON`` can be set to specify the default version qualifier - the default
value is "2". Note this value could specify just a major version (e.g. "2") or
a major.minor qualifier (e.g. "2.6"), or even major.minor-32.

If no minor version qualifiers are found, the environment variable
``PY_PYTHON{major}`` (where ``{major}`` is the current major version qualifier
as determined above) can be set to specify the full version. If no such option
is found, the launcher will enumerate the installed Python versions and use
the latest minor release found for the major version, which is likely,
although not guaranteed, to be the most recently installed version in that
family.

On 64-bit Windows with both 32-bit and 64-bit implementations of the same
(major.minor) Python version installed, the 64-bit version will always be
preferred. This will be true for both 32-bit and 64-bit implementations of the
launcher - a 32-bit launcher will prefer to execute a 64-bit Python installation
of the specified version if available. This is so the behavior of the launcher
can be predicted knowing only what versions are installed on the PC and
without regard to the order in which they were installed (i.e., without knowing
whether a 32 or 64-bit version of Python and corresponding launcher was
installed last). As noted above, an optional "-32" suffix can be used on a
version specifier to change this behaviour.

Examples:

* If no relevant options are set, the commands ``python`` and
  ``python2`` will use the latest Python 2.x version installed and
  the command ``python3`` will use the latest Python 3.x installed.

* The commands ``python3.1`` and ``python2.7`` will not consult any
  options at all as the versions are fully specified.

* If ``PY_PYTHON=3``, the commands ``python`` and ``python3`` will both use
  the latest installed Python 3 version.

* If ``PY_PYTHON=3.1-32``, the command ``python`` will use the 32-bit
  implementation of 3.1 whereas the command ``python3`` will use the latest
  installed Python (PY_PYTHON was not considered at all as a major
  version was specified.)

* If ``PY_PYTHON=3`` and ``PY_PYTHON3=3.1``, the commands
  ``python`` and ``python3`` will both use specifically 3.1

In addition to environment variables, the same settings can be configured
in the .INI file used by the launcher.  The section in the INI file is
called ``[defaults]`` and the key name will be the same as the
678
environment variables without the leading ``PY_`` prefix (and note that
679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
the key names in the INI file are case insensitive.)  The contents of
an environment variable will override things specified in the INI file.

For example:

* Setting ``PY_PYTHON=3.1`` is equivalent to the INI file containing:

::

  [defaults]
  python=3.1

* Setting ``PY_PYTHON=3`` and ``PY_PYTHON3=3.1`` is equivalent to the INI file
  containing:

::

  [defaults]
  python=3
  python3=3.1

Diagnostics
-----------

If an environment variable ``PYLAUNCH_DEBUG`` is set (to any value), the
launcher will print diagnostic information to stderr (i.e. to the console).
While this information manages to be simultaneously verbose *and* terse, it
should allow you to see what versions of Python were located, why a
particular version was chosen and the exact command-line used to execute the
target Python.


711

712
.. _finding_modules:
713

714 715 716 717 718 719 720 721 722
Finding modules
===============

Python usually stores its library (and thereby your site-packages folder) in the
installation directory.  So, if you had installed Python to
:file:`C:\\Python\\`, the default library would reside in
:file:`C:\\Python\\Lib\\` and third-party modules should be stored in
:file:`C:\\Python\\Lib\\site-packages\\`.

723 724 725 726 727
To completely override :data:`sys.path`, create a ``._pth`` file with the same
name as the DLL (``python36._pth``) or the executable (``python._pth``) and
specify one line for each path to add to :data:`sys.path`. The file based on the
DLL name overrides the one based on the executable, which allows paths to be
restricted for any program loading the runtime if desired.
728

729 730 731 732 733 734 735 736 737 738 739 740
When the file exists, all registry and environment variables are ignored,
isolated mode is enabled, and :mod:`site` is not imported unless one line in the
file specifies ``import site``. Blank paths and lines starting with ``#`` are
ignored. Each path may be absolute or relative to the location of the file.
Import statements other than to ``site`` are not permitted, and arbitrary code
cannot be specified.

Note that ``.pth`` files (without leading underscore) will be processed normally
by the :mod:`site` module.

When no ``._pth`` file is found, this is how :data:`sys.path` is populated on
Windows:
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758

* An empty entry is added at the start, which corresponds to the current
  directory.

* If the environment variable :envvar:`PYTHONPATH` exists, as described in
  :ref:`using-on-envvars`, its entries are added next.  Note that on Windows,
  paths in this variable must be separated by semicolons, to distinguish them
  from the colon used in drive identifiers (``C:\`` etc.).

* Additional "application paths" can be added in the registry as subkeys of
  :samp:`\\SOFTWARE\\Python\\PythonCore\\{version}\\PythonPath` under both the
  ``HKEY_CURRENT_USER`` and ``HKEY_LOCAL_MACHINE`` hives.  Subkeys which have
  semicolon-delimited path strings as their default value will cause each path
  to be added to :data:`sys.path`.  (Note that all known installers only use
  HKLM, so HKCU is typically empty.)

* If the environment variable :envvar:`PYTHONHOME` is set, it is assumed as
  "Python Home".  Otherwise, the path of the main Python executable is used to
759 760 761 762 763
  locate a "landmark file" (either ``Lib\os.py`` or ``pythonXY.zip``) to deduce
  the "Python Home".  If a Python home is found, the relevant sub-directories
  added to :data:`sys.path` (``Lib``, ``plat-win``, etc) are based on that
  folder.  Otherwise, the core Python path is constructed from the PythonPath
  stored in the registry.
764 765 766 767 768

* If the Python Home cannot be located, no :envvar:`PYTHONPATH` is specified in
  the environment, and no registry entries can be found, a default path with
  relative entries is used (e.g. ``.\Lib;.\plat-win``, etc).

769 770 771 772 773 774 775
If a ``pyvenv.cfg`` file is found alongside the main executable or in the
directory one level above the executable, the following variations apply:

* If ``home`` is an absolute path and :envvar:`PYTHONHOME` is not set, this
  path is used instead of the path to the main executable when deducing the
  home location.

776 777 778 779 780 781 782 783 784 785 786
The end result of all this is:

* When running :file:`python.exe`, or any other .exe in the main Python
  directory (either an installed version, or directly from the PCbuild
  directory), the core path is deduced, and the core paths in the registry are
  ignored.  Other "application paths" in the registry are always read.

* When Python is hosted in another .exe (different directory, embedded via COM,
  etc), the "Python Home" will not be deduced, so the core path from the
  registry is used.  Other "application paths" in the registry are always read.

787 788
* If Python can't find its home and there are no registry value (frozen .exe,
  some very strange installation setup) you get a path with some default, but
789 790 791 792 793
  relative, paths.

For those who want to bundle Python into their application or distribution, the
following advice will prevent conflicts with other installations:

794 795 796 797
* Include a ``._pth`` file alongside your executable containing the
  directories to include. This will ignore paths listed in the registry and
  environment variables, and also ignore :mod:`site` unless ``import site`` is
  listed.
798

799
* If you are loading :file:`python3.dll` or :file:`python36.dll` in your own
800 801 802 803 804 805 806 807
  executable, explicitly call :c:func:`Py_SetPath` or (at least)
  :c:func:`Py_SetProgramName` before :c:func:`Py_Initialize`.

* Clear and/or overwrite :envvar:`PYTHONPATH` and set :envvar:`PYTHONHOME`
  before launching :file:`python.exe` from your application.

* If you cannot use the previous suggestions (for example, you are a
  distribution that allows people to run :file:`python.exe` directly), ensure
808
  that the landmark file (:file:`Lib\\os.py`) exists in your install directory.
809 810
  (Note that it will not be detected inside a ZIP file, but a correctly named
  ZIP file will be detected instead.)
811 812 813

These will ensure that the files in a system-wide installation will not take
precedence over the copy of the standard library bundled with your application.
814 815 816
Otherwise, your users may experience problems using your application. Note that
the first suggestion is the best, as the other may still be susceptible to
non-standard paths in the registry and user site-packages.
817

818 819
.. versionchanged::
   3.6
820

821 822 823 824
      * Adds ``._pth`` file support and removes ``applocal`` option from
        ``pyvenv.cfg``.
      * Adds ``pythonXX.zip`` as a potential landmark when directly adjacent
        to the executable.
825

826 827 828 829 830 831 832 833
.. deprecated::
   3.6

      Modules specified in the registry under ``Modules`` (not ``PythonPath``)
      may be imported by :class:`importlib.machinery.WindowsRegistryFinder`.
      This finder is enabled on Windows in 3.6.0 and earlier, but may need to
      be explicitly added to :attr:`sys.meta_path` in the future.

834 835 836 837 838 839 840 841 842 843 844 845 846
Additional modules
==================

Even though Python aims to be portable among all platforms, there are features
that are unique to Windows.  A couple of modules, both in the standard library
and external, and snippets exist to use these features.

The Windows-specific standard modules are documented in
:ref:`mswin-specific-services`.

PyWin32
-------

847
The `PyWin32 <https://pypi.python.org/pypi/pywin32>`_ module by Mark Hammond
848
is a collection of modules for advanced Windows-specific support.  This includes
Georg Brandl's avatar
Georg Brandl committed
849
utilities for:
850

851
* `Component Object Model <https://www.microsoft.com/com/>`_ (COM)
852 853 854
* Win32 API calls
* Registry
* Event log
855
* `Microsoft Foundation Classes <https://msdn.microsoft.com/en-us/library/fe1cf721%28VS.80%29.aspx>`_ (MFC)
856 857
  user interfaces

858
`PythonWin <https://web.archive.org/web/20060524042422/
859
https://www.python.org/windows/pythonwin/>`_ is a sample MFC application
860 861 862 863 864 865 866 867 868 869 870
shipped with PyWin32.  It is an embeddable IDE with a built-in debugger.

.. seealso::

   `Win32 How Do I...? <http://timgolden.me.uk/python/win32_how_do_i.html>`_
      by Tim Golden

   `Python and COM <http://www.boddie.org.uk/python/COM.html>`_
      by David and Paul Boddie


871 872
cx_Freeze
---------
873

874
`cx_Freeze <https://anthony-tuininga.github.io/cx_Freeze/>`_ is a :mod:`distutils`
875 876 877 878
extension (see :ref:`extending-distutils`) which wraps Python scripts into
executable Windows programs (:file:`{*}.exe` files).  When you have done this,
you can distribute your application without requiring your users to install
Python.
879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896


WConio
------

Since Python's advanced terminal handling layer, :mod:`curses`, is restricted to
Unix-like systems, there is a library exclusive to Windows as well: Windows
Console I/O for Python.

`WConio <http://newcenturycomputers.net/projects/wconio.html>`_ is a wrapper for
Turbo-C's :file:`CONIO.H`, used to create text user interfaces.



Compiling Python on Windows
===========================

If you want to compile CPython yourself, first thing you should do is get the
897
`source <https://www.python.org/downloads/source/>`_. You can download either the
898
latest release's source or just grab a fresh `checkout
899
<https://devguide.python.org/setup/#getting-the-source-code>`_.
900

901
The source tree contains a build solution and project files for Microsoft
902 903
Visual Studio 2015, which is the compiler used to build the official Python
releases. These files are in the :file:`PCbuild` directory.
904

905
Check :file:`PCbuild/readme.txt` for general information on the build process.
906 907 908 909 910 911 912 913 914 915 916


For extension modules, consult :ref:`building-on-windows`.

.. seealso::

   `Python + Windows + distutils + SWIG + gcc MinGW <http://sebsauvage.net/python/mingw.html>`_
      or "Creating Python extensions in C/C++ with SWIG and compiling them with
      MinGW gcc under Windows" or "Installing Python extension with distutils
      and without Microsoft Visual C++" by Sébastien Sauvage, 2003

Georg Brandl's avatar
Georg Brandl committed
917
   `MingW -- Python extensions <http://oldwiki.mingw.org/index.php/Python%20extensions>`_
918 919 920
      by Trent Apted et al, 2007


921 922 923 924 925 926 927 928 929 930 931 932
Embedded Distribution
=====================

.. versionadded:: 3.5

The embedded distribution is a ZIP file containing a minimal Python environment.
It is intended for acting as part of another application, rather than being
directly accessed by end-users.

When extracted, the embedded distribution is (almost) fully isolated from the
user's system, including environment variables, system registry settings, and
installed packages. The standard library is included as pre-compiled and
933
optimized ``.pyc`` files in a ZIP, and ``python3.dll``, ``python36.dll``,
934 935 936 937 938 939
``python.exe`` and ``pythonw.exe`` are all provided. Tcl/tk (including all
dependants, such as Idle), pip and the Python documentation are not included.

.. note::

    The embedded distribution does not include the `Microsoft C Runtime
940
    <https://www.microsoft.com/en-us/download/details.aspx?id=48145>`_ and it is
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
    the responsibility of the application installer to provide this. The
    runtime may have already been installed on a user's system previously or
    automatically via Windows Update, and can be detected by finding
    ``ucrtbase.dll`` in the system directory.

Third-party packages should be installed by the application installer alongside
the embedded distribution. Using pip to manage dependencies as for a regular
Python installation is not supported with this distribution, though with some
care it may be possible to include and use pip for automatic updates. In
general, third-party packages should be treated as part of the application
("vendoring") so that the developer can ensure compatibility with newer
versions before providing updates to users.

The two recommended use cases for this distribution are described below.

Python Application
------------------

An application written in Python does not necessarily require users to be aware
of that fact. The embedded distribution may be used in this case to include a
private version of Python in an install package. Depending on how transparent it
should be (or conversely, how professional it should appear), there are two
options.

Using a specialized executable as a launcher requires some coding, but provides
the most transparent experience for users. With a customized launcher, there are
no obvious indications that the program is running on Python: icons can be
customized, company and version information can be specified, and file
associations behave properly. In most cases, a custom launcher should simply be
able to call ``Py_Main`` with a hard-coded command line.

The simpler approach is to provide a batch file or generated shortcut that
directly calls the ``python.exe`` or ``pythonw.exe`` with the required
command-line arguments. In this case, the application will appear to be Python
and not its actual name, and users may have trouble distinguishing it from other
running Python processes or file associations.

With the latter approach, packages should be installed as directories alongside
the Python executable to ensure they are available on the path. With the
specialized launcher, packages can be located in other locations as there is an
opportunity to specify the search path before launching the application.

Embedding Python
----------------

Applications written in native code often require some form of scripting
language, and the embedded Python distribution can be used for this purpose. In
general, the majority of the application is in native code, and some part will
either invoke ``python.exe`` or directly use ``python3.dll``. For either case,
extracting the embedded distribution to a subdirectory of the application
installation is sufficient to provide a loadable Python interpreter.

As with the application use, packages can be installed to any location as there
is an opportunity to specify search paths before initializing the interpreter.
Otherwise, there is no fundamental differences between using the embedded
distribution and a regular installation.

998 999 1000 1001 1002
Other resources
===============

.. seealso::

1003
   `Python Programming On Win32 <http://shop.oreilly.com/product/9781565926219.do>`_
1004 1005 1006 1007 1008 1009 1010
      "Help for Windows Programmers"
      by Mark Hammond and Andy Robinson, O'Reilly Media, 2000,
      ISBN 1-56592-621-8

   `A Python for Windows Tutorial <http://www.imladris.com/Scripts/PythonForWindows.html>`_
      by Amanda Birmingham, 2004

1011 1012
   :pep:`397` - Python launcher for Windows
      The proposal for the launcher to be included in the Python distribution.