1 .. highlightlang:: sh 2 3 .. ATTENTION: You probably should update Misc/python.man, too, if you modify 4 this file. 5 6 .. _using-on-general: 7 8 Command line and environment 9 ============================ 10 11 The CPython interpreter scans the command line and the environment for various 12 settings. 13 14 .. impl-detail:: 15 16 Other implementations' command line schemes may differ. See 17 :ref:`implementations` for further resources. 18 19 20 .. _using-on-cmdline: 21 22 Command line 23 ------------ 24 25 When invoking Python, you may specify any of these options:: 26 27 python [-bBdEhiIOqsSuvVWx?] [-c command | -m module-name | script | - ] [args] 28 29 The most common use case is, of course, a simple invocation of a script:: 30 31 python myscript.py 32 33 34 .. _using-on-interface-options: 35 36 Interface options 37 ~~~~~~~~~~~~~~~~~ 38 39 The interpreter interface resembles that of the UNIX shell, but provides some 40 additional methods of invocation: 41 42 * When called with standard input connected to a tty device, it prompts for 43 commands and executes them until an EOF (an end-of-file character, you can 44 produce that with :kbd:`Ctrl-D` on UNIX or :kbd:`Ctrl-Z, Enter` on Windows) is read. 45 * When called with a file name argument or with a file as standard input, it 46 reads and executes a script from that file. 47 * When called with a directory name argument, it reads and executes an 48 appropriately named script from that directory. 49 * When called with ``-c command``, it executes the Python statement(s) given as 50 *command*. Here *command* may contain multiple statements separated by 51 newlines. Leading whitespace is significant in Python statements! 52 * When called with ``-m module-name``, the given module is located on the 53 Python module path and executed as a script. 54 55 In non-interactive mode, the entire input is parsed before it is executed. 56 57 An interface option terminates the list of options consumed by the interpreter, 58 all consecutive arguments will end up in :data:`sys.argv` -- note that the first 59 element, subscript zero (``sys.argv[0]``), is a string reflecting the program's 60 source. 61 62 .. cmdoption:: -c <command> 63 64 Execute the Python code in *command*. *command* can be one or more 65 statements separated by newlines, with significant leading whitespace as in 66 normal module code. 67 68 If this option is given, the first element of :data:`sys.argv` will be 69 ``"-c"`` and the current directory will be added to the start of 70 :data:`sys.path` (allowing modules in that directory to be imported as top 71 level modules). 72 73 74 .. cmdoption:: -m <module-name> 75 76 Search :data:`sys.path` for the named module and execute its contents as 77 the :mod:`__main__` module. 78 79 Since the argument is a *module* name, you must not give a file extension 80 (``.py``). The module name should be a valid absolute Python module name, but 81 the implementation may not always enforce this (e.g. it may allow you to 82 use a name that includes a hyphen). 83 84 Package names (including namespace packages) are also permitted. When a 85 package name is supplied instead 86 of a normal module, the interpreter will execute ``<pkg>.__main__`` as 87 the main module. This behaviour is deliberately similar to the handling 88 of directories and zipfiles that are passed to the interpreter as the 89 script argument. 90 91 .. note:: 92 93 This option cannot be used with built-in modules and extension modules 94 written in C, since they do not have Python module files. However, it 95 can still be used for precompiled modules, even if the original source 96 file is not available. 97 98 If this option is given, the first element of :data:`sys.argv` will be the 99 full path to the module file (while the module file is being located, the 100 first element will be set to ``"-m"``). As with the :option:`-c` option, 101 the current directory will be added to the start of :data:`sys.path`. 102 103 Many standard library modules contain code that is invoked on their execution 104 as a script. An example is the :mod:`timeit` module:: 105 106 python -mtimeit -s 'setup here' 'benchmarked code here' 107 python -mtimeit -h # for details 108 109 .. seealso:: 110 :func:`runpy.run_module` 111 Equivalent functionality directly available to Python code 112 113 :pep:`338` -- Executing modules as scripts 114 115 116 .. versionchanged:: 3.1 117 Supply the package name to run a ``__main__`` submodule. 118 119 .. versionchanged:: 3.4 120 namespace packages are also supported 121 122 123 .. describe:: - 124 125 Read commands from standard input (:data:`sys.stdin`). If standard input is 126 a terminal, :option:`-i` is implied. 127 128 If this option is given, the first element of :data:`sys.argv` will be 129 ``"-"`` and the current directory will be added to the start of 130 :data:`sys.path`. 131 132 133 .. describe:: <script> 134 135 Execute the Python code contained in *script*, which must be a filesystem 136 path (absolute or relative) referring to either a Python file, a directory 137 containing a ``__main__.py`` file, or a zipfile containing a 138 ``__main__.py`` file. 139 140 If this option is given, the first element of :data:`sys.argv` will be the 141 script name as given on the command line. 142 143 If the script name refers directly to a Python file, the directory 144 containing that file is added to the start of :data:`sys.path`, and the 145 file is executed as the :mod:`__main__` module. 146 147 If the script name refers to a directory or zipfile, the script name is 148 added to the start of :data:`sys.path` and the ``__main__.py`` file in 149 that location is executed as the :mod:`__main__` module. 150 151 .. seealso:: 152 :func:`runpy.run_path` 153 Equivalent functionality directly available to Python code 154 155 156 If no interface option is given, :option:`-i` is implied, ``sys.argv[0]`` is 157 an empty string (``""``) and the current directory will be added to the 158 start of :data:`sys.path`. Also, tab-completion and history editing is 159 automatically enabled, if available on your platform (see 160 :ref:`rlcompleter-config`). 161 162 .. seealso:: :ref:`tut-invoking` 163 164 .. versionchanged:: 3.4 165 Automatic enabling of tab-completion and history editing. 166 167 168 Generic options 169 ~~~~~~~~~~~~~~~ 170 171 .. cmdoption:: -? 172 -h 173 --help 174 175 Print a short description of all command line options. 176 177 178 .. cmdoption:: -V 179 --version 180 181 Print the Python version number and exit. Example output could be:: 182 183 Python 3.6.0b2+ 184 185 When given twice, print more information about the build, like:: 186 187 Python 3.6.0b2+ (3.6:84a3c5003510+, Oct 26 2016, 02:33:55) 188 [GCC 6.2.0 20161005] 189 190 .. versionadded:: 3.6 191 The ``-VV`` option. 192 193 .. _using-on-misc-options: 194 195 Miscellaneous options 196 ~~~~~~~~~~~~~~~~~~~~~ 197 198 .. cmdoption:: -b 199 200 Issue a warning when comparing :class:`bytes` or :class:`bytearray` with 201 :class:`str` or :class:`bytes` with :class:`int`. Issue an error when the 202 option is given twice (:option:`!-bb`). 203 204 .. versionchanged:: 3.5 205 Affects comparisons of :class:`bytes` with :class:`int`. 206 207 .. cmdoption:: -B 208 209 If given, Python won't try to write ``.pyc`` files on the 210 import of source modules. See also :envvar:`PYTHONDONTWRITEBYTECODE`. 211 212 213 .. cmdoption:: -d 214 215 Turn on parser debugging output (for wizards only, depending on compilation 216 options). See also :envvar:`PYTHONDEBUG`. 217 218 219 .. cmdoption:: -E 220 221 Ignore all :envvar:`PYTHON*` environment variables, e.g. 222 :envvar:`PYTHONPATH` and :envvar:`PYTHONHOME`, that might be set. 223 224 225 .. cmdoption:: -i 226 227 When a script is passed as first argument or the :option:`-c` option is used, 228 enter interactive mode after executing the script or the command, even when 229 :data:`sys.stdin` does not appear to be a terminal. The 230 :envvar:`PYTHONSTARTUP` file is not read. 231 232 This can be useful to inspect global variables or a stack trace when a script 233 raises an exception. See also :envvar:`PYTHONINSPECT`. 234 235 236 .. cmdoption:: -I 237 238 Run Python in isolated mode. This also implies -E and -s. 239 In isolated mode :data:`sys.path` contains neither the script's directory nor 240 the user's site-packages directory. All :envvar:`PYTHON*` environment 241 variables are ignored, too. Further restrictions may be imposed to prevent 242 the user from injecting malicious code. 243 244 .. versionadded:: 3.4 245 246 247 .. cmdoption:: -O 248 249 Turn on basic optimizations. See also :envvar:`PYTHONOPTIMIZE`. 250 251 252 .. cmdoption:: -OO 253 254 Discard docstrings in addition to the :option:`-O` optimizations. 255 256 257 .. cmdoption:: -q 258 259 Don't display the copyright and version messages even in interactive mode. 260 261 .. versionadded:: 3.2 262 263 264 .. cmdoption:: -R 265 266 Kept for compatibility. On Python 3.3 and greater, hash randomization is 267 turned on by default. 268 269 On previous versions of Python, this option turns on hash randomization, 270 so that the :meth:`__hash__` values of str, bytes and datetime 271 are "salted" with an unpredictable random value. Although they remain 272 constant within an individual Python process, they are not predictable 273 between repeated invocations of Python. 274 275 Hash randomization is intended to provide protection against a 276 denial-of-service caused by carefully-chosen inputs that exploit the worst 277 case performance of a dict construction, O(n^2) complexity. See 278 http://www.ocert.org/advisories/ocert-2011-003.html for details. 279 280 :envvar:`PYTHONHASHSEED` allows you to set a fixed value for the hash 281 seed secret. 282 283 .. versionadded:: 3.2.3 284 285 286 .. cmdoption:: -s 287 288 Don't add the :data:`user site-packages directory <site.USER_SITE>` to 289 :data:`sys.path`. 290 291 .. seealso:: 292 293 :pep:`370` -- Per user site-packages directory 294 295 296 .. cmdoption:: -S 297 298 Disable the import of the module :mod:`site` and the site-dependent 299 manipulations of :data:`sys.path` that it entails. Also disable these 300 manipulations if :mod:`site` is explicitly imported later (call 301 :func:`site.main` if you want them to be triggered). 302 303 304 .. cmdoption:: -u 305 306 Force the binary layer of the stdout and stderr streams (which is 307 available as their ``buffer`` attribute) to be unbuffered. The text I/O 308 layer will still be line-buffered if writing to the console, or 309 block-buffered if redirected to a non-interactive file. 310 311 See also :envvar:`PYTHONUNBUFFERED`. 312 313 314 .. cmdoption:: -v 315 316 Print a message each time a module is initialized, showing the place 317 (filename or built-in module) from which it is loaded. When given twice 318 (:option:`!-vv`), print a message for each file that is checked for when 319 searching for a module. Also provides information on module cleanup at exit. 320 See also :envvar:`PYTHONVERBOSE`. 321 322 323 .. _using-on-warnings: 324 .. cmdoption:: -W arg 325 326 Warning control. Python's warning machinery by default prints warning 327 messages to :data:`sys.stderr`. A typical warning message has the following 328 form:: 329 330 file:line: category: message 331 332 By default, each warning is printed once for each source line where it 333 occurs. This option controls how often warnings are printed. 334 335 Multiple :option:`-W` options may be given; when a warning matches more than 336 one option, the action for the last matching option is performed. Invalid 337 :option:`-W` options are ignored (though, a warning message is printed about 338 invalid options when the first warning is issued). 339 340 Warnings can also be controlled from within a Python program using the 341 :mod:`warnings` module. 342 343 The simplest form of argument is one of the following action strings (or a 344 unique abbreviation): 345 346 ``ignore`` 347 Ignore all warnings. 348 ``default`` 349 Explicitly request the default behavior (printing each warning once per 350 source line). 351 ``all`` 352 Print a warning each time it occurs (this may generate many messages if a 353 warning is triggered repeatedly for the same source line, such as inside a 354 loop). 355 ``module`` 356 Print each warning only the first time it occurs in each module. 357 ``once`` 358 Print each warning only the first time it occurs in the program. 359 ``error`` 360 Raise an exception instead of printing a warning message. 361 362 The full form of argument is:: 363 364 action:message:category:module:line 365 366 Here, *action* is as explained above but only applies to messages that match 367 the remaining fields. Empty fields match all values; trailing empty fields 368 may be omitted. The *message* field matches the start of the warning message 369 printed; this match is case-insensitive. The *category* field matches the 370 warning category. This must be a class name; the match tests whether the 371 actual warning category of the message is a subclass of the specified warning 372 category. The full class name must be given. The *module* field matches the 373 (fully-qualified) module name; this match is case-sensitive. The *line* 374 field matches the line number, where zero matches all line numbers and is 375 thus equivalent to an omitted line number. 376 377 .. seealso:: 378 :mod:`warnings` -- the warnings module 379 380 :pep:`230` -- Warning framework 381 382 :envvar:`PYTHONWARNINGS` 383 384 385 .. cmdoption:: -x 386 387 Skip the first line of the source, allowing use of non-Unix forms of 388 ``#!cmd``. This is intended for a DOS specific hack only. 389 390 .. note:: The line numbers in error messages will be off by one. 391 392 393 .. cmdoption:: -X 394 395 Reserved for various implementation-specific options. CPython currently 396 defines the following possible values: 397 398 * ``-X faulthandler`` to enable :mod:`faulthandler`; 399 * ``-X showrefcount`` to output the total reference count and number of used 400 memory blocks when the program finishes or after each statement in the 401 interactive interpreter. This only works on debug builds. 402 * ``-X tracemalloc`` to start tracing Python memory allocations using the 403 :mod:`tracemalloc` module. By default, only the most recent frame is 404 stored in a traceback of a trace. Use ``-X tracemalloc=NFRAME`` to start 405 tracing with a traceback limit of *NFRAME* frames. See the 406 :func:`tracemalloc.start` for more information. 407 * ``-X showalloccount`` to output the total count of allocated objects for 408 each type when the program finishes. This only works when Python was built with 409 ``COUNT_ALLOCS`` defined. 410 411 It also allows passing arbitrary values and retrieving them through the 412 :data:`sys._xoptions` dictionary. 413 414 .. versionchanged:: 3.2 415 The :option:`-X` option was added. 416 417 .. versionadded:: 3.3 418 The ``-X faulthandler`` option. 419 420 .. versionadded:: 3.4 421 The ``-X showrefcount`` and ``-X tracemalloc`` options. 422 423 .. versionadded:: 3.6 424 The ``-X showalloccount`` option. 425 426 427 Options you shouldn't use 428 ~~~~~~~~~~~~~~~~~~~~~~~~~ 429 430 .. cmdoption:: -J 431 432 Reserved for use by Jython_. 433 434 .. _Jython: http://www.jython.org/ 435 436 437 .. _using-on-envvars: 438 439 Environment variables 440 --------------------- 441 442 These environment variables influence Python's behavior, they are processed 443 before the command-line switches other than -E or -I. It is customary that 444 command-line switches override environmental variables where there is a 445 conflict. 446 447 .. envvar:: PYTHONHOME 448 449 Change the location of the standard Python libraries. By default, the 450 libraries are searched in :file:`{prefix}/lib/python{version}` and 451 :file:`{exec_prefix}/lib/python{version}`, where :file:`{prefix}` and 452 :file:`{exec_prefix}` are installation-dependent directories, both defaulting 453 to :file:`/usr/local`. 454 455 When :envvar:`PYTHONHOME` is set to a single directory, its value replaces 456 both :file:`{prefix}` and :file:`{exec_prefix}`. To specify different values 457 for these, set :envvar:`PYTHONHOME` to :file:`{prefix}:{exec_prefix}`. 458 459 460 .. envvar:: PYTHONPATH 461 462 Augment the default search path for module files. The format is the same as 463 the shell's :envvar:`PATH`: one or more directory pathnames separated by 464 :data:`os.pathsep` (e.g. colons on Unix or semicolons on Windows). 465 Non-existent directories are silently ignored. 466 467 In addition to normal directories, individual :envvar:`PYTHONPATH` entries 468 may refer to zipfiles containing pure Python modules (in either source or 469 compiled form). Extension modules cannot be imported from zipfiles. 470 471 The default search path is installation dependent, but generally begins with 472 :file:`{prefix}/lib/python{version}` (see :envvar:`PYTHONHOME` above). It 473 is *always* appended to :envvar:`PYTHONPATH`. 474 475 An additional directory will be inserted in the search path in front of 476 :envvar:`PYTHONPATH` as described above under 477 :ref:`using-on-interface-options`. The search path can be manipulated from 478 within a Python program as the variable :data:`sys.path`. 479 480 481 .. envvar:: PYTHONSTARTUP 482 483 If this is the name of a readable file, the Python commands in that file are 484 executed before the first prompt is displayed in interactive mode. The file 485 is executed in the same namespace where interactive commands are executed so 486 that objects defined or imported in it can be used without qualification in 487 the interactive session. You can also change the prompts :data:`sys.ps1` and 488 :data:`sys.ps2` and the hook :data:`sys.__interactivehook__` in this file. 489 490 491 .. envvar:: PYTHONOPTIMIZE 492 493 If this is set to a non-empty string it is equivalent to specifying the 494 :option:`-O` option. If set to an integer, it is equivalent to specifying 495 :option:`-O` multiple times. 496 497 498 .. envvar:: PYTHONDEBUG 499 500 If this is set to a non-empty string it is equivalent to specifying the 501 :option:`-d` option. If set to an integer, it is equivalent to specifying 502 :option:`-d` multiple times. 503 504 505 .. envvar:: PYTHONINSPECT 506 507 If this is set to a non-empty string it is equivalent to specifying the 508 :option:`-i` option. 509 510 This variable can also be modified by Python code using :data:`os.environ` 511 to force inspect mode on program termination. 512 513 514 .. envvar:: PYTHONUNBUFFERED 515 516 If this is set to a non-empty string it is equivalent to specifying the 517 :option:`-u` option. 518 519 520 .. envvar:: PYTHONVERBOSE 521 522 If this is set to a non-empty string it is equivalent to specifying the 523 :option:`-v` option. If set to an integer, it is equivalent to specifying 524 :option:`-v` multiple times. 525 526 527 .. envvar:: PYTHONCASEOK 528 529 If this is set, Python ignores case in :keyword:`import` statements. This 530 only works on Windows and OS X. 531 532 533 .. envvar:: PYTHONDONTWRITEBYTECODE 534 535 If this is set to a non-empty string, Python won't try to write ``.pyc`` or 536 ``.pyo`` files on the import of source modules. This is equivalent to 537 specifying the :option:`-B` option. 538 539 540 .. envvar:: PYTHONHASHSEED 541 542 If this variable is not set or set to ``random``, a random value is used 543 to seed the hashes of str, bytes and datetime objects. 544 545 If :envvar:`PYTHONHASHSEED` is set to an integer value, it is used as a fixed 546 seed for generating the hash() of the types covered by the hash 547 randomization. 548 549 Its purpose is to allow repeatable hashing, such as for selftests for the 550 interpreter itself, or to allow a cluster of python processes to share hash 551 values. 552 553 The integer must be a decimal number in the range [0,4294967295]. Specifying 554 the value 0 will disable hash randomization. 555 556 .. versionadded:: 3.2.3 557 558 559 .. envvar:: PYTHONIOENCODING 560 561 If this is set before running the interpreter, it overrides the encoding used 562 for stdin/stdout/stderr, in the syntax ``encodingname:errorhandler``. Both 563 the ``encodingname`` and the ``:errorhandler`` parts are optional and have 564 the same meaning as in :func:`str.encode`. 565 566 For stderr, the ``:errorhandler`` part is ignored; the handler will always be 567 ``'backslashreplace'``. 568 569 .. versionchanged:: 3.4 570 The ``encodingname`` part is now optional. 571 572 .. versionchanged:: 3.6 573 On Windows, the encoding specified by this variable is ignored for interactive 574 console buffers unless :envvar:`PYTHONLEGACYWINDOWSIOENCODING` is also specified. 575 Files and pipes redirected through the standard streams are not affected. 576 577 .. envvar:: PYTHONNOUSERSITE 578 579 If this is set, Python won't add the :data:`user site-packages directory 580 <site.USER_SITE>` to :data:`sys.path`. 581 582 .. seealso:: 583 584 :pep:`370` -- Per user site-packages directory 585 586 587 .. envvar:: PYTHONUSERBASE 588 589 Defines the :data:`user base directory <site.USER_BASE>`, which is used to 590 compute the path of the :data:`user site-packages directory <site.USER_SITE>` 591 and :ref:`Distutils installation paths <inst-alt-install-user>` for 592 ``python setup.py install --user``. 593 594 .. seealso:: 595 596 :pep:`370` -- Per user site-packages directory 597 598 599 .. envvar:: PYTHONEXECUTABLE 600 601 If this environment variable is set, ``sys.argv[0]`` will be set to its 602 value instead of the value got through the C runtime. Only works on 603 Mac OS X. 604 605 .. envvar:: PYTHONWARNINGS 606 607 This is equivalent to the :option:`-W` option. If set to a comma 608 separated string, it is equivalent to specifying :option:`-W` multiple 609 times. 610 611 .. envvar:: PYTHONFAULTHANDLER 612 613 If this environment variable is set to a non-empty string, 614 :func:`faulthandler.enable` is called at startup: install a handler for 615 :const:`SIGSEGV`, :const:`SIGFPE`, :const:`SIGABRT`, :const:`SIGBUS` and 616 :const:`SIGILL` signals to dump the Python traceback. This is equivalent to 617 :option:`-X` ``faulthandler`` option. 618 619 .. versionadded:: 3.3 620 621 622 .. envvar:: PYTHONTRACEMALLOC 623 624 If this environment variable is set to a non-empty string, start tracing 625 Python memory allocations using the :mod:`tracemalloc` module. The value of 626 the variable is the maximum number of frames stored in a traceback of a 627 trace. For example, ``PYTHONTRACEMALLOC=1`` stores only the most recent 628 frame. See the :func:`tracemalloc.start` for more information. 629 630 .. versionadded:: 3.4 631 632 633 .. envvar:: PYTHONASYNCIODEBUG 634 635 If this environment variable is set to a non-empty string, enable the 636 :ref:`debug mode <asyncio-debug-mode>` of the :mod:`asyncio` module. 637 638 .. versionadded:: 3.4 639 640 641 .. envvar:: PYTHONMALLOC 642 643 Set the Python memory allocators and/or install debug hooks. 644 645 Set the family of memory allocators used by Python: 646 647 * ``malloc``: use the :c:func:`malloc` function of the C library 648 for all domains (:c:data:`PYMEM_DOMAIN_RAW`, :c:data:`PYMEM_DOMAIN_MEM`, 649 :c:data:`PYMEM_DOMAIN_OBJ`). 650 * ``pymalloc``: use the :ref:`pymalloc allocator <pymalloc>` for 651 :c:data:`PYMEM_DOMAIN_MEM` and :c:data:`PYMEM_DOMAIN_OBJ` domains and use 652 the :c:func:`malloc` function for the :c:data:`PYMEM_DOMAIN_RAW` domain. 653 654 Install debug hooks: 655 656 * ``debug``: install debug hooks on top of the default memory allocator 657 * ``malloc_debug``: same as ``malloc`` but also install debug hooks 658 * ``pymalloc_debug``: same as ``pymalloc`` but also install debug hooks 659 660 When Python is compiled in release mode, the default is ``pymalloc``. When 661 compiled in debug mode, the default is ``pymalloc_debug`` and the debug hooks 662 are used automatically. 663 664 If Python is configured without ``pymalloc`` support, ``pymalloc`` and 665 ``pymalloc_debug`` are not available, the default is ``malloc`` in release 666 mode and ``malloc_debug`` in debug mode. 667 668 See the :c:func:`PyMem_SetupDebugHooks` function for debug hooks on Python 669 memory allocators. 670 671 .. versionadded:: 3.6 672 673 674 .. envvar:: PYTHONMALLOCSTATS 675 676 If set to a non-empty string, Python will print statistics of the 677 :ref:`pymalloc memory allocator <pymalloc>` every time a new pymalloc object 678 arena is created, and on shutdown. 679 680 This variable is ignored if the :envvar:`PYTHONMALLOC` environment variable 681 is used to force the :c:func:`malloc` allocator of the C library, or if 682 Python is configured without ``pymalloc`` support. 683 684 .. versionchanged:: 3.6 685 This variable can now also be used on Python compiled in release mode. 686 It now has no effect if set to an empty string. 687 688 689 .. envvar:: PYTHONLEGACYWINDOWSFSENCODING 690 691 If set to a non-empty string, the default filesystem encoding and errors mode 692 will revert to their pre-3.6 values of 'mbcs' and 'replace', respectively. 693 Otherwise, the new defaults 'utf-8' and 'surrogatepass' are used. 694 695 This may also be enabled at runtime with 696 :func:`sys._enablelegacywindowsfsencoding()`. 697 698 Availability: Windows 699 700 .. versionadded:: 3.6 701 See :pep:`529` for more details. 702 703 .. envvar:: PYTHONLEGACYWINDOWSIOENCODING 704 705 If set to a non-empty string, does not use the new console reader and 706 writer. This means that Unicode characters will be encoded according to 707 the active console code page, rather than using utf-8. 708 709 This variable is ignored if the standard streams are redirected (to files 710 or pipes) rather than referring to console buffers. 711 712 Availability: Windows 713 714 .. versionadded:: 3.6 715 716 Debug-mode variables 717 ~~~~~~~~~~~~~~~~~~~~ 718 719 Setting these variables only has an effect in a debug build of Python, that is, 720 if Python was configured with the ``--with-pydebug`` build option. 721 722 .. envvar:: PYTHONTHREADDEBUG 723 724 If set, Python will print threading debug info. 725 726 727 .. envvar:: PYTHONDUMPREFS 728 729 If set, Python will dump objects and reference counts still alive after 730 shutting down the interpreter. 731