• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1:mod:`sys` --- System-specific parameters and functions
2=======================================================
3
4.. module:: sys
5   :synopsis: Access system-specific parameters and functions.
6
7--------------
8
9This module provides access to some variables used or maintained by the
10interpreter and to functions that interact strongly with the interpreter. It is
11always available.
12
13
14.. data:: abiflags
15
16   On POSIX systems where Python was built with the standard ``configure``
17   script, this contains the ABI flags as specified by :pep:`3149`.
18
19   .. versionadded:: 3.2
20
21
22.. data:: argv
23
24   The list of command line arguments passed to a Python script. ``argv[0]`` is the
25   script name (it is operating system dependent whether this is a full pathname or
26   not).  If the command was executed using the :option:`-c` command line option to
27   the interpreter, ``argv[0]`` is set to the string ``'-c'``.  If no script name
28   was passed to the Python interpreter, ``argv[0]`` is the empty string.
29
30   To loop over the standard input, or the list of files given on the
31   command line, see the :mod:`fileinput` module.
32
33
34.. data:: base_exec_prefix
35
36   Set during Python startup, before ``site.py`` is run, to the same value as
37   :data:`exec_prefix`. If not running in a
38   :ref:`virtual environment <venv-def>`, the values will stay the same; if
39   ``site.py`` finds that a virtual environment is in use, the values of
40   :data:`prefix` and :data:`exec_prefix` will be changed to point to the
41   virtual environment, whereas :data:`base_prefix` and
42   :data:`base_exec_prefix` will remain pointing to the base Python
43   installation (the one which the virtual environment was created from).
44
45   .. versionadded:: 3.3
46
47
48.. data:: base_prefix
49
50   Set during Python startup, before ``site.py`` is run, to the same value as
51   :data:`prefix`. If not running in a :ref:`virtual environment <venv-def>`, the values
52   will stay the same; if ``site.py`` finds that a virtual environment is in
53   use, the values of :data:`prefix` and :data:`exec_prefix` will be changed to
54   point to the virtual environment, whereas :data:`base_prefix` and
55   :data:`base_exec_prefix` will remain pointing to the base Python
56   installation (the one which the virtual environment was created from).
57
58   .. versionadded:: 3.3
59
60
61.. data:: byteorder
62
63   An indicator of the native byte order.  This will have the value ``'big'`` on
64   big-endian (most-significant byte first) platforms, and ``'little'`` on
65   little-endian (least-significant byte first) platforms.
66
67
68.. data:: builtin_module_names
69
70   A tuple of strings giving the names of all modules that are compiled into this
71   Python interpreter.  (This information is not available in any other way ---
72   ``modules.keys()`` only lists the imported modules.)
73
74
75.. function:: call_tracing(func, args)
76
77   Call ``func(*args)``, while tracing is enabled.  The tracing state is saved,
78   and restored afterwards.  This is intended to be called from a debugger from
79   a checkpoint, to recursively debug some other code.
80
81
82.. data:: copyright
83
84   A string containing the copyright pertaining to the Python interpreter.
85
86
87.. function:: _clear_type_cache()
88
89   Clear the internal type cache. The type cache is used to speed up attribute
90   and method lookups. Use the function *only* to drop unnecessary references
91   during reference leak debugging.
92
93   This function should be used for internal and specialized purposes only.
94
95
96.. function:: _current_frames()
97
98   Return a dictionary mapping each thread's identifier to the topmost stack frame
99   currently active in that thread at the time the function is called. Note that
100   functions in the :mod:`traceback` module can build the call stack given such a
101   frame.
102
103   This is most useful for debugging deadlock:  this function does not require the
104   deadlocked threads' cooperation, and such threads' call stacks are frozen for as
105   long as they remain deadlocked.  The frame returned for a non-deadlocked thread
106   may bear no relationship to that thread's current activity by the time calling
107   code examines the frame.
108
109   This function should be used for internal and specialized purposes only.
110
111
112.. function:: _debugmallocstats()
113
114   Print low-level information to stderr about the state of CPython's memory
115   allocator.
116
117   If Python is configured --with-pydebug, it also performs some expensive
118   internal consistency checks.
119
120   .. versionadded:: 3.3
121
122   .. impl-detail::
123
124      This function is specific to CPython.  The exact output format is not
125      defined here, and may change.
126
127
128.. data:: dllhandle
129
130   Integer specifying the handle of the Python DLL. Availability: Windows.
131
132
133.. function:: displayhook(value)
134
135   If *value* is not ``None``, this function prints ``repr(value)`` to
136   ``sys.stdout``, and saves *value* in ``builtins._``. If ``repr(value)`` is
137   not encodable to ``sys.stdout.encoding`` with ``sys.stdout.errors`` error
138   handler (which is probably ``'strict'``), encode it to
139   ``sys.stdout.encoding`` with ``'backslashreplace'`` error handler.
140
141   ``sys.displayhook`` is called on the result of evaluating an :term:`expression`
142   entered in an interactive Python session.  The display of these values can be
143   customized by assigning another one-argument function to ``sys.displayhook``.
144
145   Pseudo-code::
146
147       def displayhook(value):
148           if value is None:
149               return
150           # Set '_' to None to avoid recursion
151           builtins._ = None
152           text = repr(value)
153           try:
154               sys.stdout.write(text)
155           except UnicodeEncodeError:
156               bytes = text.encode(sys.stdout.encoding, 'backslashreplace')
157               if hasattr(sys.stdout, 'buffer'):
158                   sys.stdout.buffer.write(bytes)
159               else:
160                   text = bytes.decode(sys.stdout.encoding, 'strict')
161                   sys.stdout.write(text)
162           sys.stdout.write("\n")
163           builtins._ = value
164
165   .. versionchanged:: 3.2
166      Use ``'backslashreplace'`` error handler on :exc:`UnicodeEncodeError`.
167
168
169.. data:: dont_write_bytecode
170
171   If this is true, Python won't try to write ``.pyc`` files on the
172   import of source modules.  This value is initially set to ``True`` or
173   ``False`` depending on the :option:`-B` command line option and the
174   :envvar:`PYTHONDONTWRITEBYTECODE` environment variable, but you can set it
175   yourself to control bytecode file generation.
176
177
178.. function:: excepthook(type, value, traceback)
179
180   This function prints out a given traceback and exception to ``sys.stderr``.
181
182   When an exception is raised and uncaught, the interpreter calls
183   ``sys.excepthook`` with three arguments, the exception class, exception
184   instance, and a traceback object.  In an interactive session this happens just
185   before control is returned to the prompt; in a Python program this happens just
186   before the program exits.  The handling of such top-level exceptions can be
187   customized by assigning another three-argument function to ``sys.excepthook``.
188
189
190.. data:: __displayhook__
191          __excepthook__
192
193   These objects contain the original values of ``displayhook`` and ``excepthook``
194   at the start of the program.  They are saved so that ``displayhook`` and
195   ``excepthook`` can be restored in case they happen to get replaced with broken
196   objects.
197
198
199.. function:: exc_info()
200
201   This function returns a tuple of three values that give information about the
202   exception that is currently being handled.  The information returned is specific
203   both to the current thread and to the current stack frame.  If the current stack
204   frame is not handling an exception, the information is taken from the calling
205   stack frame, or its caller, and so on until a stack frame is found that is
206   handling an exception.  Here, "handling an exception" is defined as "executing
207   an except clause."  For any stack frame, only information about the exception
208   being currently handled is accessible.
209
210   .. index:: object: traceback
211
212   If no exception is being handled anywhere on the stack, a tuple containing
213   three ``None`` values is returned.  Otherwise, the values returned are
214   ``(type, value, traceback)``.  Their meaning is: *type* gets the type of the
215   exception being handled (a subclass of :exc:`BaseException`); *value* gets
216   the exception instance (an instance of the exception type); *traceback* gets
217   a traceback object (see the Reference Manual) which encapsulates the call
218   stack at the point where the exception originally occurred.
219
220
221.. data:: exec_prefix
222
223   A string giving the site-specific directory prefix where the platform-dependent
224   Python files are installed; by default, this is also ``'/usr/local'``.  This can
225   be set at build time with the ``--exec-prefix`` argument to the
226   :program:`configure` script.  Specifically, all configuration files (e.g. the
227   :file:`pyconfig.h` header file) are installed in the directory
228   :file:`{exec_prefix}/lib/python{X.Y}/config`, and shared library modules are
229   installed in :file:`{exec_prefix}/lib/python{X.Y}/lib-dynload`, where *X.Y*
230   is the version number of Python, for example ``3.2``.
231
232   .. note::
233
234      If a :ref:`virtual environment <venv-def>` is in effect, this
235      value will be changed in ``site.py`` to point to the virtual environment.
236      The value for the Python installation will still be available, via
237      :data:`base_exec_prefix`.
238
239
240.. data:: executable
241
242   A string giving the absolute path of the executable binary for the Python
243   interpreter, on systems where this makes sense. If Python is unable to retrieve
244   the real path to its executable, :data:`sys.executable` will be an empty string
245   or ``None``.
246
247
248.. function:: exit([arg])
249
250   Exit from Python.  This is implemented by raising the :exc:`SystemExit`
251   exception, so cleanup actions specified by finally clauses of :keyword:`try`
252   statements are honored, and it is possible to intercept the exit attempt at
253   an outer level.
254
255   The optional argument *arg* can be an integer giving the exit status
256   (defaulting to zero), or another type of object.  If it is an integer, zero
257   is considered "successful termination" and any nonzero value is considered
258   "abnormal termination" by shells and the like.  Most systems require it to be
259   in the range 0--127, and produce undefined results otherwise.  Some systems
260   have a convention for assigning specific meanings to specific exit codes, but
261   these are generally underdeveloped; Unix programs generally use 2 for command
262   line syntax errors and 1 for all other kind of errors.  If another type of
263   object is passed, ``None`` is equivalent to passing zero, and any other
264   object is printed to :data:`stderr` and results in an exit code of 1.  In
265   particular, ``sys.exit("some error message")`` is a quick way to exit a
266   program when an error occurs.
267
268   Since :func:`exit` ultimately "only" raises an exception, it will only exit
269   the process when called from the main thread, and the exception is not
270   intercepted.
271
272   .. versionchanged:: 3.6
273      If an error occurs in the cleanup after the Python interpreter
274      has caught :exc:`SystemExit` (such as an error flushing buffered data
275      in the standard streams), the exit status is changed to 120.
276
277
278.. data:: flags
279
280   The :term:`struct sequence` *flags* exposes the status of command line
281   flags. The attributes are read only.
282
283   ============================= =============================
284   attribute                     flag
285   ============================= =============================
286   :const:`debug`                :option:`-d`
287   :const:`inspect`              :option:`-i`
288   :const:`interactive`          :option:`-i`
289   :const:`optimize`             :option:`-O` or :option:`-OO`
290   :const:`dont_write_bytecode`  :option:`-B`
291   :const:`no_user_site`         :option:`-s`
292   :const:`no_site`              :option:`-S`
293   :const:`ignore_environment`   :option:`-E`
294   :const:`verbose`              :option:`-v`
295   :const:`bytes_warning`        :option:`-b`
296   :const:`quiet`                :option:`-q`
297   :const:`hash_randomization`   :option:`-R`
298   ============================= =============================
299
300   .. versionchanged:: 3.2
301      Added ``quiet`` attribute for the new :option:`-q` flag.
302
303   .. versionadded:: 3.2.3
304      The ``hash_randomization`` attribute.
305
306   .. versionchanged:: 3.3
307      Removed obsolete ``division_warning`` attribute.
308
309
310.. data:: float_info
311
312   A :term:`struct sequence` holding information about the float type. It
313   contains low level information about the precision and internal
314   representation.  The values correspond to the various floating-point
315   constants defined in the standard header file :file:`float.h` for the 'C'
316   programming language; see section 5.2.4.2.2 of the 1999 ISO/IEC C standard
317   [C99]_, 'Characteristics of floating types', for details.
318
319   .. tabularcolumns:: |l|l|L|
320
321   +---------------------+----------------+--------------------------------------------------+
322   | attribute           | float.h macro  | explanation                                      |
323   +=====================+================+==================================================+
324   | :const:`epsilon`    | DBL_EPSILON    | difference between 1 and the least value greater |
325   |                     |                | than 1 that is representable as a float          |
326   +---------------------+----------------+--------------------------------------------------+
327   | :const:`dig`        | DBL_DIG        | maximum number of decimal digits that can be     |
328   |                     |                | faithfully represented in a float;  see below    |
329   +---------------------+----------------+--------------------------------------------------+
330   | :const:`mant_dig`   | DBL_MANT_DIG   | float precision: the number of base-``radix``    |
331   |                     |                | digits in the significand of a float             |
332   +---------------------+----------------+--------------------------------------------------+
333   | :const:`max`        | DBL_MAX        | maximum representable finite float               |
334   +---------------------+----------------+--------------------------------------------------+
335   | :const:`max_exp`    | DBL_MAX_EXP    | maximum integer e such that ``radix**(e-1)`` is  |
336   |                     |                | a representable finite float                     |
337   +---------------------+----------------+--------------------------------------------------+
338   | :const:`max_10_exp` | DBL_MAX_10_EXP | maximum integer e such that ``10**e`` is in the  |
339   |                     |                | range of representable finite floats             |
340   +---------------------+----------------+--------------------------------------------------+
341   | :const:`min`        | DBL_MIN        | minimum positive normalized float                |
342   +---------------------+----------------+--------------------------------------------------+
343   | :const:`min_exp`    | DBL_MIN_EXP    | minimum integer e such that ``radix**(e-1)`` is  |
344   |                     |                | a normalized float                               |
345   +---------------------+----------------+--------------------------------------------------+
346   | :const:`min_10_exp` | DBL_MIN_10_EXP | minimum integer e such that ``10**e`` is a       |
347   |                     |                | normalized float                                 |
348   +---------------------+----------------+--------------------------------------------------+
349   | :const:`radix`      | FLT_RADIX      | radix of exponent representation                 |
350   +---------------------+----------------+--------------------------------------------------+
351   | :const:`rounds`     | FLT_ROUNDS     | integer constant representing the rounding mode  |
352   |                     |                | used for arithmetic operations.  This reflects   |
353   |                     |                | the value of the system FLT_ROUNDS macro at      |
354   |                     |                | interpreter startup time.  See section 5.2.4.2.2 |
355   |                     |                | of the C99 standard for an explanation of the    |
356   |                     |                | possible values and their meanings.              |
357   +---------------------+----------------+--------------------------------------------------+
358
359   The attribute :attr:`sys.float_info.dig` needs further explanation.  If
360   ``s`` is any string representing a decimal number with at most
361   :attr:`sys.float_info.dig` significant digits, then converting ``s`` to a
362   float and back again will recover a string representing the same decimal
363   value::
364
365      >>> import sys
366      >>> sys.float_info.dig
367      15
368      >>> s = '3.14159265358979'    # decimal string with 15 significant digits
369      >>> format(float(s), '.15g')  # convert to float and back -> same value
370      '3.14159265358979'
371
372   But for strings with more than :attr:`sys.float_info.dig` significant digits,
373   this isn't always true::
374
375      >>> s = '9876543211234567'    # 16 significant digits is too many!
376      >>> format(float(s), '.16g')  # conversion changes value
377      '9876543211234568'
378
379.. data:: float_repr_style
380
381   A string indicating how the :func:`repr` function behaves for
382   floats.  If the string has value ``'short'`` then for a finite
383   float ``x``, ``repr(x)`` aims to produce a short string with the
384   property that ``float(repr(x)) == x``.  This is the usual behaviour
385   in Python 3.1 and later.  Otherwise, ``float_repr_style`` has value
386   ``'legacy'`` and ``repr(x)`` behaves in the same way as it did in
387   versions of Python prior to 3.1.
388
389   .. versionadded:: 3.1
390
391
392.. function:: getallocatedblocks()
393
394   Return the number of memory blocks currently allocated by the interpreter,
395   regardless of their size.  This function is mainly useful for tracking
396   and debugging memory leaks.  Because of the interpreter's internal
397   caches, the result can vary from call to call; you may have to call
398   :func:`_clear_type_cache()` and :func:`gc.collect()` to get more
399   predictable results.
400
401   If a Python build or implementation cannot reasonably compute this
402   information, :func:`getallocatedblocks()` is allowed to return 0 instead.
403
404   .. versionadded:: 3.4
405
406
407.. function:: getcheckinterval()
408
409   Return the interpreter's "check interval"; see :func:`setcheckinterval`.
410
411   .. deprecated:: 3.2
412      Use :func:`getswitchinterval` instead.
413
414
415.. function:: getdefaultencoding()
416
417   Return the name of the current default string encoding used by the Unicode
418   implementation.
419
420
421.. function:: getdlopenflags()
422
423   Return the current value of the flags that are used for
424   :c:func:`dlopen` calls.  Symbolic names for the flag values can be
425   found in the :mod:`os` module (``RTLD_xxx`` constants, e.g.
426   :data:`os.RTLD_LAZY`).  Availability: Unix.
427
428
429.. function:: getfilesystemencoding()
430
431   Return the name of the encoding used to convert between Unicode
432   filenames and bytes filenames. For best compatibility, str should be
433   used for filenames in all cases, although representing filenames as bytes
434   is also supported. Functions accepting or returning filenames should support
435   either str or bytes and internally convert to the system's preferred
436   representation.
437
438   This encoding is always ASCII-compatible.
439
440   :func:`os.fsencode` and :func:`os.fsdecode` should be used to ensure that
441   the correct encoding and errors mode are used.
442
443   * On Mac OS X, the encoding is ``'utf-8'``.
444
445   * On Unix, the encoding is the locale encoding.
446
447   * On Windows, the encoding may be ``'utf-8'`` or ``'mbcs'``, depending
448     on user configuration.
449
450   .. versionchanged:: 3.2
451      :func:`getfilesystemencoding` result cannot be ``None`` anymore.
452
453   .. versionchanged:: 3.6
454      Windows is no longer guaranteed to return ``'mbcs'``. See :pep:`529`
455      and :func:`_enablelegacywindowsfsencoding` for more information.
456
457.. function:: getfilesystemencodeerrors()
458
459   Return the name of the error mode used to convert between Unicode filenames
460   and bytes filenames. The encoding name is returned from
461   :func:`getfilesystemencoding`.
462
463   :func:`os.fsencode` and :func:`os.fsdecode` should be used to ensure that
464   the correct encoding and errors mode are used.
465
466   .. versionadded:: 3.6
467
468.. function:: getrefcount(object)
469
470   Return the reference count of the *object*.  The count returned is generally one
471   higher than you might expect, because it includes the (temporary) reference as
472   an argument to :func:`getrefcount`.
473
474
475.. function:: getrecursionlimit()
476
477   Return the current value of the recursion limit, the maximum depth of the Python
478   interpreter stack.  This limit prevents infinite recursion from causing an
479   overflow of the C stack and crashing Python.  It can be set by
480   :func:`setrecursionlimit`.
481
482
483.. function:: getsizeof(object[, default])
484
485   Return the size of an object in bytes. The object can be any type of
486   object. All built-in objects will return correct results, but this
487   does not have to hold true for third-party extensions as it is implementation
488   specific.
489
490   Only the memory consumption directly attributed to the object is
491   accounted for, not the memory consumption of objects it refers to.
492
493   If given, *default* will be returned if the object does not provide means to
494   retrieve the size.  Otherwise a :exc:`TypeError` will be raised.
495
496   :func:`getsizeof` calls the object's ``__sizeof__`` method and adds an
497   additional garbage collector overhead if the object is managed by the garbage
498   collector.
499
500   See `recursive sizeof recipe <https://code.activestate.com/recipes/577504>`_
501   for an example of using :func:`getsizeof` recursively to find the size of
502   containers and all their contents.
503
504.. function:: getswitchinterval()
505
506   Return the interpreter's "thread switch interval"; see
507   :func:`setswitchinterval`.
508
509   .. versionadded:: 3.2
510
511
512.. function:: _getframe([depth])
513
514   Return a frame object from the call stack.  If optional integer *depth* is
515   given, return the frame object that many calls below the top of the stack.  If
516   that is deeper than the call stack, :exc:`ValueError` is raised.  The default
517   for *depth* is zero, returning the frame at the top of the call stack.
518
519   .. impl-detail::
520
521      This function should be used for internal and specialized purposes only.
522      It is not guaranteed to exist in all implementations of Python.
523
524
525.. function:: getprofile()
526
527   .. index::
528      single: profile function
529      single: profiler
530
531   Get the profiler function as set by :func:`setprofile`.
532
533
534.. function:: gettrace()
535
536   .. index::
537      single: trace function
538      single: debugger
539
540   Get the trace function as set by :func:`settrace`.
541
542   .. impl-detail::
543
544      The :func:`gettrace` function is intended only for implementing debuggers,
545      profilers, coverage tools and the like.  Its behavior is part of the
546      implementation platform, rather than part of the language definition, and
547      thus may not be available in all Python implementations.
548
549
550.. function:: getwindowsversion()
551
552   Return a named tuple describing the Windows version
553   currently running.  The named elements are *major*, *minor*,
554   *build*, *platform*, *service_pack*, *service_pack_minor*,
555   *service_pack_major*, *suite_mask*, *product_type* and
556   *platform_version*. *service_pack* contains a string,
557   *platform_version* a 3-tuple and all other values are
558   integers. The components can also be accessed by name, so
559   ``sys.getwindowsversion()[0]`` is equivalent to
560   ``sys.getwindowsversion().major``. For compatibility with prior
561   versions, only the first 5 elements are retrievable by indexing.
562
563   *platform* will be :const:`2 (VER_PLATFORM_WIN32_NT)`.
564
565   *product_type* may be one of the following values:
566
567   +---------------------------------------+---------------------------------+
568   | Constant                              | Meaning                         |
569   +=======================================+=================================+
570   | :const:`1 (VER_NT_WORKSTATION)`       | The system is a workstation.    |
571   +---------------------------------------+---------------------------------+
572   | :const:`2 (VER_NT_DOMAIN_CONTROLLER)` | The system is a domain          |
573   |                                       | controller.                     |
574   +---------------------------------------+---------------------------------+
575   | :const:`3 (VER_NT_SERVER)`            | The system is a server, but not |
576   |                                       | a domain controller.            |
577   +---------------------------------------+---------------------------------+
578
579   This function wraps the Win32 :c:func:`GetVersionEx` function; see the
580   Microsoft documentation on :c:func:`OSVERSIONINFOEX` for more information
581   about these fields.
582
583   *platform_version* returns the accurate major version, minor version and
584   build number of the current operating system, rather than the version that
585   is being emulated for the process. It is intended for use in logging rather
586   than for feature detection.
587
588   Availability: Windows.
589
590   .. versionchanged:: 3.2
591      Changed to a named tuple and added *service_pack_minor*,
592      *service_pack_major*, *suite_mask*, and *product_type*.
593
594   .. versionchanged:: 3.6
595      Added *platform_version*
596
597
598.. function:: get_asyncgen_hooks()
599
600   Returns an *asyncgen_hooks* object, which is similar to a
601   :class:`~collections.namedtuple` of the form `(firstiter, finalizer)`,
602   where *firstiter* and *finalizer* are expected to be either ``None`` or
603   functions which take an :term:`asynchronous generator iterator` as an
604   argument, and are used to schedule finalization of an asychronous
605   generator by an event loop.
606
607   .. versionadded:: 3.6
608      See :pep:`525` for more details.
609
610   .. note::
611      This function has been added on a provisional basis (see :pep:`411`
612      for details.)
613
614
615.. function:: get_coroutine_wrapper()
616
617   Returns ``None``, or a wrapper set by :func:`set_coroutine_wrapper`.
618
619   .. versionadded:: 3.5
620      See :pep:`492` for more details.
621
622   .. note::
623      This function has been added on a provisional basis (see :pep:`411`
624      for details.)  Use it only for debugging purposes.
625
626
627.. data:: hash_info
628
629   A :term:`struct sequence` giving parameters of the numeric hash
630   implementation.  For more details about hashing of numeric types, see
631   :ref:`numeric-hash`.
632
633   +---------------------+--------------------------------------------------+
634   | attribute           | explanation                                      |
635   +=====================+==================================================+
636   | :const:`width`      | width in bits used for hash values               |
637   +---------------------+--------------------------------------------------+
638   | :const:`modulus`    | prime modulus P used for numeric hash scheme     |
639   +---------------------+--------------------------------------------------+
640   | :const:`inf`        | hash value returned for a positive infinity      |
641   +---------------------+--------------------------------------------------+
642   | :const:`nan`        | hash value returned for a nan                    |
643   +---------------------+--------------------------------------------------+
644   | :const:`imag`       | multiplier used for the imaginary part of a      |
645   |                     | complex number                                   |
646   +---------------------+--------------------------------------------------+
647   | :const:`algorithm`  | name of the algorithm for hashing of str, bytes, |
648   |                     | and memoryview                                   |
649   +---------------------+--------------------------------------------------+
650   | :const:`hash_bits`  | internal output size of the hash algorithm       |
651   +---------------------+--------------------------------------------------+
652   | :const:`seed_bits`  | size of the seed key of the hash algorithm       |
653   +---------------------+--------------------------------------------------+
654
655
656   .. versionadded:: 3.2
657
658   .. versionchanged:: 3.4
659      Added *algorithm*, *hash_bits* and *seed_bits*
660
661
662.. data:: hexversion
663
664   The version number encoded as a single integer.  This is guaranteed to increase
665   with each version, including proper support for non-production releases.  For
666   example, to test that the Python interpreter is at least version 1.5.2, use::
667
668      if sys.hexversion >= 0x010502F0:
669          # use some advanced feature
670          ...
671      else:
672          # use an alternative implementation or warn the user
673          ...
674
675   This is called ``hexversion`` since it only really looks meaningful when viewed
676   as the result of passing it to the built-in :func:`hex` function.  The
677   :term:`struct sequence`  :data:`sys.version_info` may be used for a more
678   human-friendly encoding of the same information.
679
680   More details of ``hexversion`` can be found at :ref:`apiabiversion`.
681
682
683.. data:: implementation
684
685   An object containing information about the implementation of the
686   currently running Python interpreter.  The following attributes are
687   required to exist in all Python implementations.
688
689   *name* is the implementation's identifier, e.g. ``'cpython'``.  The actual
690   string is defined by the Python implementation, but it is guaranteed to be
691   lower case.
692
693   *version* is a named tuple, in the same format as
694   :data:`sys.version_info`.  It represents the version of the Python
695   *implementation*.  This has a distinct meaning from the specific
696   version of the Python *language* to which the currently running
697   interpreter conforms, which ``sys.version_info`` represents.  For
698   example, for PyPy 1.8 ``sys.implementation.version`` might be
699   ``sys.version_info(1, 8, 0, 'final', 0)``, whereas ``sys.version_info``
700   would be ``sys.version_info(2, 7, 2, 'final', 0)``.  For CPython they
701   are the same value, since it is the reference implementation.
702
703   *hexversion* is the implementation version in hexadecimal format, like
704   :data:`sys.hexversion`.
705
706   *cache_tag* is the tag used by the import machinery in the filenames of
707   cached modules.  By convention, it would be a composite of the
708   implementation's name and version, like ``'cpython-33'``.  However, a
709   Python implementation may use some other value if appropriate.  If
710   ``cache_tag`` is set to ``None``, it indicates that module caching should
711   be disabled.
712
713   :data:`sys.implementation` may contain additional attributes specific to
714   the Python implementation.  These non-standard attributes must start with
715   an underscore, and are not described here.  Regardless of its contents,
716   :data:`sys.implementation` will not change during a run of the interpreter,
717   nor between implementation versions.  (It may change between Python
718   language versions, however.)  See :pep:`421` for more information.
719
720   .. versionadded:: 3.3
721
722
723.. data:: int_info
724
725   A :term:`struct sequence` that holds information about Python's internal
726   representation of integers.  The attributes are read only.
727
728   .. tabularcolumns:: |l|L|
729
730   +-------------------------+----------------------------------------------+
731   | Attribute               | Explanation                                  |
732   +=========================+==============================================+
733   | :const:`bits_per_digit` | number of bits held in each digit.  Python   |
734   |                         | integers are stored internally in base       |
735   |                         | ``2**int_info.bits_per_digit``               |
736   +-------------------------+----------------------------------------------+
737   | :const:`sizeof_digit`   | size in bytes of the C type used to          |
738   |                         | represent a digit                            |
739   +-------------------------+----------------------------------------------+
740
741   .. versionadded:: 3.1
742
743
744.. data:: __interactivehook__
745
746   When this attribute exists, its value is automatically called (with no
747   arguments) when the interpreter is launched in :ref:`interactive mode
748   <tut-interactive>`.  This is done after the :envvar:`PYTHONSTARTUP` file is
749   read, so that you can set this hook there.  The :mod:`site` module
750   :ref:`sets this <rlcompleter-config>`.
751
752   .. versionadded:: 3.4
753
754
755.. function:: intern(string)
756
757   Enter *string* in the table of "interned" strings and return the interned string
758   -- which is *string* itself or a copy. Interning strings is useful to gain a
759   little performance on dictionary lookup -- if the keys in a dictionary are
760   interned, and the lookup key is interned, the key comparisons (after hashing)
761   can be done by a pointer compare instead of a string compare.  Normally, the
762   names used in Python programs are automatically interned, and the dictionaries
763   used to hold module, class or instance attributes have interned keys.
764
765   Interned strings are not immortal; you must keep a reference to the return
766   value of :func:`intern` around to benefit from it.
767
768
769.. function:: is_finalizing()
770
771   Return :const:`True` if the Python interpreter is
772   :term:`shutting down <interpreter shutdown>`, :const:`False` otherwise.
773
774   .. versionadded:: 3.5
775
776
777.. data:: last_type
778          last_value
779          last_traceback
780
781   These three variables are not always defined; they are set when an exception is
782   not handled and the interpreter prints an error message and a stack traceback.
783   Their intended use is to allow an interactive user to import a debugger module
784   and engage in post-mortem debugging without having to re-execute the command
785   that caused the error.  (Typical use is ``import pdb; pdb.pm()`` to enter the
786   post-mortem debugger; see :mod:`pdb` module for
787   more information.)
788
789   The meaning of the variables is the same as that of the return values from
790   :func:`exc_info` above.
791
792
793.. data:: maxsize
794
795   An integer giving the maximum value a variable of type :c:type:`Py_ssize_t` can
796   take.  It's usually ``2**31 - 1`` on a 32-bit platform and ``2**63 - 1`` on a
797   64-bit platform.
798
799
800.. data:: maxunicode
801
802   An integer giving the value of the largest Unicode code point,
803   i.e. ``1114111`` (``0x10FFFF`` in hexadecimal).
804
805   .. versionchanged:: 3.3
806      Before :pep:`393`, ``sys.maxunicode`` used to be either ``0xFFFF``
807      or ``0x10FFFF``, depending on the configuration option that specified
808      whether Unicode characters were stored as UCS-2 or UCS-4.
809
810
811.. data:: meta_path
812
813    A list of :term:`meta path finder` objects that have their
814    :meth:`~importlib.abc.MetaPathFinder.find_spec` methods called to see if one
815    of the objects can find the module to be imported. The
816    :meth:`~importlib.abc.MetaPathFinder.find_spec` method is called with at
817    least the absolute name of the module being imported. If the module to be
818    imported is contained in a package, then the parent package's :attr:`__path__`
819    attribute is passed in as a second argument. The method returns a
820    :term:`module spec`, or ``None`` if the module cannot be found.
821
822    .. seealso::
823
824        :class:`importlib.abc.MetaPathFinder`
825          The abstract base class defining the interface of finder objects on
826          :data:`meta_path`.
827        :class:`importlib.machinery.ModuleSpec`
828          The concrete class which
829          :meth:`~importlib.abc.MetaPathFinder.find_spec` should return
830          instances of.
831
832    .. versionchanged:: 3.4
833
834        :term:`Module specs <module spec>` were introduced in Python 3.4, by
835        :pep:`451`. Earlier versions of Python looked for a method called
836        :meth:`~importlib.abc.MetaPathFinder.find_module`.
837        This is still called as a fallback if a :data:`meta_path` entry doesn't
838        have a :meth:`~importlib.abc.MetaPathFinder.find_spec` method.
839
840.. data:: modules
841
842   This is a dictionary that maps module names to modules which have already been
843   loaded.  This can be manipulated to force reloading of modules and other tricks.
844   However, replacing the dictionary will not necessarily work as expected and
845   deleting essential items from the dictionary may cause Python to fail.
846
847
848.. data:: path
849
850   .. index:: triple: module; search; path
851
852   A list of strings that specifies the search path for modules. Initialized from
853   the environment variable :envvar:`PYTHONPATH`, plus an installation-dependent
854   default.
855
856   As initialized upon program startup, the first item of this list, ``path[0]``,
857   is the directory containing the script that was used to invoke the Python
858   interpreter.  If the script directory is not available (e.g.  if the interpreter
859   is invoked interactively or if the script is read from standard input),
860   ``path[0]`` is the empty string, which directs Python to search modules in the
861   current directory first.  Notice that the script directory is inserted *before*
862   the entries inserted as a result of :envvar:`PYTHONPATH`.
863
864   A program is free to modify this list for its own purposes.  Only strings
865   and bytes should be added to :data:`sys.path`; all other data types are
866   ignored during import.
867
868
869   .. seealso::
870      Module :mod:`site` This describes how to use .pth files to extend
871      :data:`sys.path`.
872
873
874.. data:: path_hooks
875
876    A list of callables that take a path argument to try to create a
877    :term:`finder` for the path. If a finder can be created, it is to be
878    returned by the callable, else raise :exc:`ImportError`.
879
880    Originally specified in :pep:`302`.
881
882
883.. data:: path_importer_cache
884
885    A dictionary acting as a cache for :term:`finder` objects. The keys are
886    paths that have been passed to :data:`sys.path_hooks` and the values are
887    the finders that are found. If a path is a valid file system path but no
888    finder is found on :data:`sys.path_hooks` then ``None`` is
889    stored.
890
891    Originally specified in :pep:`302`.
892
893    .. versionchanged:: 3.3
894       ``None`` is stored instead of :class:`imp.NullImporter` when no finder
895       is found.
896
897
898.. data:: platform
899
900   This string contains a platform identifier that can be used to append
901   platform-specific components to :data:`sys.path`, for instance.
902
903   For Unix systems, except on Linux, this is the lowercased OS name as
904   returned by ``uname -s`` with the first part of the version as returned by
905   ``uname -r`` appended, e.g. ``'sunos5'`` or ``'freebsd8'``, *at the time
906   when Python was built*.  Unless you want to test for a specific system
907   version, it is therefore recommended to use the following idiom::
908
909      if sys.platform.startswith('freebsd'):
910          # FreeBSD-specific code here...
911      elif sys.platform.startswith('linux'):
912          # Linux-specific code here...
913
914   For other systems, the values are:
915
916   ================ ===========================
917   System           ``platform`` value
918   ================ ===========================
919   Linux            ``'linux'``
920   Windows          ``'win32'``
921   Windows/Cygwin   ``'cygwin'``
922   Mac OS X         ``'darwin'``
923   ================ ===========================
924
925   .. versionchanged:: 3.3
926      On Linux, :attr:`sys.platform` doesn't contain the major version anymore.
927      It is always ``'linux'``, instead of ``'linux2'`` or ``'linux3'``.  Since
928      older Python versions include the version number, it is recommended to
929      always use the ``startswith`` idiom presented above.
930
931   .. seealso::
932
933      :attr:`os.name` has a coarser granularity.  :func:`os.uname` gives
934      system-dependent version information.
935
936      The :mod:`platform` module provides detailed checks for the
937      system's identity.
938
939
940.. data:: prefix
941
942   A string giving the site-specific directory prefix where the platform
943   independent Python files are installed; by default, this is the string
944   ``'/usr/local'``.  This can be set at build time with the ``--prefix``
945   argument to the :program:`configure` script.  The main collection of Python
946   library modules is installed in the directory :file:`{prefix}/lib/python{X.Y}`
947   while the platform independent header files (all except :file:`pyconfig.h`) are
948   stored in :file:`{prefix}/include/python{X.Y}`, where *X.Y* is the version
949   number of Python, for example ``3.2``.
950
951   .. note:: If a :ref:`virtual environment <venv-def>` is in effect, this
952      value will be changed in ``site.py`` to point to the virtual
953      environment. The value for the Python installation will still be
954      available, via :data:`base_prefix`.
955
956
957.. data:: ps1
958          ps2
959
960   .. index::
961      single: interpreter prompts
962      single: prompts, interpreter
963
964   Strings specifying the primary and secondary prompt of the interpreter.  These
965   are only defined if the interpreter is in interactive mode.  Their initial
966   values in this case are ``'>>> '`` and ``'... '``.  If a non-string object is
967   assigned to either variable, its :func:`str` is re-evaluated each time the
968   interpreter prepares to read a new interactive command; this can be used to
969   implement a dynamic prompt.
970
971
972.. function:: setcheckinterval(interval)
973
974   Set the interpreter's "check interval".  This integer value determines how often
975   the interpreter checks for periodic things such as thread switches and signal
976   handlers.  The default is ``100``, meaning the check is performed every 100
977   Python virtual instructions. Setting it to a larger value may increase
978   performance for programs using threads.  Setting it to a value ``<=`` 0 checks
979   every virtual instruction, maximizing responsiveness as well as overhead.
980
981   .. deprecated:: 3.2
982      This function doesn't have an effect anymore, as the internal logic for
983      thread switching and asynchronous tasks has been rewritten.  Use
984      :func:`setswitchinterval` instead.
985
986
987.. function:: setdlopenflags(n)
988
989   Set the flags used by the interpreter for :c:func:`dlopen` calls, such as when
990   the interpreter loads extension modules.  Among other things, this will enable a
991   lazy resolving of symbols when importing a module, if called as
992   ``sys.setdlopenflags(0)``.  To share symbols across extension modules, call as
993   ``sys.setdlopenflags(os.RTLD_GLOBAL)``.  Symbolic names for the flag values
994   can be found in the :mod:`os` module (``RTLD_xxx`` constants, e.g.
995   :data:`os.RTLD_LAZY`).
996
997   Availability: Unix.
998
999.. function:: setprofile(profilefunc)
1000
1001   .. index::
1002      single: profile function
1003      single: profiler
1004
1005   Set the system's profile function, which allows you to implement a Python source
1006   code profiler in Python.  See chapter :ref:`profile` for more information on the
1007   Python profiler.  The system's profile function is called similarly to the
1008   system's trace function (see :func:`settrace`), but it isn't called for each
1009   executed line of code (only on call and return, but the return event is reported
1010   even when an exception has been set).  The function is thread-specific, but
1011   there is no way for the profiler to know about context switches between threads,
1012   so it does not make sense to use this in the presence of multiple threads. Also,
1013   its return value is not used, so it can simply return ``None``.
1014
1015
1016.. function:: setrecursionlimit(limit)
1017
1018   Set the maximum depth of the Python interpreter stack to *limit*.  This limit
1019   prevents infinite recursion from causing an overflow of the C stack and crashing
1020   Python.
1021
1022   The highest possible limit is platform-dependent.  A user may need to set the
1023   limit higher when they have a program that requires deep recursion and a platform
1024   that supports a higher limit.  This should be done with care, because a too-high
1025   limit can lead to a crash.
1026
1027   If the new limit is too low at the current recursion depth, a
1028   :exc:`RecursionError` exception is raised.
1029
1030   .. versionchanged:: 3.5.1
1031      A :exc:`RecursionError` exception is now raised if the new limit is too
1032      low at the current recursion depth.
1033
1034
1035.. function:: setswitchinterval(interval)
1036
1037   Set the interpreter's thread switch interval (in seconds).  This floating-point
1038   value determines the ideal duration of the "timeslices" allocated to
1039   concurrently running Python threads.  Please note that the actual value
1040   can be higher, especially if long-running internal functions or methods
1041   are used.  Also, which thread becomes scheduled at the end of the interval
1042   is the operating system's decision.  The interpreter doesn't have its
1043   own scheduler.
1044
1045   .. versionadded:: 3.2
1046
1047
1048.. function:: settrace(tracefunc)
1049
1050   .. index::
1051      single: trace function
1052      single: debugger
1053
1054   Set the system's trace function, which allows you to implement a Python
1055   source code debugger in Python.  The function is thread-specific; for a
1056   debugger to support multiple threads, it must be registered using
1057   :func:`settrace` for each thread being debugged.
1058
1059   Trace functions should have three arguments: *frame*, *event*, and
1060   *arg*. *frame* is the current stack frame.  *event* is a string: ``'call'``,
1061   ``'line'``, ``'return'``, ``'exception'``, ``'c_call'``, ``'c_return'``, or
1062   ``'c_exception'``. *arg* depends on the event type.
1063
1064   The trace function is invoked (with *event* set to ``'call'``) whenever a new
1065   local scope is entered; it should return a reference to a local trace
1066   function to be used that scope, or ``None`` if the scope shouldn't be traced.
1067
1068   The local trace function should return a reference to itself (or to another
1069   function for further tracing in that scope), or ``None`` to turn off tracing
1070   in that scope.
1071
1072   The events have the following meaning:
1073
1074   ``'call'``
1075      A function is called (or some other code block entered).  The
1076      global trace function is called; *arg* is ``None``; the return value
1077      specifies the local trace function.
1078
1079   ``'line'``
1080      The interpreter is about to execute a new line of code or re-execute the
1081      condition of a loop.  The local trace function is called; *arg* is
1082      ``None``; the return value specifies the new local trace function.  See
1083      :file:`Objects/lnotab_notes.txt` for a detailed explanation of how this
1084      works.
1085
1086   ``'return'``
1087      A function (or other code block) is about to return.  The local trace
1088      function is called; *arg* is the value that will be returned, or ``None``
1089      if the event is caused by an exception being raised.  The trace function's
1090      return value is ignored.
1091
1092   ``'exception'``
1093      An exception has occurred.  The local trace function is called; *arg* is a
1094      tuple ``(exception, value, traceback)``; the return value specifies the
1095      new local trace function.
1096
1097   ``'c_call'``
1098      A C function is about to be called.  This may be an extension function or
1099      a built-in.  *arg* is the C function object.
1100
1101   ``'c_return'``
1102      A C function has returned. *arg* is the C function object.
1103
1104   ``'c_exception'``
1105      A C function has raised an exception.  *arg* is the C function object.
1106
1107   Note that as an exception is propagated down the chain of callers, an
1108   ``'exception'`` event is generated at each level.
1109
1110   For more information on code and frame objects, refer to :ref:`types`.
1111
1112   .. impl-detail::
1113
1114      The :func:`settrace` function is intended only for implementing debuggers,
1115      profilers, coverage tools and the like.  Its behavior is part of the
1116      implementation platform, rather than part of the language definition, and
1117      thus may not be available in all Python implementations.
1118
1119.. function:: set_asyncgen_hooks(firstiter, finalizer)
1120
1121   Accepts two optional keyword arguments which are callables that accept an
1122   :term:`asynchronous generator iterator` as an argument. The *firstiter*
1123   callable will be called when an asynchronous generator is iterated for the
1124   first time. The *finalizer* will be called when an asynchronous generator
1125   is about to be garbage collected.
1126
1127   .. versionadded:: 3.6
1128      See :pep:`525` for more details, and for a reference example of a
1129      *finalizer* method see the implementation of
1130      ``asyncio.Loop.shutdown_asyncgens`` in
1131      :source:`Lib/asyncio/base_events.py`
1132
1133   .. note::
1134      This function has been added on a provisional basis (see :pep:`411`
1135      for details.)
1136
1137
1138.. function:: set_coroutine_wrapper(wrapper)
1139
1140   Allows intercepting creation of :term:`coroutine` objects (only ones that
1141   are created by an :keyword:`async def` function; generators decorated with
1142   :func:`types.coroutine` or :func:`asyncio.coroutine` will not be
1143   intercepted).
1144
1145   The *wrapper* argument must be either:
1146
1147   * a callable that accepts one argument (a coroutine object);
1148   * ``None``, to reset the wrapper.
1149
1150   If called twice, the new wrapper replaces the previous one.  The function
1151   is thread-specific.
1152
1153   The *wrapper* callable cannot define new coroutines directly or indirectly::
1154
1155        def wrapper(coro):
1156            async def wrap(coro):
1157                return await coro
1158            return wrap(coro)
1159        sys.set_coroutine_wrapper(wrapper)
1160
1161        async def foo():
1162            pass
1163
1164        # The following line will fail with a RuntimeError, because
1165        # ``wrapper`` creates a ``wrap(coro)`` coroutine:
1166        foo()
1167
1168   See also :func:`get_coroutine_wrapper`.
1169
1170   .. versionadded:: 3.5
1171      See :pep:`492` for more details.
1172
1173   .. note::
1174      This function has been added on a provisional basis (see :pep:`411`
1175      for details.)  Use it only for debugging purposes.
1176
1177.. function:: _enablelegacywindowsfsencoding()
1178
1179   Changes the default filesystem encoding and errors mode to 'mbcs' and
1180   'replace' respectively, for consistency with versions of Python prior to 3.6.
1181
1182   This is equivalent to defining the :envvar:`PYTHONLEGACYWINDOWSFSENCODING`
1183   environment variable before launching Python.
1184
1185   Availability: Windows
1186
1187   .. versionadded:: 3.6
1188      See :pep:`529` for more details.
1189
1190.. data:: stdin
1191          stdout
1192          stderr
1193
1194   :term:`File objects <file object>` used by the interpreter for standard
1195   input, output and errors:
1196
1197   * ``stdin`` is used for all interactive input (including calls to
1198     :func:`input`);
1199   * ``stdout`` is used for the output of :func:`print` and :term:`expression`
1200     statements and for the prompts of :func:`input`;
1201   * The interpreter's own prompts and its error messages go to ``stderr``.
1202
1203   These streams are regular :term:`text files <text file>` like those
1204   returned by the :func:`open` function.  Their parameters are chosen as
1205   follows:
1206
1207   * The character encoding is platform-dependent.  Under Windows, if the stream
1208     is interactive (that is, if its :meth:`isatty` method returns ``True``), the
1209     console codepage is used, otherwise the ANSI code page.  Under other
1210     platforms, the locale encoding is used (see :meth:`locale.getpreferredencoding`).
1211
1212     Under all platforms though, you can override this value by setting the
1213     :envvar:`PYTHONIOENCODING` environment variable before starting Python.
1214
1215   * When interactive, standard streams are line-buffered.  Otherwise, they
1216     are block-buffered like regular text files.  You can override this
1217     value with the :option:`-u` command-line option.
1218
1219   .. note::
1220
1221      To write or read binary data from/to the standard streams, use the
1222      underlying binary :data:`~io.TextIOBase.buffer` object.  For example, to
1223      write bytes to :data:`stdout`, use ``sys.stdout.buffer.write(b'abc')``.
1224
1225      However, if you are writing a library (and do not control in which
1226      context its code will be executed), be aware that the standard streams
1227      may be replaced with file-like objects like :class:`io.StringIO` which
1228      do not support the :attr:`~io.BufferedIOBase.buffer` attribute.
1229
1230
1231.. data:: __stdin__
1232          __stdout__
1233          __stderr__
1234
1235   These objects contain the original values of ``stdin``, ``stderr`` and
1236   ``stdout`` at the start of the program.  They are used during finalization,
1237   and could be useful to print to the actual standard stream no matter if the
1238   ``sys.std*`` object has been redirected.
1239
1240   It can also be used to restore the actual files to known working file objects
1241   in case they have been overwritten with a broken object.  However, the
1242   preferred way to do this is to explicitly save the previous stream before
1243   replacing it, and restore the saved object.
1244
1245   .. note::
1246       Under some conditions ``stdin``, ``stdout`` and ``stderr`` as well as the
1247       original values ``__stdin__``, ``__stdout__`` and ``__stderr__`` can be
1248       ``None``. It is usually the case for Windows GUI apps that aren't connected
1249       to a console and Python apps started with :program:`pythonw`.
1250
1251
1252.. data:: thread_info
1253
1254   A :term:`struct sequence` holding information about the thread
1255   implementation.
1256
1257   .. tabularcolumns:: |l|p{0.7\linewidth}|
1258
1259   +------------------+---------------------------------------------------------+
1260   | Attribute        | Explanation                                             |
1261   +==================+=========================================================+
1262   | :const:`name`    | Name of the thread implementation:                      |
1263   |                  |                                                         |
1264   |                  |  * ``'nt'``: Windows threads                            |
1265   |                  |  * ``'pthread'``: POSIX threads                         |
1266   |                  |  * ``'solaris'``: Solaris threads                       |
1267   +------------------+---------------------------------------------------------+
1268   | :const:`lock`    | Name of the lock implementation:                        |
1269   |                  |                                                         |
1270   |                  |  * ``'semaphore'``: a lock uses a semaphore             |
1271   |                  |  * ``'mutex+cond'``: a lock uses a mutex                |
1272   |                  |    and a condition variable                             |
1273   |                  |  * ``None`` if this information is unknown              |
1274   +------------------+---------------------------------------------------------+
1275   | :const:`version` | Name and version of the thread library. It is a string, |
1276   |                  | or ``None`` if these informations are unknown.          |
1277   +------------------+---------------------------------------------------------+
1278
1279   .. versionadded:: 3.3
1280
1281
1282.. data:: tracebacklimit
1283
1284   When this variable is set to an integer value, it determines the maximum number
1285   of levels of traceback information printed when an unhandled exception occurs.
1286   The default is ``1000``.  When set to ``0`` or less, all traceback information
1287   is suppressed and only the exception type and value are printed.
1288
1289
1290.. data:: version
1291
1292   A string containing the version number of the Python interpreter plus additional
1293   information on the build number and compiler used.  This string is displayed
1294   when the interactive interpreter is started.  Do not extract version information
1295   out of it, rather, use :data:`version_info` and the functions provided by the
1296   :mod:`platform` module.
1297
1298
1299.. data:: api_version
1300
1301   The C API version for this interpreter.  Programmers may find this useful when
1302   debugging version conflicts between Python and extension modules.
1303
1304
1305.. data:: version_info
1306
1307   A tuple containing the five components of the version number: *major*, *minor*,
1308   *micro*, *releaselevel*, and *serial*.  All values except *releaselevel* are
1309   integers; the release level is ``'alpha'``, ``'beta'``, ``'candidate'``, or
1310   ``'final'``.  The ``version_info`` value corresponding to the Python version 2.0
1311   is ``(2, 0, 0, 'final', 0)``.  The components can also be accessed by name,
1312   so ``sys.version_info[0]`` is equivalent to ``sys.version_info.major``
1313   and so on.
1314
1315   .. versionchanged:: 3.1
1316      Added named component attributes.
1317
1318.. data:: warnoptions
1319
1320   This is an implementation detail of the warnings framework; do not modify this
1321   value.  Refer to the :mod:`warnings` module for more information on the warnings
1322   framework.
1323
1324
1325.. data:: winver
1326
1327   The version number used to form registry keys on Windows platforms. This is
1328   stored as string resource 1000 in the Python DLL.  The value is normally the
1329   first three characters of :const:`version`.  It is provided in the :mod:`sys`
1330   module for informational purposes; modifying this value has no effect on the
1331   registry keys used by Python. Availability: Windows.
1332
1333
1334.. data:: _xoptions
1335
1336   A dictionary of the various implementation-specific flags passed through
1337   the :option:`-X` command-line option.  Option names are either mapped to
1338   their values, if given explicitly, or to :const:`True`.  Example:
1339
1340   .. code-block:: shell-session
1341
1342      $ ./python -Xa=b -Xc
1343      Python 3.2a3+ (py3k, Oct 16 2010, 20:14:50)
1344      [GCC 4.4.3] on linux2
1345      Type "help", "copyright", "credits" or "license" for more information.
1346      >>> import sys
1347      >>> sys._xoptions
1348      {'a': 'b', 'c': True}
1349
1350   .. impl-detail::
1351
1352      This is a CPython-specific way of accessing options passed through
1353      :option:`-X`.  Other implementations may export them through other
1354      means, or not at all.
1355
1356   .. versionadded:: 3.2
1357
1358
1359.. rubric:: Citations
1360
1361.. [C99] ISO/IEC 9899:1999.  "Programming languages -- C."  A public draft of this standard is available at http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf\ .
1362