1871 lines
156 KiB
HTML
1871 lines
156 KiB
HTML
|
||
<!DOCTYPE html>
|
||
|
||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||
<head>
|
||
<meta charset="utf-8" />
|
||
<title>sys — System-specific parameters and functions — Python 3.7.4 documentation</title>
|
||
<link rel="stylesheet" href="../_static/pydoctheme.css" type="text/css" />
|
||
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
|
||
|
||
<script type="text/javascript" id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
|
||
<script type="text/javascript" src="../_static/jquery.js"></script>
|
||
<script type="text/javascript" src="../_static/underscore.js"></script>
|
||
<script type="text/javascript" src="../_static/doctools.js"></script>
|
||
<script type="text/javascript" src="../_static/language_data.js"></script>
|
||
|
||
<script type="text/javascript" src="../_static/sidebar.js"></script>
|
||
|
||
<link rel="search" type="application/opensearchdescription+xml"
|
||
title="Search within Python 3.7.4 documentation"
|
||
href="../_static/opensearch.xml"/>
|
||
<link rel="author" title="About these documents" href="../about.html" />
|
||
<link rel="index" title="Index" href="../genindex.html" />
|
||
<link rel="search" title="Search" href="../search.html" />
|
||
<link rel="copyright" title="Copyright" href="../copyright.html" />
|
||
<link rel="next" title="sysconfig — Provide access to Python’s configuration information" href="sysconfig.html" />
|
||
<link rel="prev" title="Python Runtime Services" href="python.html" />
|
||
<link rel="shortcut icon" type="image/png" href="../_static/py.png" />
|
||
<link rel="canonical" href="https://docs.python.org/3/library/sys.html" />
|
||
|
||
<script type="text/javascript" src="../_static/copybutton.js"></script>
|
||
<script type="text/javascript" src="../_static/switchers.js"></script>
|
||
|
||
|
||
|
||
<style>
|
||
@media only screen {
|
||
table.full-width-table {
|
||
width: 100%;
|
||
}
|
||
}
|
||
</style>
|
||
|
||
|
||
</head><body>
|
||
|
||
<div class="related" role="navigation" aria-label="related navigation">
|
||
<h3>Navigation</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="General Index"
|
||
accesskey="I">index</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python Module Index"
|
||
>modules</a> |</li>
|
||
<li class="right" >
|
||
<a href="sysconfig.html" title="sysconfig — Provide access to Python’s configuration information"
|
||
accesskey="N">next</a> |</li>
|
||
<li class="right" >
|
||
<a href="python.html" title="Python Runtime Services"
|
||
accesskey="P">previous</a> |</li>
|
||
<li><img src="../_static/py.png" alt=""
|
||
style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li>
|
||
<span class="language_switcher_placeholder">en</span>
|
||
<span class="version_switcher_placeholder">3.7.4</span>
|
||
<a href="../index.html">Documentation </a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> »</li>
|
||
<li class="nav-item nav-item-2"><a href="python.html" accesskey="U">Python Runtime Services</a> »</li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" style="display: none" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="Quick search" type="text" name="q" />
|
||
<input type="submit" value="Go" />
|
||
<input type="hidden" name="check_keywords" value="yes" />
|
||
<input type="hidden" name="area" value="default" />
|
||
</form>
|
||
</div>
|
||
<script type="text/javascript">$('.inline-search').show(0);</script>
|
||
|
|
||
</li>
|
||
|
||
</ul>
|
||
</div>
|
||
|
||
<div class="document">
|
||
<div class="documentwrapper">
|
||
<div class="bodywrapper">
|
||
<div class="body" role="main">
|
||
|
||
<div class="section" id="module-sys">
|
||
<span id="sys-system-specific-parameters-and-functions"></span><h1><a class="reference internal" href="#module-sys" title="sys: Access system-specific parameters and functions."><code class="xref py py-mod docutils literal notranslate"><span class="pre">sys</span></code></a> — System-specific parameters and functions<a class="headerlink" href="#module-sys" title="Permalink to this headline">¶</a></h1>
|
||
<hr class="docutils" />
|
||
<p>This module provides access to some variables used or maintained by the
|
||
interpreter and to functions that interact strongly with the interpreter. It is
|
||
always available.</p>
|
||
<dl class="data">
|
||
<dt id="sys.abiflags">
|
||
<code class="descclassname">sys.</code><code class="descname">abiflags</code><a class="headerlink" href="#sys.abiflags" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>On POSIX systems where Python was built with the standard <code class="docutils literal notranslate"><span class="pre">configure</span></code>
|
||
script, this contains the ABI flags as specified by <span class="target" id="index-0"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-3149"><strong>PEP 3149</strong></a>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.2.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.argv">
|
||
<code class="descclassname">sys.</code><code class="descname">argv</code><a class="headerlink" href="#sys.argv" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>The list of command line arguments passed to a Python script. <code class="docutils literal notranslate"><span class="pre">argv[0]</span></code> is the
|
||
script name (it is operating system dependent whether this is a full pathname or
|
||
not). If the command was executed using the <a class="reference internal" href="../using/cmdline.html#cmdoption-c"><code class="xref std std-option docutils literal notranslate"><span class="pre">-c</span></code></a> command line option to
|
||
the interpreter, <code class="docutils literal notranslate"><span class="pre">argv[0]</span></code> is set to the string <code class="docutils literal notranslate"><span class="pre">'-c'</span></code>. If no script name
|
||
was passed to the Python interpreter, <code class="docutils literal notranslate"><span class="pre">argv[0]</span></code> is the empty string.</p>
|
||
<p>To loop over the standard input, or the list of files given on the
|
||
command line, see the <a class="reference internal" href="fileinput.html#module-fileinput" title="fileinput: Loop over standard input or a list of files."><code class="xref py py-mod docutils literal notranslate"><span class="pre">fileinput</span></code></a> module.</p>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>On Unix, command line arguments are passed by bytes from OS. Python decodes
|
||
them with filesystem encoding and “surrogateescape” error handler.
|
||
When you need original bytes, you can get it by
|
||
<code class="docutils literal notranslate"><span class="pre">[os.fsencode(arg)</span> <span class="pre">for</span> <span class="pre">arg</span> <span class="pre">in</span> <span class="pre">sys.argv]</span></code>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.base_exec_prefix">
|
||
<code class="descclassname">sys.</code><code class="descname">base_exec_prefix</code><a class="headerlink" href="#sys.base_exec_prefix" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Set during Python startup, before <code class="docutils literal notranslate"><span class="pre">site.py</span></code> is run, to the same value as
|
||
<a class="reference internal" href="#sys.exec_prefix" title="sys.exec_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">exec_prefix</span></code></a>. If not running in a
|
||
<a class="reference internal" href="venv.html#venv-def"><span class="std std-ref">virtual environment</span></a>, the values will stay the same; if
|
||
<code class="docutils literal notranslate"><span class="pre">site.py</span></code> finds that a virtual environment is in use, the values of
|
||
<a class="reference internal" href="#sys.prefix" title="sys.prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">prefix</span></code></a> and <a class="reference internal" href="#sys.exec_prefix" title="sys.exec_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">exec_prefix</span></code></a> will be changed to point to the
|
||
virtual environment, whereas <a class="reference internal" href="#sys.base_prefix" title="sys.base_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">base_prefix</span></code></a> and
|
||
<a class="reference internal" href="#sys.base_exec_prefix" title="sys.base_exec_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">base_exec_prefix</span></code></a> will remain pointing to the base Python
|
||
installation (the one which the virtual environment was created from).</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.3.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.base_prefix">
|
||
<code class="descclassname">sys.</code><code class="descname">base_prefix</code><a class="headerlink" href="#sys.base_prefix" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Set during Python startup, before <code class="docutils literal notranslate"><span class="pre">site.py</span></code> is run, to the same value as
|
||
<a class="reference internal" href="#sys.prefix" title="sys.prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">prefix</span></code></a>. If not running in a <a class="reference internal" href="venv.html#venv-def"><span class="std std-ref">virtual environment</span></a>, the values
|
||
will stay the same; if <code class="docutils literal notranslate"><span class="pre">site.py</span></code> finds that a virtual environment is in
|
||
use, the values of <a class="reference internal" href="#sys.prefix" title="sys.prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">prefix</span></code></a> and <a class="reference internal" href="#sys.exec_prefix" title="sys.exec_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">exec_prefix</span></code></a> will be changed to
|
||
point to the virtual environment, whereas <a class="reference internal" href="#sys.base_prefix" title="sys.base_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">base_prefix</span></code></a> and
|
||
<a class="reference internal" href="#sys.base_exec_prefix" title="sys.base_exec_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">base_exec_prefix</span></code></a> will remain pointing to the base Python
|
||
installation (the one which the virtual environment was created from).</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.3.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.byteorder">
|
||
<code class="descclassname">sys.</code><code class="descname">byteorder</code><a class="headerlink" href="#sys.byteorder" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>An indicator of the native byte order. This will have the value <code class="docutils literal notranslate"><span class="pre">'big'</span></code> on
|
||
big-endian (most-significant byte first) platforms, and <code class="docutils literal notranslate"><span class="pre">'little'</span></code> on
|
||
little-endian (least-significant byte first) platforms.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.builtin_module_names">
|
||
<code class="descclassname">sys.</code><code class="descname">builtin_module_names</code><a class="headerlink" href="#sys.builtin_module_names" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A tuple of strings giving the names of all modules that are compiled into this
|
||
Python interpreter. (This information is not available in any other way —
|
||
<code class="docutils literal notranslate"><span class="pre">modules.keys()</span></code> only lists the imported modules.)</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.call_tracing">
|
||
<code class="descclassname">sys.</code><code class="descname">call_tracing</code><span class="sig-paren">(</span><em>func</em>, <em>args</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.call_tracing" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Call <code class="docutils literal notranslate"><span class="pre">func(*args)</span></code>, while tracing is enabled. The tracing state is saved,
|
||
and restored afterwards. This is intended to be called from a debugger from
|
||
a checkpoint, to recursively debug some other code.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.copyright">
|
||
<code class="descclassname">sys.</code><code class="descname">copyright</code><a class="headerlink" href="#sys.copyright" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A string containing the copyright pertaining to the Python interpreter.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys._clear_type_cache">
|
||
<code class="descclassname">sys.</code><code class="descname">_clear_type_cache</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys._clear_type_cache" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Clear the internal type cache. The type cache is used to speed up attribute
|
||
and method lookups. Use the function <em>only</em> to drop unnecessary references
|
||
during reference leak debugging.</p>
|
||
<p>This function should be used for internal and specialized purposes only.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys._current_frames">
|
||
<code class="descclassname">sys.</code><code class="descname">_current_frames</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys._current_frames" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return a dictionary mapping each thread’s identifier to the topmost stack frame
|
||
currently active in that thread at the time the function is called. Note that
|
||
functions in the <a class="reference internal" href="traceback.html#module-traceback" title="traceback: Print or retrieve a stack traceback."><code class="xref py py-mod docutils literal notranslate"><span class="pre">traceback</span></code></a> module can build the call stack given such a
|
||
frame.</p>
|
||
<p>This is most useful for debugging deadlock: this function does not require the
|
||
deadlocked threads’ cooperation, and such threads’ call stacks are frozen for as
|
||
long as they remain deadlocked. The frame returned for a non-deadlocked thread
|
||
may bear no relationship to that thread’s current activity by the time calling
|
||
code examines the frame.</p>
|
||
<p>This function should be used for internal and specialized purposes only.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.breakpointhook">
|
||
<code class="descclassname">sys.</code><code class="descname">breakpointhook</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.breakpointhook" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>This hook function is called by built-in <a class="reference internal" href="functions.html#breakpoint" title="breakpoint"><code class="xref py py-func docutils literal notranslate"><span class="pre">breakpoint()</span></code></a>. By default,
|
||
it drops you into the <a class="reference internal" href="pdb.html#module-pdb" title="pdb: The Python debugger for interactive interpreters."><code class="xref py py-mod docutils literal notranslate"><span class="pre">pdb</span></code></a> debugger, but it can be set to any other
|
||
function so that you can choose which debugger gets used.</p>
|
||
<p>The signature of this function is dependent on what it calls. For example,
|
||
the default binding (e.g. <code class="docutils literal notranslate"><span class="pre">pdb.set_trace()</span></code>) expects no arguments, but
|
||
you might bind it to a function that expects additional arguments
|
||
(positional and/or keyword). The built-in <code class="docutils literal notranslate"><span class="pre">breakpoint()</span></code> function passes
|
||
its <code class="docutils literal notranslate"><span class="pre">*args</span></code> and <code class="docutils literal notranslate"><span class="pre">**kws</span></code> straight through. Whatever
|
||
<code class="docutils literal notranslate"><span class="pre">breakpointhooks()</span></code> returns is returned from <code class="docutils literal notranslate"><span class="pre">breakpoint()</span></code>.</p>
|
||
<p>The default implementation first consults the environment variable
|
||
<span class="target" id="index-1"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONBREAKPOINT"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONBREAKPOINT</span></code></a>. If that is set to <code class="docutils literal notranslate"><span class="pre">"0"</span></code> then this function
|
||
returns immediately; i.e. it is a no-op. If the environment variable is
|
||
not set, or is set to the empty string, <code class="docutils literal notranslate"><span class="pre">pdb.set_trace()</span></code> is called.
|
||
Otherwise this variable should name a function to run, using Python’s
|
||
dotted-import nomenclature, e.g. <code class="docutils literal notranslate"><span class="pre">package.subpackage.module.function</span></code>.
|
||
In this case, <code class="docutils literal notranslate"><span class="pre">package.subpackage.module</span></code> would be imported and the
|
||
resulting module must have a callable named <code class="docutils literal notranslate"><span class="pre">function()</span></code>. This is run,
|
||
passing in <code class="docutils literal notranslate"><span class="pre">*args</span></code> and <code class="docutils literal notranslate"><span class="pre">**kws</span></code>, and whatever <code class="docutils literal notranslate"><span class="pre">function()</span></code> returns,
|
||
<code class="docutils literal notranslate"><span class="pre">sys.breakpointhook()</span></code> returns to the built-in <a class="reference internal" href="functions.html#breakpoint" title="breakpoint"><code class="xref py py-func docutils literal notranslate"><span class="pre">breakpoint()</span></code></a>
|
||
function.</p>
|
||
<p>Note that if anything goes wrong while importing the callable named by
|
||
<span class="target" id="index-2"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONBREAKPOINT"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONBREAKPOINT</span></code></a>, a <a class="reference internal" href="exceptions.html#RuntimeWarning" title="RuntimeWarning"><code class="xref py py-exc docutils literal notranslate"><span class="pre">RuntimeWarning</span></code></a> is reported and the
|
||
breakpoint is ignored.</p>
|
||
<p>Also note that if <code class="docutils literal notranslate"><span class="pre">sys.breakpointhook()</span></code> is overridden programmatically,
|
||
<span class="target" id="index-3"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONBREAKPOINT"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONBREAKPOINT</span></code></a> is <em>not</em> consulted.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.7.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys._debugmallocstats">
|
||
<code class="descclassname">sys.</code><code class="descname">_debugmallocstats</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys._debugmallocstats" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Print low-level information to stderr about the state of CPython’s memory
|
||
allocator.</p>
|
||
<p>If Python is configured –with-pydebug, it also performs some expensive
|
||
internal consistency checks.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.3.</span></p>
|
||
</div>
|
||
<div class="impl-detail compound">
|
||
<p><strong>CPython implementation detail:</strong> This function is specific to CPython. The exact output format is not
|
||
defined here, and may change.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.dllhandle">
|
||
<code class="descclassname">sys.</code><code class="descname">dllhandle</code><a class="headerlink" href="#sys.dllhandle" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Integer specifying the handle of the Python DLL.</p>
|
||
<p class="availability"><a class="reference internal" href="intro.html#availability"><span class="std std-ref">Availability</span></a>: Windows.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.displayhook">
|
||
<code class="descclassname">sys.</code><code class="descname">displayhook</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.displayhook" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>If <em>value</em> is not <code class="docutils literal notranslate"><span class="pre">None</span></code>, this function prints <code class="docutils literal notranslate"><span class="pre">repr(value)</span></code> to
|
||
<code class="docutils literal notranslate"><span class="pre">sys.stdout</span></code>, and saves <em>value</em> in <code class="docutils literal notranslate"><span class="pre">builtins._</span></code>. If <code class="docutils literal notranslate"><span class="pre">repr(value)</span></code> is
|
||
not encodable to <code class="docutils literal notranslate"><span class="pre">sys.stdout.encoding</span></code> with <code class="docutils literal notranslate"><span class="pre">sys.stdout.errors</span></code> error
|
||
handler (which is probably <code class="docutils literal notranslate"><span class="pre">'strict'</span></code>), encode it to
|
||
<code class="docutils literal notranslate"><span class="pre">sys.stdout.encoding</span></code> with <code class="docutils literal notranslate"><span class="pre">'backslashreplace'</span></code> error handler.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">sys.displayhook</span></code> is called on the result of evaluating an <a class="reference internal" href="../glossary.html#term-expression"><span class="xref std std-term">expression</span></a>
|
||
entered in an interactive Python session. The display of these values can be
|
||
customized by assigning another one-argument function to <code class="docutils literal notranslate"><span class="pre">sys.displayhook</span></code>.</p>
|
||
<p>Pseudo-code:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">displayhook</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>
|
||
<span class="k">if</span> <span class="n">value</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
|
||
<span class="k">return</span>
|
||
<span class="c1"># Set '_' to None to avoid recursion</span>
|
||
<span class="n">builtins</span><span class="o">.</span><span class="n">_</span> <span class="o">=</span> <span class="kc">None</span>
|
||
<span class="n">text</span> <span class="o">=</span> <span class="nb">repr</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
|
||
<span class="k">try</span><span class="p">:</span>
|
||
<span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
|
||
<span class="k">except</span> <span class="ne">UnicodeEncodeError</span><span class="p">:</span>
|
||
<span class="nb">bytes</span> <span class="o">=</span> <span class="n">text</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">encoding</span><span class="p">,</span> <span class="s1">'backslashreplace'</span><span class="p">)</span>
|
||
<span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="p">,</span> <span class="s1">'buffer'</span><span class="p">):</span>
|
||
<span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">buffer</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">bytes</span><span class="p">)</span>
|
||
<span class="k">else</span><span class="p">:</span>
|
||
<span class="n">text</span> <span class="o">=</span> <span class="nb">bytes</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">encoding</span><span class="p">,</span> <span class="s1">'strict'</span><span class="p">)</span>
|
||
<span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
|
||
<span class="n">sys</span><span class="o">.</span><span class="n">stdout</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
|
||
<span class="n">builtins</span><span class="o">.</span><span class="n">_</span> <span class="o">=</span> <span class="n">value</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.2: </span>Use <code class="docutils literal notranslate"><span class="pre">'backslashreplace'</span></code> error handler on <a class="reference internal" href="exceptions.html#UnicodeEncodeError" title="UnicodeEncodeError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">UnicodeEncodeError</span></code></a>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.dont_write_bytecode">
|
||
<code class="descclassname">sys.</code><code class="descname">dont_write_bytecode</code><a class="headerlink" href="#sys.dont_write_bytecode" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>If this is true, Python won’t try to write <code class="docutils literal notranslate"><span class="pre">.pyc</span></code> files on the
|
||
import of source modules. This value is initially set to <code class="docutils literal notranslate"><span class="pre">True</span></code> or
|
||
<code class="docutils literal notranslate"><span class="pre">False</span></code> depending on the <a class="reference internal" href="../using/cmdline.html#id1"><code class="xref std std-option docutils literal notranslate"><span class="pre">-B</span></code></a> command line option and the
|
||
<span class="target" id="index-4"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONDONTWRITEBYTECODE"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONDONTWRITEBYTECODE</span></code></a> environment variable, but you can set it
|
||
yourself to control bytecode file generation.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.excepthook">
|
||
<code class="descclassname">sys.</code><code class="descname">excepthook</code><span class="sig-paren">(</span><em>type</em>, <em>value</em>, <em>traceback</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.excepthook" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>This function prints out a given traceback and exception to <code class="docutils literal notranslate"><span class="pre">sys.stderr</span></code>.</p>
|
||
<p>When an exception is raised and uncaught, the interpreter calls
|
||
<code class="docutils literal notranslate"><span class="pre">sys.excepthook</span></code> with three arguments, the exception class, exception
|
||
instance, and a traceback object. In an interactive session this happens just
|
||
before control is returned to the prompt; in a Python program this happens just
|
||
before the program exits. The handling of such top-level exceptions can be
|
||
customized by assigning another three-argument function to <code class="docutils literal notranslate"><span class="pre">sys.excepthook</span></code>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.__breakpointhook__">
|
||
<code class="descclassname">sys.</code><code class="descname">__breakpointhook__</code><a class="headerlink" href="#sys.__breakpointhook__" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.__displayhook__">
|
||
<code class="descclassname">sys.</code><code class="descname">__displayhook__</code><a class="headerlink" href="#sys.__displayhook__" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.__excepthook__">
|
||
<code class="descclassname">sys.</code><code class="descname">__excepthook__</code><a class="headerlink" href="#sys.__excepthook__" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>These objects contain the original values of <code class="docutils literal notranslate"><span class="pre">breakpointhook</span></code>,
|
||
<code class="docutils literal notranslate"><span class="pre">displayhook</span></code>, and <code class="docutils literal notranslate"><span class="pre">excepthook</span></code> at the start of the program. They are
|
||
saved so that <code class="docutils literal notranslate"><span class="pre">breakpointhook</span></code>, <code class="docutils literal notranslate"><span class="pre">displayhook</span></code> and <code class="docutils literal notranslate"><span class="pre">excepthook</span></code> can be
|
||
restored in case they happen to get replaced with broken or alternative
|
||
objects.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.7: </span>__breakpointhook__</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.exc_info">
|
||
<code class="descclassname">sys.</code><code class="descname">exc_info</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.exc_info" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>This function returns a tuple of three values that give information about the
|
||
exception that is currently being handled. The information returned is specific
|
||
both to the current thread and to the current stack frame. If the current stack
|
||
frame is not handling an exception, the information is taken from the calling
|
||
stack frame, or its caller, and so on until a stack frame is found that is
|
||
handling an exception. Here, “handling an exception” is defined as “executing
|
||
an except clause.” For any stack frame, only information about the exception
|
||
being currently handled is accessible.</p>
|
||
<p id="index-5">If no exception is being handled anywhere on the stack, a tuple containing
|
||
three <code class="docutils literal notranslate"><span class="pre">None</span></code> values is returned. Otherwise, the values returned are
|
||
<code class="docutils literal notranslate"><span class="pre">(type,</span> <span class="pre">value,</span> <span class="pre">traceback)</span></code>. Their meaning is: <em>type</em> gets the type of the
|
||
exception being handled (a subclass of <a class="reference internal" href="exceptions.html#BaseException" title="BaseException"><code class="xref py py-exc docutils literal notranslate"><span class="pre">BaseException</span></code></a>); <em>value</em> gets
|
||
the exception instance (an instance of the exception type); <em>traceback</em> gets
|
||
a traceback object (see the Reference Manual) which encapsulates the call
|
||
stack at the point where the exception originally occurred.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.exec_prefix">
|
||
<code class="descclassname">sys.</code><code class="descname">exec_prefix</code><a class="headerlink" href="#sys.exec_prefix" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A string giving the site-specific directory prefix where the platform-dependent
|
||
Python files are installed; by default, this is also <code class="docutils literal notranslate"><span class="pre">'/usr/local'</span></code>. This can
|
||
be set at build time with the <code class="docutils literal notranslate"><span class="pre">--exec-prefix</span></code> argument to the
|
||
<strong class="program">configure</strong> script. Specifically, all configuration files (e.g. the
|
||
<code class="file docutils literal notranslate"><span class="pre">pyconfig.h</span></code> header file) are installed in the directory
|
||
<code class="file docutils literal notranslate"><em><span class="pre">exec_prefix</span></em><span class="pre">/lib/python</span><em><span class="pre">X.Y</span></em><span class="pre">/config</span></code>, and shared library modules are
|
||
installed in <code class="file docutils literal notranslate"><em><span class="pre">exec_prefix</span></em><span class="pre">/lib/python</span><em><span class="pre">X.Y</span></em><span class="pre">/lib-dynload</span></code>, where <em>X.Y</em>
|
||
is the version number of Python, for example <code class="docutils literal notranslate"><span class="pre">3.2</span></code>.</p>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>If a <a class="reference internal" href="venv.html#venv-def"><span class="std std-ref">virtual environment</span></a> is in effect, this
|
||
value will be changed in <code class="docutils literal notranslate"><span class="pre">site.py</span></code> to point to the virtual environment.
|
||
The value for the Python installation will still be available, via
|
||
<a class="reference internal" href="#sys.base_exec_prefix" title="sys.base_exec_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">base_exec_prefix</span></code></a>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.executable">
|
||
<code class="descclassname">sys.</code><code class="descname">executable</code><a class="headerlink" href="#sys.executable" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A string giving the absolute path of the executable binary for the Python
|
||
interpreter, on systems where this makes sense. If Python is unable to retrieve
|
||
the real path to its executable, <a class="reference internal" href="#sys.executable" title="sys.executable"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.executable</span></code></a> will be an empty string
|
||
or <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.exit">
|
||
<code class="descclassname">sys.</code><code class="descname">exit</code><span class="sig-paren">(</span><span class="optional">[</span><em>arg</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.exit" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Exit from Python. This is implemented by raising the <a class="reference internal" href="exceptions.html#SystemExit" title="SystemExit"><code class="xref py py-exc docutils literal notranslate"><span class="pre">SystemExit</span></code></a>
|
||
exception, so cleanup actions specified by finally clauses of <a class="reference internal" href="../reference/compound_stmts.html#try"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">try</span></code></a>
|
||
statements are honored, and it is possible to intercept the exit attempt at
|
||
an outer level.</p>
|
||
<p>The optional argument <em>arg</em> can be an integer giving the exit status
|
||
(defaulting to zero), or another type of object. If it is an integer, zero
|
||
is considered “successful termination” and any nonzero value is considered
|
||
“abnormal termination” by shells and the like. Most systems require it to be
|
||
in the range 0–127, and produce undefined results otherwise. Some systems
|
||
have a convention for assigning specific meanings to specific exit codes, but
|
||
these are generally underdeveloped; Unix programs generally use 2 for command
|
||
line syntax errors and 1 for all other kind of errors. If another type of
|
||
object is passed, <code class="docutils literal notranslate"><span class="pre">None</span></code> is equivalent to passing zero, and any other
|
||
object is printed to <a class="reference internal" href="#sys.stderr" title="sys.stderr"><code class="xref py py-data docutils literal notranslate"><span class="pre">stderr</span></code></a> and results in an exit code of 1. In
|
||
particular, <code class="docutils literal notranslate"><span class="pre">sys.exit("some</span> <span class="pre">error</span> <span class="pre">message")</span></code> is a quick way to exit a
|
||
program when an error occurs.</p>
|
||
<p>Since <a class="reference internal" href="constants.html#exit" title="exit"><code class="xref py py-func docutils literal notranslate"><span class="pre">exit()</span></code></a> ultimately “only” raises an exception, it will only exit
|
||
the process when called from the main thread, and the exception is not
|
||
intercepted.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.6: </span>If an error occurs in the cleanup after the Python interpreter
|
||
has caught <a class="reference internal" href="exceptions.html#SystemExit" title="SystemExit"><code class="xref py py-exc docutils literal notranslate"><span class="pre">SystemExit</span></code></a> (such as an error flushing buffered data
|
||
in the standard streams), the exit status is changed to 120.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.flags">
|
||
<code class="descclassname">sys.</code><code class="descname">flags</code><a class="headerlink" href="#sys.flags" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>The <a class="reference internal" href="../glossary.html#term-struct-sequence"><span class="xref std std-term">struct sequence</span></a> <em>flags</em> exposes the status of command line
|
||
flags. The attributes are read only.</p>
|
||
<table class="docutils align-center">
|
||
<colgroup>
|
||
<col style="width: 50%" />
|
||
<col style="width: 50%" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>attribute</p></th>
|
||
<th class="head"><p>flag</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">debug</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-d"><code class="xref std std-option docutils literal notranslate"><span class="pre">-d</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><a class="reference internal" href="inspect.html#module-inspect" title="inspect: Extract information and source code from live objects."><code class="xref py py-const docutils literal notranslate"><span class="pre">inspect</span></code></a></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-i"><code class="xref std std-option docutils literal notranslate"><span class="pre">-i</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">interactive</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-i"><code class="xref std std-option docutils literal notranslate"><span class="pre">-i</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">isolated</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#id2"><code class="xref std std-option docutils literal notranslate"><span class="pre">-I</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">optimize</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-o"><code class="xref std std-option docutils literal notranslate"><span class="pre">-O</span></code></a> or <a class="reference internal" href="../using/cmdline.html#cmdoption-oo"><code class="xref std std-option docutils literal notranslate"><span class="pre">-OO</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><a class="reference internal" href="#sys.dont_write_bytecode" title="sys.dont_write_bytecode"><code class="xref py py-const docutils literal notranslate"><span class="pre">dont_write_bytecode</span></code></a></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#id1"><code class="xref std std-option docutils literal notranslate"><span class="pre">-B</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">no_user_site</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-s"><code class="xref std std-option docutils literal notranslate"><span class="pre">-s</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">no_site</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#id3"><code class="xref std std-option docutils literal notranslate"><span class="pre">-S</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">ignore_environment</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-e"><code class="xref std std-option docutils literal notranslate"><span class="pre">-E</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">verbose</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#id4"><code class="xref std std-option docutils literal notranslate"><span class="pre">-v</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">bytes_warning</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-b"><code class="xref std std-option docutils literal notranslate"><span class="pre">-b</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">quiet</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-q"><code class="xref std std-option docutils literal notranslate"><span class="pre">-q</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">hash_randomization</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#cmdoption-r"><code class="xref std std-option docutils literal notranslate"><span class="pre">-R</span></code></a></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">dev_mode</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#id5"><code class="xref std std-option docutils literal notranslate"><span class="pre">-X</span></code></a> <code class="docutils literal notranslate"><span class="pre">dev</span></code></p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">utf8_mode</span></code></p></td>
|
||
<td><p><a class="reference internal" href="../using/cmdline.html#id5"><code class="xref std std-option docutils literal notranslate"><span class="pre">-X</span></code></a> <code class="docutils literal notranslate"><span class="pre">utf8</span></code></p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.2: </span>Added <code class="docutils literal notranslate"><span class="pre">quiet</span></code> attribute for the new <a class="reference internal" href="../using/cmdline.html#cmdoption-q"><code class="xref std std-option docutils literal notranslate"><span class="pre">-q</span></code></a> flag.</p>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.2.3: </span>The <code class="docutils literal notranslate"><span class="pre">hash_randomization</span></code> attribute.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.3: </span>Removed obsolete <code class="docutils literal notranslate"><span class="pre">division_warning</span></code> attribute.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.4: </span>Added <code class="docutils literal notranslate"><span class="pre">isolated</span></code> attribute for <a class="reference internal" href="../using/cmdline.html#id2"><code class="xref std std-option docutils literal notranslate"><span class="pre">-I</span></code></a> <code class="docutils literal notranslate"><span class="pre">isolated</span></code> flag.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.7: </span>Added <code class="docutils literal notranslate"><span class="pre">dev_mode</span></code> attribute for the new <a class="reference internal" href="../using/cmdline.html#id5"><code class="xref std std-option docutils literal notranslate"><span class="pre">-X</span></code></a> <code class="docutils literal notranslate"><span class="pre">dev</span></code> flag
|
||
and <code class="docutils literal notranslate"><span class="pre">utf8_mode</span></code> attribute for the new <a class="reference internal" href="../using/cmdline.html#id5"><code class="xref std std-option docutils literal notranslate"><span class="pre">-X</span></code></a> <code class="docutils literal notranslate"><span class="pre">utf8</span></code> flag.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.float_info">
|
||
<code class="descclassname">sys.</code><code class="descname">float_info</code><a class="headerlink" href="#sys.float_info" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="../glossary.html#term-struct-sequence"><span class="xref std std-term">struct sequence</span></a> holding information about the float type. It
|
||
contains low level information about the precision and internal
|
||
representation. The values correspond to the various floating-point
|
||
constants defined in the standard header file <code class="file docutils literal notranslate"><span class="pre">float.h</span></code> for the ‘C’
|
||
programming language; see section 5.2.4.2.2 of the 1999 ISO/IEC C standard
|
||
<a class="reference internal" href="#c99" id="id1"><span>[C99]</span></a>, ‘Characteristics of floating types’, for details.</p>
|
||
<table class="docutils align-center">
|
||
<colgroup>
|
||
<col style="width: 24%" />
|
||
<col style="width: 18%" />
|
||
<col style="width: 57%" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>attribute</p></th>
|
||
<th class="head"><p>float.h macro</p></th>
|
||
<th class="head"><p>explanation</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">epsilon</span></code></p></td>
|
||
<td><p>DBL_EPSILON</p></td>
|
||
<td><p>difference between 1 and the least value greater
|
||
than 1 that is representable as a float</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">dig</span></code></p></td>
|
||
<td><p>DBL_DIG</p></td>
|
||
<td><p>maximum number of decimal digits that can be
|
||
faithfully represented in a float; see below</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">mant_dig</span></code></p></td>
|
||
<td><p>DBL_MANT_DIG</p></td>
|
||
<td><p>float precision: the number of base-<code class="docutils literal notranslate"><span class="pre">radix</span></code>
|
||
digits in the significand of a float</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><a class="reference internal" href="functions.html#max" title="max"><code class="xref py py-const docutils literal notranslate"><span class="pre">max</span></code></a></p></td>
|
||
<td><p>DBL_MAX</p></td>
|
||
<td><p>maximum representable finite float</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">max_exp</span></code></p></td>
|
||
<td><p>DBL_MAX_EXP</p></td>
|
||
<td><p>maximum integer e such that <code class="docutils literal notranslate"><span class="pre">radix**(e-1)</span></code> is
|
||
a representable finite float</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">max_10_exp</span></code></p></td>
|
||
<td><p>DBL_MAX_10_EXP</p></td>
|
||
<td><p>maximum integer e such that <code class="docutils literal notranslate"><span class="pre">10**e</span></code> is in the
|
||
range of representable finite floats</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><a class="reference internal" href="functions.html#min" title="min"><code class="xref py py-const docutils literal notranslate"><span class="pre">min</span></code></a></p></td>
|
||
<td><p>DBL_MIN</p></td>
|
||
<td><p>minimum positive normalized float</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">min_exp</span></code></p></td>
|
||
<td><p>DBL_MIN_EXP</p></td>
|
||
<td><p>minimum integer e such that <code class="docutils literal notranslate"><span class="pre">radix**(e-1)</span></code> is
|
||
a normalized float</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">min_10_exp</span></code></p></td>
|
||
<td><p>DBL_MIN_10_EXP</p></td>
|
||
<td><p>minimum integer e such that <code class="docutils literal notranslate"><span class="pre">10**e</span></code> is a
|
||
normalized float</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">radix</span></code></p></td>
|
||
<td><p>FLT_RADIX</p></td>
|
||
<td><p>radix of exponent representation</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">rounds</span></code></p></td>
|
||
<td><p>FLT_ROUNDS</p></td>
|
||
<td><p>integer constant representing the rounding mode
|
||
used for arithmetic operations. This reflects
|
||
the value of the system FLT_ROUNDS macro at
|
||
interpreter startup time. See section 5.2.4.2.2
|
||
of the C99 standard for an explanation of the
|
||
possible values and their meanings.</p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<p>The attribute <code class="xref py py-attr docutils literal notranslate"><span class="pre">sys.float_info.dig</span></code> needs further explanation. If
|
||
<code class="docutils literal notranslate"><span class="pre">s</span></code> is any string representing a decimal number with at most
|
||
<code class="xref py py-attr docutils literal notranslate"><span class="pre">sys.float_info.dig</span></code> significant digits, then converting <code class="docutils literal notranslate"><span class="pre">s</span></code> to a
|
||
float and back again will recover a string representing the same decimal
|
||
value:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">sys</span>
|
||
<span class="gp">>>> </span><span class="n">sys</span><span class="o">.</span><span class="n">float_info</span><span class="o">.</span><span class="n">dig</span>
|
||
<span class="go">15</span>
|
||
<span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="s1">'3.14159265358979'</span> <span class="c1"># decimal string with 15 significant digits</span>
|
||
<span class="gp">>>> </span><span class="nb">format</span><span class="p">(</span><span class="nb">float</span><span class="p">(</span><span class="n">s</span><span class="p">),</span> <span class="s1">'.15g'</span><span class="p">)</span> <span class="c1"># convert to float and back -> same value</span>
|
||
<span class="go">'3.14159265358979'</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>But for strings with more than <code class="xref py py-attr docutils literal notranslate"><span class="pre">sys.float_info.dig</span></code> significant digits,
|
||
this isn’t always true:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="s1">'9876543211234567'</span> <span class="c1"># 16 significant digits is too many!</span>
|
||
<span class="gp">>>> </span><span class="nb">format</span><span class="p">(</span><span class="nb">float</span><span class="p">(</span><span class="n">s</span><span class="p">),</span> <span class="s1">'.16g'</span><span class="p">)</span> <span class="c1"># conversion changes value</span>
|
||
<span class="go">'9876543211234568'</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.float_repr_style">
|
||
<code class="descclassname">sys.</code><code class="descname">float_repr_style</code><a class="headerlink" href="#sys.float_repr_style" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A string indicating how the <a class="reference internal" href="functions.html#repr" title="repr"><code class="xref py py-func docutils literal notranslate"><span class="pre">repr()</span></code></a> function behaves for
|
||
floats. If the string has value <code class="docutils literal notranslate"><span class="pre">'short'</span></code> then for a finite
|
||
float <code class="docutils literal notranslate"><span class="pre">x</span></code>, <code class="docutils literal notranslate"><span class="pre">repr(x)</span></code> aims to produce a short string with the
|
||
property that <code class="docutils literal notranslate"><span class="pre">float(repr(x))</span> <span class="pre">==</span> <span class="pre">x</span></code>. This is the usual behaviour
|
||
in Python 3.1 and later. Otherwise, <code class="docutils literal notranslate"><span class="pre">float_repr_style</span></code> has value
|
||
<code class="docutils literal notranslate"><span class="pre">'legacy'</span></code> and <code class="docutils literal notranslate"><span class="pre">repr(x)</span></code> behaves in the same way as it did in
|
||
versions of Python prior to 3.1.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.1.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getallocatedblocks">
|
||
<code class="descclassname">sys.</code><code class="descname">getallocatedblocks</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getallocatedblocks" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the number of memory blocks currently allocated by the interpreter,
|
||
regardless of their size. This function is mainly useful for tracking
|
||
and debugging memory leaks. Because of the interpreter’s internal
|
||
caches, the result can vary from call to call; you may have to call
|
||
<a class="reference internal" href="#sys._clear_type_cache" title="sys._clear_type_cache"><code class="xref py py-func docutils literal notranslate"><span class="pre">_clear_type_cache()</span></code></a> and <a class="reference internal" href="gc.html#gc.collect" title="gc.collect"><code class="xref py py-func docutils literal notranslate"><span class="pre">gc.collect()</span></code></a> to get more
|
||
predictable results.</p>
|
||
<p>If a Python build or implementation cannot reasonably compute this
|
||
information, <a class="reference internal" href="#sys.getallocatedblocks" title="sys.getallocatedblocks"><code class="xref py py-func docutils literal notranslate"><span class="pre">getallocatedblocks()</span></code></a> is allowed to return 0 instead.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.4.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getandroidapilevel">
|
||
<code class="descclassname">sys.</code><code class="descname">getandroidapilevel</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getandroidapilevel" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the build time API version of Android as an integer.</p>
|
||
<p class="availability"><a class="reference internal" href="intro.html#availability"><span class="std std-ref">Availability</span></a>: Android.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.7.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getcheckinterval">
|
||
<code class="descclassname">sys.</code><code class="descname">getcheckinterval</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getcheckinterval" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the interpreter’s “check interval”; see <a class="reference internal" href="#sys.setcheckinterval" title="sys.setcheckinterval"><code class="xref py py-func docutils literal notranslate"><span class="pre">setcheckinterval()</span></code></a>.</p>
|
||
<div class="deprecated">
|
||
<p><span class="versionmodified deprecated">Deprecated since version 3.2: </span>Use <a class="reference internal" href="#sys.getswitchinterval" title="sys.getswitchinterval"><code class="xref py py-func docutils literal notranslate"><span class="pre">getswitchinterval()</span></code></a> instead.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getdefaultencoding">
|
||
<code class="descclassname">sys.</code><code class="descname">getdefaultencoding</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getdefaultencoding" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the name of the current default string encoding used by the Unicode
|
||
implementation.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getdlopenflags">
|
||
<code class="descclassname">sys.</code><code class="descname">getdlopenflags</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getdlopenflags" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the current value of the flags that are used for
|
||
<code class="xref c c-func docutils literal notranslate"><span class="pre">dlopen()</span></code> calls. Symbolic names for the flag values can be
|
||
found in the <a class="reference internal" href="os.html#module-os" title="os: Miscellaneous operating system interfaces."><code class="xref py py-mod docutils literal notranslate"><span class="pre">os</span></code></a> module (<code class="docutils literal notranslate"><span class="pre">RTLD_xxx</span></code> constants, e.g.
|
||
<a class="reference internal" href="os.html#os.RTLD_LAZY" title="os.RTLD_LAZY"><code class="xref py py-data docutils literal notranslate"><span class="pre">os.RTLD_LAZY</span></code></a>).</p>
|
||
<p class="availability"><a class="reference internal" href="intro.html#availability"><span class="std std-ref">Availability</span></a>: Unix.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getfilesystemencoding">
|
||
<code class="descclassname">sys.</code><code class="descname">getfilesystemencoding</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getfilesystemencoding" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the name of the encoding used to convert between Unicode
|
||
filenames and bytes filenames. For best compatibility, str should be
|
||
used for filenames in all cases, although representing filenames as bytes
|
||
is also supported. Functions accepting or returning filenames should support
|
||
either str or bytes and internally convert to the system’s preferred
|
||
representation.</p>
|
||
<p>This encoding is always ASCII-compatible.</p>
|
||
<p><a class="reference internal" href="os.html#os.fsencode" title="os.fsencode"><code class="xref py py-func docutils literal notranslate"><span class="pre">os.fsencode()</span></code></a> and <a class="reference internal" href="os.html#os.fsdecode" title="os.fsdecode"><code class="xref py py-func docutils literal notranslate"><span class="pre">os.fsdecode()</span></code></a> should be used to ensure that
|
||
the correct encoding and errors mode are used.</p>
|
||
<ul class="simple">
|
||
<li><p>In the UTF-8 mode, the encoding is <code class="docutils literal notranslate"><span class="pre">utf-8</span></code> on any platform.</p></li>
|
||
<li><p>On Mac OS X, the encoding is <code class="docutils literal notranslate"><span class="pre">'utf-8'</span></code>.</p></li>
|
||
<li><p>On Unix, the encoding is the locale encoding.</p></li>
|
||
<li><p>On Windows, the encoding may be <code class="docutils literal notranslate"><span class="pre">'utf-8'</span></code> or <code class="docutils literal notranslate"><span class="pre">'mbcs'</span></code>, depending
|
||
on user configuration.</p></li>
|
||
</ul>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.2: </span><a class="reference internal" href="#sys.getfilesystemencoding" title="sys.getfilesystemencoding"><code class="xref py py-func docutils literal notranslate"><span class="pre">getfilesystemencoding()</span></code></a> result cannot be <code class="docutils literal notranslate"><span class="pre">None</span></code> anymore.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.6: </span>Windows is no longer guaranteed to return <code class="docutils literal notranslate"><span class="pre">'mbcs'</span></code>. See <span class="target" id="index-6"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0529"><strong>PEP 529</strong></a>
|
||
and <a class="reference internal" href="#sys._enablelegacywindowsfsencoding" title="sys._enablelegacywindowsfsencoding"><code class="xref py py-func docutils literal notranslate"><span class="pre">_enablelegacywindowsfsencoding()</span></code></a> for more information.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.7: </span>Return ‘utf-8’ in the UTF-8 mode.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getfilesystemencodeerrors">
|
||
<code class="descclassname">sys.</code><code class="descname">getfilesystemencodeerrors</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getfilesystemencodeerrors" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the name of the error mode used to convert between Unicode filenames
|
||
and bytes filenames. The encoding name is returned from
|
||
<a class="reference internal" href="#sys.getfilesystemencoding" title="sys.getfilesystemencoding"><code class="xref py py-func docutils literal notranslate"><span class="pre">getfilesystemencoding()</span></code></a>.</p>
|
||
<p><a class="reference internal" href="os.html#os.fsencode" title="os.fsencode"><code class="xref py py-func docutils literal notranslate"><span class="pre">os.fsencode()</span></code></a> and <a class="reference internal" href="os.html#os.fsdecode" title="os.fsdecode"><code class="xref py py-func docutils literal notranslate"><span class="pre">os.fsdecode()</span></code></a> should be used to ensure that
|
||
the correct encoding and errors mode are used.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.6.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getrefcount">
|
||
<code class="descclassname">sys.</code><code class="descname">getrefcount</code><span class="sig-paren">(</span><em>object</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.getrefcount" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the reference count of the <em>object</em>. The count returned is generally one
|
||
higher than you might expect, because it includes the (temporary) reference as
|
||
an argument to <a class="reference internal" href="#sys.getrefcount" title="sys.getrefcount"><code class="xref py py-func docutils literal notranslate"><span class="pre">getrefcount()</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getrecursionlimit">
|
||
<code class="descclassname">sys.</code><code class="descname">getrecursionlimit</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getrecursionlimit" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the current value of the recursion limit, the maximum depth of the Python
|
||
interpreter stack. This limit prevents infinite recursion from causing an
|
||
overflow of the C stack and crashing Python. It can be set by
|
||
<a class="reference internal" href="#sys.setrecursionlimit" title="sys.setrecursionlimit"><code class="xref py py-func docutils literal notranslate"><span class="pre">setrecursionlimit()</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getsizeof">
|
||
<code class="descclassname">sys.</code><code class="descname">getsizeof</code><span class="sig-paren">(</span><em>object</em><span class="optional">[</span>, <em>default</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getsizeof" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the size of an object in bytes. The object can be any type of
|
||
object. All built-in objects will return correct results, but this
|
||
does not have to hold true for third-party extensions as it is implementation
|
||
specific.</p>
|
||
<p>Only the memory consumption directly attributed to the object is
|
||
accounted for, not the memory consumption of objects it refers to.</p>
|
||
<p>If given, <em>default</em> will be returned if the object does not provide means to
|
||
retrieve the size. Otherwise a <a class="reference internal" href="exceptions.html#TypeError" title="TypeError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">TypeError</span></code></a> will be raised.</p>
|
||
<p><a class="reference internal" href="#sys.getsizeof" title="sys.getsizeof"><code class="xref py py-func docutils literal notranslate"><span class="pre">getsizeof()</span></code></a> calls the object’s <code class="docutils literal notranslate"><span class="pre">__sizeof__</span></code> method and adds an
|
||
additional garbage collector overhead if the object is managed by the garbage
|
||
collector.</p>
|
||
<p>See <a class="reference external" href="https://code.activestate.com/recipes/577504">recursive sizeof recipe</a>
|
||
for an example of using <a class="reference internal" href="#sys.getsizeof" title="sys.getsizeof"><code class="xref py py-func docutils literal notranslate"><span class="pre">getsizeof()</span></code></a> recursively to find the size of
|
||
containers and all their contents.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getswitchinterval">
|
||
<code class="descclassname">sys.</code><code class="descname">getswitchinterval</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getswitchinterval" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return the interpreter’s “thread switch interval”; see
|
||
<a class="reference internal" href="#sys.setswitchinterval" title="sys.setswitchinterval"><code class="xref py py-func docutils literal notranslate"><span class="pre">setswitchinterval()</span></code></a>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.2.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys._getframe">
|
||
<code class="descclassname">sys.</code><code class="descname">_getframe</code><span class="sig-paren">(</span><span class="optional">[</span><em>depth</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#sys._getframe" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return a frame object from the call stack. If optional integer <em>depth</em> is
|
||
given, return the frame object that many calls below the top of the stack. If
|
||
that is deeper than the call stack, <a class="reference internal" href="exceptions.html#ValueError" title="ValueError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code></a> is raised. The default
|
||
for <em>depth</em> is zero, returning the frame at the top of the call stack.</p>
|
||
<div class="impl-detail compound">
|
||
<p><strong>CPython implementation detail:</strong> This function should be used for internal and specialized purposes only.
|
||
It is not guaranteed to exist in all implementations of Python.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getprofile">
|
||
<code class="descclassname">sys.</code><code class="descname">getprofile</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getprofile" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p id="index-7">Get the profiler function as set by <a class="reference internal" href="#sys.setprofile" title="sys.setprofile"><code class="xref py py-func docutils literal notranslate"><span class="pre">setprofile()</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.gettrace">
|
||
<code class="descclassname">sys.</code><code class="descname">gettrace</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.gettrace" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p id="index-8">Get the trace function as set by <a class="reference internal" href="#sys.settrace" title="sys.settrace"><code class="xref py py-func docutils literal notranslate"><span class="pre">settrace()</span></code></a>.</p>
|
||
<div class="impl-detail compound">
|
||
<p><strong>CPython implementation detail:</strong> The <a class="reference internal" href="#sys.gettrace" title="sys.gettrace"><code class="xref py py-func docutils literal notranslate"><span class="pre">gettrace()</span></code></a> function is intended only for implementing debuggers,
|
||
profilers, coverage tools and the like. Its behavior is part of the
|
||
implementation platform, rather than part of the language definition, and
|
||
thus may not be available in all Python implementations.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.getwindowsversion">
|
||
<code class="descclassname">sys.</code><code class="descname">getwindowsversion</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.getwindowsversion" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return a named tuple describing the Windows version
|
||
currently running. The named elements are <em>major</em>, <em>minor</em>,
|
||
<em>build</em>, <em>platform</em>, <em>service_pack</em>, <em>service_pack_minor</em>,
|
||
<em>service_pack_major</em>, <em>suite_mask</em>, <em>product_type</em> and
|
||
<em>platform_version</em>. <em>service_pack</em> contains a string,
|
||
<em>platform_version</em> a 3-tuple and all other values are
|
||
integers. The components can also be accessed by name, so
|
||
<code class="docutils literal notranslate"><span class="pre">sys.getwindowsversion()[0]</span></code> is equivalent to
|
||
<code class="docutils literal notranslate"><span class="pre">sys.getwindowsversion().major</span></code>. For compatibility with prior
|
||
versions, only the first 5 elements are retrievable by indexing.</p>
|
||
<p><em>platform</em> will be <code class="xref py py-const docutils literal notranslate"><span class="pre">2</span> <span class="pre">(VER_PLATFORM_WIN32_NT)</span></code>.</p>
|
||
<p><em>product_type</em> may be one of the following values:</p>
|
||
<table class="docutils align-center">
|
||
<colgroup>
|
||
<col style="width: 54%" />
|
||
<col style="width: 46%" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>Constant</p></th>
|
||
<th class="head"><p>Meaning</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">1</span> <span class="pre">(VER_NT_WORKSTATION)</span></code></p></td>
|
||
<td><p>The system is a workstation.</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">2</span> <span class="pre">(VER_NT_DOMAIN_CONTROLLER)</span></code></p></td>
|
||
<td><p>The system is a domain
|
||
controller.</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">3</span> <span class="pre">(VER_NT_SERVER)</span></code></p></td>
|
||
<td><p>The system is a server, but not
|
||
a domain controller.</p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<p>This function wraps the Win32 <code class="xref c c-func docutils literal notranslate"><span class="pre">GetVersionEx()</span></code> function; see the
|
||
Microsoft documentation on <code class="xref c c-func docutils literal notranslate"><span class="pre">OSVERSIONINFOEX()</span></code> for more information
|
||
about these fields.</p>
|
||
<p><em>platform_version</em> returns the accurate major version, minor version and
|
||
build number of the current operating system, rather than the version that
|
||
is being emulated for the process. It is intended for use in logging rather
|
||
than for feature detection.</p>
|
||
<p class="availability"><a class="reference internal" href="intro.html#availability"><span class="std std-ref">Availability</span></a>: Windows.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.2: </span>Changed to a named tuple and added <em>service_pack_minor</em>,
|
||
<em>service_pack_major</em>, <em>suite_mask</em>, and <em>product_type</em>.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.6: </span>Added <em>platform_version</em></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.get_asyncgen_hooks">
|
||
<code class="descclassname">sys.</code><code class="descname">get_asyncgen_hooks</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.get_asyncgen_hooks" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Returns an <em>asyncgen_hooks</em> object, which is similar to a
|
||
<a class="reference internal" href="collections.html#collections.namedtuple" title="collections.namedtuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">namedtuple</span></code></a> of the form <cite>(firstiter, finalizer)</cite>,
|
||
where <em>firstiter</em> and <em>finalizer</em> are expected to be either <code class="docutils literal notranslate"><span class="pre">None</span></code> or
|
||
functions which take an <a class="reference internal" href="../glossary.html#term-asynchronous-generator-iterator"><span class="xref std std-term">asynchronous generator iterator</span></a> as an
|
||
argument, and are used to schedule finalization of an asynchronous
|
||
generator by an event loop.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.6: </span>See <span class="target" id="index-9"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0525"><strong>PEP 525</strong></a> for more details.</p>
|
||
</div>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>This function has been added on a provisional basis (see <span class="target" id="index-10"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0411"><strong>PEP 411</strong></a>
|
||
for details.)</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.get_coroutine_origin_tracking_depth">
|
||
<code class="descclassname">sys.</code><code class="descname">get_coroutine_origin_tracking_depth</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.get_coroutine_origin_tracking_depth" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Get the current coroutine origin tracking depth, as set by
|
||
<a class="reference internal" href="#sys.set_coroutine_origin_tracking_depth" title="sys.set_coroutine_origin_tracking_depth"><code class="xref py py-func docutils literal notranslate"><span class="pre">set_coroutine_origin_tracking_depth()</span></code></a>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.7.</span></p>
|
||
</div>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>This function has been added on a provisional basis (see <span class="target" id="index-11"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0411"><strong>PEP 411</strong></a>
|
||
for details.) Use it only for debugging purposes.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.get_coroutine_wrapper">
|
||
<code class="descclassname">sys.</code><code class="descname">get_coroutine_wrapper</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.get_coroutine_wrapper" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Returns <code class="docutils literal notranslate"><span class="pre">None</span></code>, or a wrapper set by <a class="reference internal" href="#sys.set_coroutine_wrapper" title="sys.set_coroutine_wrapper"><code class="xref py py-func docutils literal notranslate"><span class="pre">set_coroutine_wrapper()</span></code></a>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.5: </span>See <span class="target" id="index-12"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0492"><strong>PEP 492</strong></a> for more details.</p>
|
||
</div>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>This function has been added on a provisional basis (see <span class="target" id="index-13"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0411"><strong>PEP 411</strong></a>
|
||
for details.) Use it only for debugging purposes.</p>
|
||
</div>
|
||
<div class="deprecated">
|
||
<p><span class="versionmodified deprecated">Deprecated since version 3.7: </span>The coroutine wrapper functionality has been deprecated, and
|
||
will be removed in 3.8. See <a class="reference external" href="https://bugs.python.org/issue32591">bpo-32591</a> for details.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.hash_info">
|
||
<code class="descclassname">sys.</code><code class="descname">hash_info</code><a class="headerlink" href="#sys.hash_info" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="../glossary.html#term-struct-sequence"><span class="xref std std-term">struct sequence</span></a> giving parameters of the numeric hash
|
||
implementation. For more details about hashing of numeric types, see
|
||
<a class="reference internal" href="stdtypes.html#numeric-hash"><span class="std std-ref">Hashing of numeric types</span></a>.</p>
|
||
<table class="docutils align-center">
|
||
<colgroup>
|
||
<col style="width: 30%" />
|
||
<col style="width: 70%" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>attribute</p></th>
|
||
<th class="head"><p>explanation</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">width</span></code></p></td>
|
||
<td><p>width in bits used for hash values</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">modulus</span></code></p></td>
|
||
<td><p>prime modulus P used for numeric hash scheme</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">inf</span></code></p></td>
|
||
<td><p>hash value returned for a positive infinity</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">nan</span></code></p></td>
|
||
<td><p>hash value returned for a nan</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">imag</span></code></p></td>
|
||
<td><p>multiplier used for the imaginary part of a
|
||
complex number</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">algorithm</span></code></p></td>
|
||
<td><p>name of the algorithm for hashing of str, bytes,
|
||
and memoryview</p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">hash_bits</span></code></p></td>
|
||
<td><p>internal output size of the hash algorithm</p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">seed_bits</span></code></p></td>
|
||
<td><p>size of the seed key of the hash algorithm</p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.2.</span></p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.4: </span>Added <em>algorithm</em>, <em>hash_bits</em> and <em>seed_bits</em></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.hexversion">
|
||
<code class="descclassname">sys.</code><code class="descname">hexversion</code><a class="headerlink" href="#sys.hexversion" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>The version number encoded as a single integer. This is guaranteed to increase
|
||
with each version, including proper support for non-production releases. For
|
||
example, to test that the Python interpreter is at least version 1.5.2, use:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">hexversion</span> <span class="o">>=</span> <span class="mh">0x010502F0</span><span class="p">:</span>
|
||
<span class="c1"># use some advanced feature</span>
|
||
<span class="o">...</span>
|
||
<span class="k">else</span><span class="p">:</span>
|
||
<span class="c1"># use an alternative implementation or warn the user</span>
|
||
<span class="o">...</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>This is called <code class="docutils literal notranslate"><span class="pre">hexversion</span></code> since it only really looks meaningful when viewed
|
||
as the result of passing it to the built-in <a class="reference internal" href="functions.html#hex" title="hex"><code class="xref py py-func docutils literal notranslate"><span class="pre">hex()</span></code></a> function. The
|
||
<a class="reference internal" href="../glossary.html#term-struct-sequence"><span class="xref std std-term">struct sequence</span></a> <a class="reference internal" href="#sys.version_info" title="sys.version_info"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.version_info</span></code></a> may be used for a more
|
||
human-friendly encoding of the same information.</p>
|
||
<p>More details of <code class="docutils literal notranslate"><span class="pre">hexversion</span></code> can be found at <a class="reference internal" href="../c-api/apiabiversion.html#apiabiversion"><span class="std std-ref">API and ABI Versioning</span></a>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.implementation">
|
||
<code class="descclassname">sys.</code><code class="descname">implementation</code><a class="headerlink" href="#sys.implementation" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>An object containing information about the implementation of the
|
||
currently running Python interpreter. The following attributes are
|
||
required to exist in all Python implementations.</p>
|
||
<p><em>name</em> is the implementation’s identifier, e.g. <code class="docutils literal notranslate"><span class="pre">'cpython'</span></code>. The actual
|
||
string is defined by the Python implementation, but it is guaranteed to be
|
||
lower case.</p>
|
||
<p><em>version</em> is a named tuple, in the same format as
|
||
<a class="reference internal" href="#sys.version_info" title="sys.version_info"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.version_info</span></code></a>. It represents the version of the Python
|
||
<em>implementation</em>. This has a distinct meaning from the specific
|
||
version of the Python <em>language</em> to which the currently running
|
||
interpreter conforms, which <code class="docutils literal notranslate"><span class="pre">sys.version_info</span></code> represents. For
|
||
example, for PyPy 1.8 <code class="docutils literal notranslate"><span class="pre">sys.implementation.version</span></code> might be
|
||
<code class="docutils literal notranslate"><span class="pre">sys.version_info(1,</span> <span class="pre">8,</span> <span class="pre">0,</span> <span class="pre">'final',</span> <span class="pre">0)</span></code>, whereas <code class="docutils literal notranslate"><span class="pre">sys.version_info</span></code>
|
||
would be <code class="docutils literal notranslate"><span class="pre">sys.version_info(2,</span> <span class="pre">7,</span> <span class="pre">2,</span> <span class="pre">'final',</span> <span class="pre">0)</span></code>. For CPython they
|
||
are the same value, since it is the reference implementation.</p>
|
||
<p><em>hexversion</em> is the implementation version in hexadecimal format, like
|
||
<a class="reference internal" href="#sys.hexversion" title="sys.hexversion"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.hexversion</span></code></a>.</p>
|
||
<p><em>cache_tag</em> is the tag used by the import machinery in the filenames of
|
||
cached modules. By convention, it would be a composite of the
|
||
implementation’s name and version, like <code class="docutils literal notranslate"><span class="pre">'cpython-33'</span></code>. However, a
|
||
Python implementation may use some other value if appropriate. If
|
||
<code class="docutils literal notranslate"><span class="pre">cache_tag</span></code> is set to <code class="docutils literal notranslate"><span class="pre">None</span></code>, it indicates that module caching should
|
||
be disabled.</p>
|
||
<p><a class="reference internal" href="#sys.implementation" title="sys.implementation"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.implementation</span></code></a> may contain additional attributes specific to
|
||
the Python implementation. These non-standard attributes must start with
|
||
an underscore, and are not described here. Regardless of its contents,
|
||
<a class="reference internal" href="#sys.implementation" title="sys.implementation"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.implementation</span></code></a> will not change during a run of the interpreter,
|
||
nor between implementation versions. (It may change between Python
|
||
language versions, however.) See <span class="target" id="index-14"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0421"><strong>PEP 421</strong></a> for more information.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.3.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.int_info">
|
||
<code class="descclassname">sys.</code><code class="descname">int_info</code><a class="headerlink" href="#sys.int_info" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="../glossary.html#term-struct-sequence"><span class="xref std std-term">struct sequence</span></a> that holds information about Python’s internal
|
||
representation of integers. The attributes are read only.</p>
|
||
<table class="docutils align-center">
|
||
<colgroup>
|
||
<col style="width: 35%" />
|
||
<col style="width: 65%" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>Attribute</p></th>
|
||
<th class="head"><p>Explanation</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">bits_per_digit</span></code></p></td>
|
||
<td><p>number of bits held in each digit. Python
|
||
integers are stored internally in base
|
||
<code class="docutils literal notranslate"><span class="pre">2**int_info.bits_per_digit</span></code></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">sizeof_digit</span></code></p></td>
|
||
<td><p>size in bytes of the C type used to
|
||
represent a digit</p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.1.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.__interactivehook__">
|
||
<code class="descclassname">sys.</code><code class="descname">__interactivehook__</code><a class="headerlink" href="#sys.__interactivehook__" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>When this attribute exists, its value is automatically called (with no
|
||
arguments) when the interpreter is launched in <a class="reference internal" href="../tutorial/interpreter.html#tut-interactive"><span class="std std-ref">interactive mode</span></a>. This is done after the <span class="target" id="index-15"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONSTARTUP"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONSTARTUP</span></code></a> file is
|
||
read, so that you can set this hook there. The <a class="reference internal" href="site.html#module-site" title="site: Module responsible for site-specific configuration."><code class="xref py py-mod docutils literal notranslate"><span class="pre">site</span></code></a> module
|
||
<a class="reference internal" href="site.html#rlcompleter-config"><span class="std std-ref">sets this</span></a>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.4.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.intern">
|
||
<code class="descclassname">sys.</code><code class="descname">intern</code><span class="sig-paren">(</span><em>string</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.intern" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Enter <em>string</em> in the table of “interned” strings and return the interned string
|
||
– which is <em>string</em> itself or a copy. Interning strings is useful to gain a
|
||
little performance on dictionary lookup – if the keys in a dictionary are
|
||
interned, and the lookup key is interned, the key comparisons (after hashing)
|
||
can be done by a pointer compare instead of a string compare. Normally, the
|
||
names used in Python programs are automatically interned, and the dictionaries
|
||
used to hold module, class or instance attributes have interned keys.</p>
|
||
<p>Interned strings are not immortal; you must keep a reference to the return
|
||
value of <a class="reference internal" href="#sys.intern" title="sys.intern"><code class="xref py py-func docutils literal notranslate"><span class="pre">intern()</span></code></a> around to benefit from it.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.is_finalizing">
|
||
<code class="descclassname">sys.</code><code class="descname">is_finalizing</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys.is_finalizing" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Return <a class="reference internal" href="constants.html#True" title="True"><code class="xref py py-const docutils literal notranslate"><span class="pre">True</span></code></a> if the Python interpreter is
|
||
<a class="reference internal" href="../glossary.html#term-interpreter-shutdown"><span class="xref std std-term">shutting down</span></a>, <a class="reference internal" href="constants.html#False" title="False"><code class="xref py py-const docutils literal notranslate"><span class="pre">False</span></code></a> otherwise.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.5.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.last_type">
|
||
<code class="descclassname">sys.</code><code class="descname">last_type</code><a class="headerlink" href="#sys.last_type" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.last_value">
|
||
<code class="descclassname">sys.</code><code class="descname">last_value</code><a class="headerlink" href="#sys.last_value" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.last_traceback">
|
||
<code class="descclassname">sys.</code><code class="descname">last_traceback</code><a class="headerlink" href="#sys.last_traceback" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>These three variables are not always defined; they are set when an exception is
|
||
not handled and the interpreter prints an error message and a stack traceback.
|
||
Their intended use is to allow an interactive user to import a debugger module
|
||
and engage in post-mortem debugging without having to re-execute the command
|
||
that caused the error. (Typical use is <code class="docutils literal notranslate"><span class="pre">import</span> <span class="pre">pdb;</span> <span class="pre">pdb.pm()</span></code> to enter the
|
||
post-mortem debugger; see <a class="reference internal" href="pdb.html#module-pdb" title="pdb: The Python debugger for interactive interpreters."><code class="xref py py-mod docutils literal notranslate"><span class="pre">pdb</span></code></a> module for
|
||
more information.)</p>
|
||
<p>The meaning of the variables is the same as that of the return values from
|
||
<a class="reference internal" href="#sys.exc_info" title="sys.exc_info"><code class="xref py py-func docutils literal notranslate"><span class="pre">exc_info()</span></code></a> above.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.maxsize">
|
||
<code class="descclassname">sys.</code><code class="descname">maxsize</code><a class="headerlink" href="#sys.maxsize" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>An integer giving the maximum value a variable of type <code class="xref c c-type docutils literal notranslate"><span class="pre">Py_ssize_t</span></code> can
|
||
take. It’s usually <code class="docutils literal notranslate"><span class="pre">2**31</span> <span class="pre">-</span> <span class="pre">1</span></code> on a 32-bit platform and <code class="docutils literal notranslate"><span class="pre">2**63</span> <span class="pre">-</span> <span class="pre">1</span></code> on a
|
||
64-bit platform.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.maxunicode">
|
||
<code class="descclassname">sys.</code><code class="descname">maxunicode</code><a class="headerlink" href="#sys.maxunicode" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>An integer giving the value of the largest Unicode code point,
|
||
i.e. <code class="docutils literal notranslate"><span class="pre">1114111</span></code> (<code class="docutils literal notranslate"><span class="pre">0x10FFFF</span></code> in hexadecimal).</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.3: </span>Before <span class="target" id="index-16"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0393"><strong>PEP 393</strong></a>, <code class="docutils literal notranslate"><span class="pre">sys.maxunicode</span></code> used to be either <code class="docutils literal notranslate"><span class="pre">0xFFFF</span></code>
|
||
or <code class="docutils literal notranslate"><span class="pre">0x10FFFF</span></code>, depending on the configuration option that specified
|
||
whether Unicode characters were stored as UCS-2 or UCS-4.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.meta_path">
|
||
<code class="descclassname">sys.</code><code class="descname">meta_path</code><a class="headerlink" href="#sys.meta_path" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A list of <a class="reference internal" href="../glossary.html#term-meta-path-finder"><span class="xref std std-term">meta path finder</span></a> objects that have their
|
||
<a class="reference internal" href="importlib.html#importlib.abc.MetaPathFinder.find_spec" title="importlib.abc.MetaPathFinder.find_spec"><code class="xref py py-meth docutils literal notranslate"><span class="pre">find_spec()</span></code></a> methods called to see if one
|
||
of the objects can find the module to be imported. The
|
||
<a class="reference internal" href="importlib.html#importlib.abc.MetaPathFinder.find_spec" title="importlib.abc.MetaPathFinder.find_spec"><code class="xref py py-meth docutils literal notranslate"><span class="pre">find_spec()</span></code></a> method is called with at
|
||
least the absolute name of the module being imported. If the module to be
|
||
imported is contained in a package, then the parent package’s <a class="reference internal" href="../reference/import.html#__path__" title="__path__"><code class="xref py py-attr docutils literal notranslate"><span class="pre">__path__</span></code></a>
|
||
attribute is passed in as a second argument. The method returns a
|
||
<a class="reference internal" href="../glossary.html#term-module-spec"><span class="xref std std-term">module spec</span></a>, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if the module cannot be found.</p>
|
||
<div class="admonition seealso">
|
||
<p class="admonition-title">See also</p>
|
||
<dl class="simple">
|
||
<dt><a class="reference internal" href="importlib.html#importlib.abc.MetaPathFinder" title="importlib.abc.MetaPathFinder"><code class="xref py py-class docutils literal notranslate"><span class="pre">importlib.abc.MetaPathFinder</span></code></a></dt><dd><p>The abstract base class defining the interface of finder objects on
|
||
<a class="reference internal" href="#sys.meta_path" title="sys.meta_path"><code class="xref py py-data docutils literal notranslate"><span class="pre">meta_path</span></code></a>.</p>
|
||
</dd>
|
||
<dt><a class="reference internal" href="importlib.html#importlib.machinery.ModuleSpec" title="importlib.machinery.ModuleSpec"><code class="xref py py-class docutils literal notranslate"><span class="pre">importlib.machinery.ModuleSpec</span></code></a></dt><dd><p>The concrete class which
|
||
<a class="reference internal" href="importlib.html#importlib.abc.MetaPathFinder.find_spec" title="importlib.abc.MetaPathFinder.find_spec"><code class="xref py py-meth docutils literal notranslate"><span class="pre">find_spec()</span></code></a> should return
|
||
instances of.</p>
|
||
</dd>
|
||
</dl>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.4: </span><a class="reference internal" href="../glossary.html#term-module-spec"><span class="xref std std-term">Module specs</span></a> were introduced in Python 3.4, by
|
||
<span class="target" id="index-17"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0451"><strong>PEP 451</strong></a>. Earlier versions of Python looked for a method called
|
||
<a class="reference internal" href="importlib.html#importlib.abc.MetaPathFinder.find_module" title="importlib.abc.MetaPathFinder.find_module"><code class="xref py py-meth docutils literal notranslate"><span class="pre">find_module()</span></code></a>.
|
||
This is still called as a fallback if a <a class="reference internal" href="#sys.meta_path" title="sys.meta_path"><code class="xref py py-data docutils literal notranslate"><span class="pre">meta_path</span></code></a> entry doesn’t
|
||
have a <a class="reference internal" href="importlib.html#importlib.abc.MetaPathFinder.find_spec" title="importlib.abc.MetaPathFinder.find_spec"><code class="xref py py-meth docutils literal notranslate"><span class="pre">find_spec()</span></code></a> method.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.modules">
|
||
<code class="descclassname">sys.</code><code class="descname">modules</code><a class="headerlink" href="#sys.modules" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>This is a dictionary that maps module names to modules which have already been
|
||
loaded. This can be manipulated to force reloading of modules and other tricks.
|
||
However, replacing the dictionary will not necessarily work as expected and
|
||
deleting essential items from the dictionary may cause Python to fail.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.path">
|
||
<code class="descclassname">sys.</code><code class="descname">path</code><a class="headerlink" href="#sys.path" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p id="index-18">A list of strings that specifies the search path for modules. Initialized from
|
||
the environment variable <span class="target" id="index-19"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONPATH"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONPATH</span></code></a>, plus an installation-dependent
|
||
default.</p>
|
||
<p>As initialized upon program startup, the first item of this list, <code class="docutils literal notranslate"><span class="pre">path[0]</span></code>,
|
||
is the directory containing the script that was used to invoke the Python
|
||
interpreter. If the script directory is not available (e.g. if the interpreter
|
||
is invoked interactively or if the script is read from standard input),
|
||
<code class="docutils literal notranslate"><span class="pre">path[0]</span></code> is the empty string, which directs Python to search modules in the
|
||
current directory first. Notice that the script directory is inserted <em>before</em>
|
||
the entries inserted as a result of <span class="target" id="index-20"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONPATH"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONPATH</span></code></a>.</p>
|
||
<p>A program is free to modify this list for its own purposes. Only strings
|
||
and bytes should be added to <a class="reference internal" href="#sys.path" title="sys.path"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.path</span></code></a>; all other data types are
|
||
ignored during import.</p>
|
||
<div class="admonition seealso">
|
||
<p class="admonition-title">See also</p>
|
||
<p>Module <a class="reference internal" href="site.html#module-site" title="site: Module responsible for site-specific configuration."><code class="xref py py-mod docutils literal notranslate"><span class="pre">site</span></code></a> This describes how to use .pth files to extend
|
||
<a class="reference internal" href="#sys.path" title="sys.path"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.path</span></code></a>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.path_hooks">
|
||
<code class="descclassname">sys.</code><code class="descname">path_hooks</code><a class="headerlink" href="#sys.path_hooks" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A list of callables that take a path argument to try to create a
|
||
<a class="reference internal" href="../glossary.html#term-finder"><span class="xref std std-term">finder</span></a> for the path. If a finder can be created, it is to be
|
||
returned by the callable, else raise <a class="reference internal" href="exceptions.html#ImportError" title="ImportError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ImportError</span></code></a>.</p>
|
||
<p>Originally specified in <span class="target" id="index-21"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0302"><strong>PEP 302</strong></a>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.path_importer_cache">
|
||
<code class="descclassname">sys.</code><code class="descname">path_importer_cache</code><a class="headerlink" href="#sys.path_importer_cache" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A dictionary acting as a cache for <a class="reference internal" href="../glossary.html#term-finder"><span class="xref std std-term">finder</span></a> objects. The keys are
|
||
paths that have been passed to <a class="reference internal" href="#sys.path_hooks" title="sys.path_hooks"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.path_hooks</span></code></a> and the values are
|
||
the finders that are found. If a path is a valid file system path but no
|
||
finder is found on <a class="reference internal" href="#sys.path_hooks" title="sys.path_hooks"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.path_hooks</span></code></a> then <code class="docutils literal notranslate"><span class="pre">None</span></code> is
|
||
stored.</p>
|
||
<p>Originally specified in <span class="target" id="index-22"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0302"><strong>PEP 302</strong></a>.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.3: </span><code class="docutils literal notranslate"><span class="pre">None</span></code> is stored instead of <a class="reference internal" href="imp.html#imp.NullImporter" title="imp.NullImporter"><code class="xref py py-class docutils literal notranslate"><span class="pre">imp.NullImporter</span></code></a> when no finder
|
||
is found.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.platform">
|
||
<code class="descclassname">sys.</code><code class="descname">platform</code><a class="headerlink" href="#sys.platform" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>This string contains a platform identifier that can be used to append
|
||
platform-specific components to <a class="reference internal" href="#sys.path" title="sys.path"><code class="xref py py-data docutils literal notranslate"><span class="pre">sys.path</span></code></a>, for instance.</p>
|
||
<p>For Unix systems, except on Linux, this is the lowercased OS name as
|
||
returned by <code class="docutils literal notranslate"><span class="pre">uname</span> <span class="pre">-s</span></code> with the first part of the version as returned by
|
||
<code class="docutils literal notranslate"><span class="pre">uname</span> <span class="pre">-r</span></code> appended, e.g. <code class="docutils literal notranslate"><span class="pre">'sunos5'</span></code> or <code class="docutils literal notranslate"><span class="pre">'freebsd8'</span></code>, <em>at the time
|
||
when Python was built</em>. Unless you want to test for a specific system
|
||
version, it is therefore recommended to use the following idiom:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">platform</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">'freebsd'</span><span class="p">):</span>
|
||
<span class="c1"># FreeBSD-specific code here...</span>
|
||
<span class="k">elif</span> <span class="n">sys</span><span class="o">.</span><span class="n">platform</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">'linux'</span><span class="p">):</span>
|
||
<span class="c1"># Linux-specific code here...</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>For other systems, the values are:</p>
|
||
<table class="docutils align-center">
|
||
<colgroup>
|
||
<col style="width: 37%" />
|
||
<col style="width: 63%" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>System</p></th>
|
||
<th class="head"><p><code class="docutils literal notranslate"><span class="pre">platform</span></code> value</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p>Linux</p></td>
|
||
<td><p><code class="docutils literal notranslate"><span class="pre">'linux'</span></code></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p>Windows</p></td>
|
||
<td><p><code class="docutils literal notranslate"><span class="pre">'win32'</span></code></p></td>
|
||
</tr>
|
||
<tr class="row-even"><td><p>Windows/Cygwin</p></td>
|
||
<td><p><code class="docutils literal notranslate"><span class="pre">'cygwin'</span></code></p></td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p>Mac OS X</p></td>
|
||
<td><p><code class="docutils literal notranslate"><span class="pre">'darwin'</span></code></p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.3: </span>On Linux, <a class="reference internal" href="#sys.platform" title="sys.platform"><code class="xref py py-attr docutils literal notranslate"><span class="pre">sys.platform</span></code></a> doesn’t contain the major version anymore.
|
||
It is always <code class="docutils literal notranslate"><span class="pre">'linux'</span></code>, instead of <code class="docutils literal notranslate"><span class="pre">'linux2'</span></code> or <code class="docutils literal notranslate"><span class="pre">'linux3'</span></code>. Since
|
||
older Python versions include the version number, it is recommended to
|
||
always use the <code class="docutils literal notranslate"><span class="pre">startswith</span></code> idiom presented above.</p>
|
||
</div>
|
||
<div class="admonition seealso">
|
||
<p class="admonition-title">See also</p>
|
||
<p><a class="reference internal" href="os.html#os.name" title="os.name"><code class="xref py py-attr docutils literal notranslate"><span class="pre">os.name</span></code></a> has a coarser granularity. <a class="reference internal" href="os.html#os.uname" title="os.uname"><code class="xref py py-func docutils literal notranslate"><span class="pre">os.uname()</span></code></a> gives
|
||
system-dependent version information.</p>
|
||
<p>The <a class="reference internal" href="platform.html#module-platform" title="platform: Retrieves as much platform identifying data as possible."><code class="xref py py-mod docutils literal notranslate"><span class="pre">platform</span></code></a> module provides detailed checks for the
|
||
system’s identity.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.prefix">
|
||
<code class="descclassname">sys.</code><code class="descname">prefix</code><a class="headerlink" href="#sys.prefix" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A string giving the site-specific directory prefix where the platform
|
||
independent Python files are installed; by default, this is the string
|
||
<code class="docutils literal notranslate"><span class="pre">'/usr/local'</span></code>. This can be set at build time with the <code class="docutils literal notranslate"><span class="pre">--prefix</span></code>
|
||
argument to the <strong class="program">configure</strong> script. The main collection of Python
|
||
library modules is installed in the directory <code class="file docutils literal notranslate"><em><span class="pre">prefix</span></em><span class="pre">/lib/python</span><em><span class="pre">X.Y</span></em></code>
|
||
while the platform independent header files (all except <code class="file docutils literal notranslate"><span class="pre">pyconfig.h</span></code>) are
|
||
stored in <code class="file docutils literal notranslate"><em><span class="pre">prefix</span></em><span class="pre">/include/python</span><em><span class="pre">X.Y</span></em></code>, where <em>X.Y</em> is the version
|
||
number of Python, for example <code class="docutils literal notranslate"><span class="pre">3.2</span></code>.</p>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>If a <a class="reference internal" href="venv.html#venv-def"><span class="std std-ref">virtual environment</span></a> is in effect, this
|
||
value will be changed in <code class="docutils literal notranslate"><span class="pre">site.py</span></code> to point to the virtual
|
||
environment. The value for the Python installation will still be
|
||
available, via <a class="reference internal" href="#sys.base_prefix" title="sys.base_prefix"><code class="xref py py-data docutils literal notranslate"><span class="pre">base_prefix</span></code></a>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.ps1">
|
||
<code class="descclassname">sys.</code><code class="descname">ps1</code><a class="headerlink" href="#sys.ps1" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.ps2">
|
||
<code class="descclassname">sys.</code><code class="descname">ps2</code><a class="headerlink" href="#sys.ps2" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p id="index-23">Strings specifying the primary and secondary prompt of the interpreter. These
|
||
are only defined if the interpreter is in interactive mode. Their initial
|
||
values in this case are <code class="docutils literal notranslate"><span class="pre">'>>></span> <span class="pre">'</span></code> and <code class="docutils literal notranslate"><span class="pre">'...</span> <span class="pre">'</span></code>. If a non-string object is
|
||
assigned to either variable, its <a class="reference internal" href="stdtypes.html#str" title="str"><code class="xref py py-func docutils literal notranslate"><span class="pre">str()</span></code></a> is re-evaluated each time the
|
||
interpreter prepares to read a new interactive command; this can be used to
|
||
implement a dynamic prompt.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.setcheckinterval">
|
||
<code class="descclassname">sys.</code><code class="descname">setcheckinterval</code><span class="sig-paren">(</span><em>interval</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.setcheckinterval" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Set the interpreter’s “check interval”. This integer value determines how often
|
||
the interpreter checks for periodic things such as thread switches and signal
|
||
handlers. The default is <code class="docutils literal notranslate"><span class="pre">100</span></code>, meaning the check is performed every 100
|
||
Python virtual instructions. Setting it to a larger value may increase
|
||
performance for programs using threads. Setting it to a value <code class="docutils literal notranslate"><span class="pre"><=</span></code> 0 checks
|
||
every virtual instruction, maximizing responsiveness as well as overhead.</p>
|
||
<div class="deprecated">
|
||
<p><span class="versionmodified deprecated">Deprecated since version 3.2: </span>This function doesn’t have an effect anymore, as the internal logic for
|
||
thread switching and asynchronous tasks has been rewritten. Use
|
||
<a class="reference internal" href="#sys.setswitchinterval" title="sys.setswitchinterval"><code class="xref py py-func docutils literal notranslate"><span class="pre">setswitchinterval()</span></code></a> instead.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.setdlopenflags">
|
||
<code class="descclassname">sys.</code><code class="descname">setdlopenflags</code><span class="sig-paren">(</span><em>n</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.setdlopenflags" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Set the flags used by the interpreter for <code class="xref c c-func docutils literal notranslate"><span class="pre">dlopen()</span></code> calls, such as when
|
||
the interpreter loads extension modules. Among other things, this will enable a
|
||
lazy resolving of symbols when importing a module, if called as
|
||
<code class="docutils literal notranslate"><span class="pre">sys.setdlopenflags(0)</span></code>. To share symbols across extension modules, call as
|
||
<code class="docutils literal notranslate"><span class="pre">sys.setdlopenflags(os.RTLD_GLOBAL)</span></code>. Symbolic names for the flag values
|
||
can be found in the <a class="reference internal" href="os.html#module-os" title="os: Miscellaneous operating system interfaces."><code class="xref py py-mod docutils literal notranslate"><span class="pre">os</span></code></a> module (<code class="docutils literal notranslate"><span class="pre">RTLD_xxx</span></code> constants, e.g.
|
||
<a class="reference internal" href="os.html#os.RTLD_LAZY" title="os.RTLD_LAZY"><code class="xref py py-data docutils literal notranslate"><span class="pre">os.RTLD_LAZY</span></code></a>).</p>
|
||
<p class="availability"><a class="reference internal" href="intro.html#availability"><span class="std std-ref">Availability</span></a>: Unix.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.setprofile">
|
||
<code class="descclassname">sys.</code><code class="descname">setprofile</code><span class="sig-paren">(</span><em>profilefunc</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.setprofile" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p id="index-24">Set the system’s profile function, which allows you to implement a Python source
|
||
code profiler in Python. See chapter <a class="reference internal" href="profile.html#profile"><span class="std std-ref">The Python Profilers</span></a> for more information on the
|
||
Python profiler. The system’s profile function is called similarly to the
|
||
system’s trace function (see <a class="reference internal" href="#sys.settrace" title="sys.settrace"><code class="xref py py-func docutils literal notranslate"><span class="pre">settrace()</span></code></a>), but it is called with different events,
|
||
for example it isn’t called for each executed line of code (only on call and return,
|
||
but the return event is reported even when an exception has been set). The function is
|
||
thread-specific, but there is no way for the profiler to know about context switches between
|
||
threads, so it does not make sense to use this in the presence of multiple threads. Also,
|
||
its return value is not used, so it can simply return <code class="docutils literal notranslate"><span class="pre">None</span></code>. Error in the profile
|
||
function will cause itself unset.</p>
|
||
<p>Profile functions should have three arguments: <em>frame</em>, <em>event</em>, and
|
||
<em>arg</em>. <em>frame</em> is the current stack frame. <em>event</em> is a string: <code class="docutils literal notranslate"><span class="pre">'call'</span></code>,
|
||
<code class="docutils literal notranslate"><span class="pre">'return'</span></code>, <code class="docutils literal notranslate"><span class="pre">'c_call'</span></code>, <code class="docutils literal notranslate"><span class="pre">'c_return'</span></code>, or <code class="docutils literal notranslate"><span class="pre">'c_exception'</span></code>. <em>arg</em> depends
|
||
on the event type.</p>
|
||
<p>The events have the following meaning:</p>
|
||
<dl class="simple">
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'call'</span></code></dt><dd><p>A function is called (or some other code block entered). The
|
||
profile function is called; <em>arg</em> is <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p>
|
||
</dd>
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'return'</span></code></dt><dd><p>A function (or other code block) is about to return. The profile
|
||
function is called; <em>arg</em> is the value that will be returned, or <code class="docutils literal notranslate"><span class="pre">None</span></code>
|
||
if the event is caused by an exception being raised.</p>
|
||
</dd>
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'c_call'</span></code></dt><dd><p>A C function is about to be called. This may be an extension function or
|
||
a built-in. <em>arg</em> is the C function object.</p>
|
||
</dd>
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'c_return'</span></code></dt><dd><p>A C function has returned. <em>arg</em> is the C function object.</p>
|
||
</dd>
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'c_exception'</span></code></dt><dd><p>A C function has raised an exception. <em>arg</em> is the C function object.</p>
|
||
</dd>
|
||
</dl>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.setrecursionlimit">
|
||
<code class="descclassname">sys.</code><code class="descname">setrecursionlimit</code><span class="sig-paren">(</span><em>limit</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.setrecursionlimit" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Set the maximum depth of the Python interpreter stack to <em>limit</em>. This limit
|
||
prevents infinite recursion from causing an overflow of the C stack and crashing
|
||
Python.</p>
|
||
<p>The highest possible limit is platform-dependent. A user may need to set the
|
||
limit higher when they have a program that requires deep recursion and a platform
|
||
that supports a higher limit. This should be done with care, because a too-high
|
||
limit can lead to a crash.</p>
|
||
<p>If the new limit is too low at the current recursion depth, a
|
||
<a class="reference internal" href="exceptions.html#RecursionError" title="RecursionError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">RecursionError</span></code></a> exception is raised.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.5.1: </span>A <a class="reference internal" href="exceptions.html#RecursionError" title="RecursionError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">RecursionError</span></code></a> exception is now raised if the new limit is too
|
||
low at the current recursion depth.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.setswitchinterval">
|
||
<code class="descclassname">sys.</code><code class="descname">setswitchinterval</code><span class="sig-paren">(</span><em>interval</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.setswitchinterval" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Set the interpreter’s thread switch interval (in seconds). This floating-point
|
||
value determines the ideal duration of the “timeslices” allocated to
|
||
concurrently running Python threads. Please note that the actual value
|
||
can be higher, especially if long-running internal functions or methods
|
||
are used. Also, which thread becomes scheduled at the end of the interval
|
||
is the operating system’s decision. The interpreter doesn’t have its
|
||
own scheduler.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.2.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.settrace">
|
||
<code class="descclassname">sys.</code><code class="descname">settrace</code><span class="sig-paren">(</span><em>tracefunc</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.settrace" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p id="index-25">Set the system’s trace function, which allows you to implement a Python
|
||
source code debugger in Python. The function is thread-specific; for a
|
||
debugger to support multiple threads, it must register a trace function using
|
||
<a class="reference internal" href="#sys.settrace" title="sys.settrace"><code class="xref py py-func docutils literal notranslate"><span class="pre">settrace()</span></code></a> for each thread being debugged or use <a class="reference internal" href="threading.html#threading.settrace" title="threading.settrace"><code class="xref py py-func docutils literal notranslate"><span class="pre">threading.settrace()</span></code></a>.</p>
|
||
<p>Trace functions should have three arguments: <em>frame</em>, <em>event</em>, and
|
||
<em>arg</em>. <em>frame</em> is the current stack frame. <em>event</em> is a string: <code class="docutils literal notranslate"><span class="pre">'call'</span></code>,
|
||
<code class="docutils literal notranslate"><span class="pre">'line'</span></code>, <code class="docutils literal notranslate"><span class="pre">'return'</span></code>, <code class="docutils literal notranslate"><span class="pre">'exception'</span></code> or <code class="docutils literal notranslate"><span class="pre">'opcode'</span></code>. <em>arg</em> depends on
|
||
the event type.</p>
|
||
<p>The trace function is invoked (with <em>event</em> set to <code class="docutils literal notranslate"><span class="pre">'call'</span></code>) whenever a new
|
||
local scope is entered; it should return a reference to a local trace
|
||
function to be used that scope, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if the scope shouldn’t be traced.</p>
|
||
<p>The local trace function should return a reference to itself (or to another
|
||
function for further tracing in that scope), or <code class="docutils literal notranslate"><span class="pre">None</span></code> to turn off tracing
|
||
in that scope.</p>
|
||
<p>If there is any error occurred in the trace function, it will be unset, just
|
||
like <code class="docutils literal notranslate"><span class="pre">settrace(None)</span></code> is called.</p>
|
||
<p>The events have the following meaning:</p>
|
||
<dl class="simple">
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'call'</span></code></dt><dd><p>A function is called (or some other code block entered). The
|
||
global trace function is called; <em>arg</em> is <code class="docutils literal notranslate"><span class="pre">None</span></code>; the return value
|
||
specifies the local trace function.</p>
|
||
</dd>
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'line'</span></code></dt><dd><p>The interpreter is about to execute a new line of code or re-execute the
|
||
condition of a loop. The local trace function is called; <em>arg</em> is
|
||
<code class="docutils literal notranslate"><span class="pre">None</span></code>; the return value specifies the new local trace function. See
|
||
<code class="file docutils literal notranslate"><span class="pre">Objects/lnotab_notes.txt</span></code> for a detailed explanation of how this
|
||
works.
|
||
Per-line events may be disabled for a frame by setting
|
||
<code class="xref py py-attr docutils literal notranslate"><span class="pre">f_trace_lines</span></code> to <a class="reference internal" href="constants.html#False" title="False"><code class="xref py py-const docutils literal notranslate"><span class="pre">False</span></code></a> on that frame.</p>
|
||
</dd>
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'return'</span></code></dt><dd><p>A function (or other code block) is about to return. The local trace
|
||
function is called; <em>arg</em> is the value that will be returned, or <code class="docutils literal notranslate"><span class="pre">None</span></code>
|
||
if the event is caused by an exception being raised. The trace function’s
|
||
return value is ignored.</p>
|
||
</dd>
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'exception'</span></code></dt><dd><p>An exception has occurred. The local trace function is called; <em>arg</em> is a
|
||
tuple <code class="docutils literal notranslate"><span class="pre">(exception,</span> <span class="pre">value,</span> <span class="pre">traceback)</span></code>; the return value specifies the
|
||
new local trace function.</p>
|
||
</dd>
|
||
<dt><code class="docutils literal notranslate"><span class="pre">'opcode'</span></code></dt><dd><p>The interpreter is about to execute a new opcode (see <a class="reference internal" href="dis.html#module-dis" title="dis: Disassembler for Python bytecode."><code class="xref py py-mod docutils literal notranslate"><span class="pre">dis</span></code></a> for
|
||
opcode details). The local trace function is called; <em>arg</em> is
|
||
<code class="docutils literal notranslate"><span class="pre">None</span></code>; the return value specifies the new local trace function.
|
||
Per-opcode events are not emitted by default: they must be explicitly
|
||
requested by setting <code class="xref py py-attr docutils literal notranslate"><span class="pre">f_trace_opcodes</span></code> to <a class="reference internal" href="constants.html#True" title="True"><code class="xref py py-const docutils literal notranslate"><span class="pre">True</span></code></a> on the
|
||
frame.</p>
|
||
</dd>
|
||
</dl>
|
||
<p>Note that as an exception is propagated down the chain of callers, an
|
||
<code class="docutils literal notranslate"><span class="pre">'exception'</span></code> event is generated at each level.</p>
|
||
<p>For more information on code and frame objects, refer to <a class="reference internal" href="../reference/datamodel.html#types"><span class="std std-ref">The standard type hierarchy</span></a>.</p>
|
||
<div class="impl-detail compound">
|
||
<p><strong>CPython implementation detail:</strong> The <a class="reference internal" href="#sys.settrace" title="sys.settrace"><code class="xref py py-func docutils literal notranslate"><span class="pre">settrace()</span></code></a> function is intended only for implementing debuggers,
|
||
profilers, coverage tools and the like. Its behavior is part of the
|
||
implementation platform, rather than part of the language definition, and
|
||
thus may not be available in all Python implementations.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.7: </span><code class="docutils literal notranslate"><span class="pre">'opcode'</span></code> event type added; <code class="xref py py-attr docutils literal notranslate"><span class="pre">f_trace_lines</span></code> and
|
||
<code class="xref py py-attr docutils literal notranslate"><span class="pre">f_trace_opcodes</span></code> attributes added to frames</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.set_asyncgen_hooks">
|
||
<code class="descclassname">sys.</code><code class="descname">set_asyncgen_hooks</code><span class="sig-paren">(</span><em>firstiter</em>, <em>finalizer</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.set_asyncgen_hooks" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Accepts two optional keyword arguments which are callables that accept an
|
||
<a class="reference internal" href="../glossary.html#term-asynchronous-generator-iterator"><span class="xref std std-term">asynchronous generator iterator</span></a> as an argument. The <em>firstiter</em>
|
||
callable will be called when an asynchronous generator is iterated for the
|
||
first time. The <em>finalizer</em> will be called when an asynchronous generator
|
||
is about to be garbage collected.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.6: </span>See <span class="target" id="index-26"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0525"><strong>PEP 525</strong></a> for more details, and for a reference example of a
|
||
<em>finalizer</em> method see the implementation of
|
||
<code class="docutils literal notranslate"><span class="pre">asyncio.Loop.shutdown_asyncgens</span></code> in
|
||
<a class="reference external" href="https://github.com/python/cpython/tree/3.7/Lib/asyncio/base_events.py">Lib/asyncio/base_events.py</a></p>
|
||
</div>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>This function has been added on a provisional basis (see <span class="target" id="index-27"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0411"><strong>PEP 411</strong></a>
|
||
for details.)</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.set_coroutine_origin_tracking_depth">
|
||
<code class="descclassname">sys.</code><code class="descname">set_coroutine_origin_tracking_depth</code><span class="sig-paren">(</span><em>depth</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.set_coroutine_origin_tracking_depth" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Allows enabling or disabling coroutine origin tracking. When
|
||
enabled, the <code class="docutils literal notranslate"><span class="pre">cr_origin</span></code> attribute on coroutine objects will
|
||
contain a tuple of (filename, line number, function name) tuples
|
||
describing the traceback where the coroutine object was created,
|
||
with the most recent call first. When disabled, <code class="docutils literal notranslate"><span class="pre">cr_origin</span></code> will
|
||
be None.</p>
|
||
<p>To enable, pass a <em>depth</em> value greater than zero; this sets the
|
||
number of frames whose information will be captured. To disable,
|
||
pass set <em>depth</em> to zero.</p>
|
||
<p>This setting is thread-specific.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.7.</span></p>
|
||
</div>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>This function has been added on a provisional basis (see <span class="target" id="index-28"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0411"><strong>PEP 411</strong></a>
|
||
for details.) Use it only for debugging purposes.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys.set_coroutine_wrapper">
|
||
<code class="descclassname">sys.</code><code class="descname">set_coroutine_wrapper</code><span class="sig-paren">(</span><em>wrapper</em><span class="sig-paren">)</span><a class="headerlink" href="#sys.set_coroutine_wrapper" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Allows intercepting creation of <a class="reference internal" href="../glossary.html#term-coroutine"><span class="xref std std-term">coroutine</span></a> objects (only ones that
|
||
are created by an <a class="reference internal" href="../reference/compound_stmts.html#async-def"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">async</span> <span class="pre">def</span></code></a> function; generators decorated with
|
||
<a class="reference internal" href="types.html#types.coroutine" title="types.coroutine"><code class="xref py py-func docutils literal notranslate"><span class="pre">types.coroutine()</span></code></a> or <a class="reference internal" href="asyncio-task.html#asyncio.coroutine" title="asyncio.coroutine"><code class="xref py py-func docutils literal notranslate"><span class="pre">asyncio.coroutine()</span></code></a> will not be
|
||
intercepted).</p>
|
||
<p>The <em>wrapper</em> argument must be either:</p>
|
||
<ul class="simple">
|
||
<li><p>a callable that accepts one argument (a coroutine object);</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">None</span></code>, to reset the wrapper.</p></li>
|
||
</ul>
|
||
<p>If called twice, the new wrapper replaces the previous one. The function
|
||
is thread-specific.</p>
|
||
<p>The <em>wrapper</em> callable cannot define new coroutines directly or indirectly:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">wrapper</span><span class="p">(</span><span class="n">coro</span><span class="p">):</span>
|
||
<span class="k">async</span> <span class="k">def</span> <span class="nf">wrap</span><span class="p">(</span><span class="n">coro</span><span class="p">):</span>
|
||
<span class="k">return</span> <span class="k">await</span> <span class="n">coro</span>
|
||
<span class="k">return</span> <span class="n">wrap</span><span class="p">(</span><span class="n">coro</span><span class="p">)</span>
|
||
<span class="n">sys</span><span class="o">.</span><span class="n">set_coroutine_wrapper</span><span class="p">(</span><span class="n">wrapper</span><span class="p">)</span>
|
||
|
||
<span class="k">async</span> <span class="k">def</span> <span class="nf">foo</span><span class="p">():</span>
|
||
<span class="k">pass</span>
|
||
|
||
<span class="c1"># The following line will fail with a RuntimeError, because</span>
|
||
<span class="c1"># ``wrapper`` creates a ``wrap(coro)`` coroutine:</span>
|
||
<span class="n">foo</span><span class="p">()</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>See also <a class="reference internal" href="#sys.get_coroutine_wrapper" title="sys.get_coroutine_wrapper"><code class="xref py py-func docutils literal notranslate"><span class="pre">get_coroutine_wrapper()</span></code></a>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.5: </span>See <span class="target" id="index-29"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0492"><strong>PEP 492</strong></a> for more details.</p>
|
||
</div>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>This function has been added on a provisional basis (see <span class="target" id="index-30"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0411"><strong>PEP 411</strong></a>
|
||
for details.) Use it only for debugging purposes.</p>
|
||
</div>
|
||
<div class="deprecated">
|
||
<p><span class="versionmodified deprecated">Deprecated since version 3.7: </span>The coroutine wrapper functionality has been deprecated, and
|
||
will be removed in 3.8. See <a class="reference external" href="https://bugs.python.org/issue32591">bpo-32591</a> for details.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="function">
|
||
<dt id="sys._enablelegacywindowsfsencoding">
|
||
<code class="descclassname">sys.</code><code class="descname">_enablelegacywindowsfsencoding</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sys._enablelegacywindowsfsencoding" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>Changes the default filesystem encoding and errors mode to ‘mbcs’ and
|
||
‘replace’ respectively, for consistency with versions of Python prior to 3.6.</p>
|
||
<p>This is equivalent to defining the <span class="target" id="index-31"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONLEGACYWINDOWSFSENCODING"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONLEGACYWINDOWSFSENCODING</span></code></a>
|
||
environment variable before launching Python.</p>
|
||
<p class="availability"><a class="reference internal" href="intro.html#availability"><span class="std std-ref">Availability</span></a>: Windows.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.6: </span>See <span class="target" id="index-32"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0529"><strong>PEP 529</strong></a> for more details.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.stdin">
|
||
<code class="descclassname">sys.</code><code class="descname">stdin</code><a class="headerlink" href="#sys.stdin" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.stdout">
|
||
<code class="descclassname">sys.</code><code class="descname">stdout</code><a class="headerlink" href="#sys.stdout" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.stderr">
|
||
<code class="descclassname">sys.</code><code class="descname">stderr</code><a class="headerlink" href="#sys.stderr" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p><a class="reference internal" href="../glossary.html#term-file-object"><span class="xref std std-term">File objects</span></a> used by the interpreter for standard
|
||
input, output and errors:</p>
|
||
<ul class="simple">
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">stdin</span></code> is used for all interactive input (including calls to
|
||
<a class="reference internal" href="functions.html#input" title="input"><code class="xref py py-func docutils literal notranslate"><span class="pre">input()</span></code></a>);</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">stdout</span></code> is used for the output of <a class="reference internal" href="functions.html#print" title="print"><code class="xref py py-func docutils literal notranslate"><span class="pre">print()</span></code></a> and <a class="reference internal" href="../glossary.html#term-expression"><span class="xref std std-term">expression</span></a>
|
||
statements and for the prompts of <a class="reference internal" href="functions.html#input" title="input"><code class="xref py py-func docutils literal notranslate"><span class="pre">input()</span></code></a>;</p></li>
|
||
<li><p>The interpreter’s own prompts and its error messages go to <code class="docutils literal notranslate"><span class="pre">stderr</span></code>.</p></li>
|
||
</ul>
|
||
<p>These streams are regular <a class="reference internal" href="../glossary.html#term-text-file"><span class="xref std std-term">text files</span></a> like those
|
||
returned by the <a class="reference internal" href="functions.html#open" title="open"><code class="xref py py-func docutils literal notranslate"><span class="pre">open()</span></code></a> function. Their parameters are chosen as
|
||
follows:</p>
|
||
<ul>
|
||
<li><p>The character encoding is platform-dependent. Non-Windows
|
||
platforms use the locale encoding (see
|
||
<a class="reference internal" href="locale.html#locale.getpreferredencoding" title="locale.getpreferredencoding"><code class="xref py py-meth docutils literal notranslate"><span class="pre">locale.getpreferredencoding()</span></code></a>).</p>
|
||
<p>On Windows, UTF-8 is used for the console device. Non-character
|
||
devices such as disk files and pipes use the system locale
|
||
encoding (i.e. the ANSI codepage). Non-console character
|
||
devices such as NUL (i.e. where isatty() returns True) use the
|
||
value of the console input and output codepages at startup,
|
||
respectively for stdin and stdout/stderr. This defaults to the
|
||
system locale encoding if the process is not initially attached
|
||
to a console.</p>
|
||
<p>The special behaviour of the console can be overridden
|
||
by setting the environment variable PYTHONLEGACYWINDOWSSTDIO
|
||
before starting Python. In that case, the console codepages are
|
||
used as for any other character device.</p>
|
||
<p>Under all platforms, you can override the character encoding by
|
||
setting the <span class="target" id="index-33"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONIOENCODING"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONIOENCODING</span></code></a> environment variable before
|
||
starting Python or by using the new <a class="reference internal" href="../using/cmdline.html#id5"><code class="xref std std-option docutils literal notranslate"><span class="pre">-X</span></code></a> <code class="docutils literal notranslate"><span class="pre">utf8</span></code> command
|
||
line option and <span class="target" id="index-34"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONUTF8"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONUTF8</span></code></a> environment variable. However,
|
||
for the Windows console, this only applies when
|
||
<span class="target" id="index-35"></span><a class="reference internal" href="../using/cmdline.html#envvar-PYTHONLEGACYWINDOWSSTDIO"><code class="xref std std-envvar docutils literal notranslate"><span class="pre">PYTHONLEGACYWINDOWSSTDIO</span></code></a> is also set.</p>
|
||
</li>
|
||
<li><p>When interactive, <code class="docutils literal notranslate"><span class="pre">stdout</span></code> and <code class="docutils literal notranslate"><span class="pre">stderr</span></code> streams are line-buffered.
|
||
Otherwise, they are block-buffered like regular text files. You can
|
||
override this value with the <a class="reference internal" href="../using/cmdline.html#cmdoption-u"><code class="xref std std-option docutils literal notranslate"><span class="pre">-u</span></code></a> command-line option.</p></li>
|
||
</ul>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>To write or read binary data from/to the standard streams, use the
|
||
underlying binary <a class="reference internal" href="io.html#io.TextIOBase.buffer" title="io.TextIOBase.buffer"><code class="xref py py-data docutils literal notranslate"><span class="pre">buffer</span></code></a> object. For example, to
|
||
write bytes to <a class="reference internal" href="#sys.stdout" title="sys.stdout"><code class="xref py py-data docutils literal notranslate"><span class="pre">stdout</span></code></a>, use <code class="docutils literal notranslate"><span class="pre">sys.stdout.buffer.write(b'abc')</span></code>.</p>
|
||
<p>However, if you are writing a library (and do not control in which
|
||
context its code will be executed), be aware that the standard streams
|
||
may be replaced with file-like objects like <a class="reference internal" href="io.html#io.StringIO" title="io.StringIO"><code class="xref py py-class docutils literal notranslate"><span class="pre">io.StringIO</span></code></a> which
|
||
do not support the <code class="xref py py-attr docutils literal notranslate"><span class="pre">buffer</span></code> attribute.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.__stdin__">
|
||
<code class="descclassname">sys.</code><code class="descname">__stdin__</code><a class="headerlink" href="#sys.__stdin__" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.__stdout__">
|
||
<code class="descclassname">sys.</code><code class="descname">__stdout__</code><a class="headerlink" href="#sys.__stdout__" title="Permalink to this definition">¶</a></dt>
|
||
<dt id="sys.__stderr__">
|
||
<code class="descclassname">sys.</code><code class="descname">__stderr__</code><a class="headerlink" href="#sys.__stderr__" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>These objects contain the original values of <code class="docutils literal notranslate"><span class="pre">stdin</span></code>, <code class="docutils literal notranslate"><span class="pre">stderr</span></code> and
|
||
<code class="docutils literal notranslate"><span class="pre">stdout</span></code> at the start of the program. They are used during finalization,
|
||
and could be useful to print to the actual standard stream no matter if the
|
||
<code class="docutils literal notranslate"><span class="pre">sys.std*</span></code> object has been redirected.</p>
|
||
<p>It can also be used to restore the actual files to known working file objects
|
||
in case they have been overwritten with a broken object. However, the
|
||
preferred way to do this is to explicitly save the previous stream before
|
||
replacing it, and restore the saved object.</p>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>Under some conditions <code class="docutils literal notranslate"><span class="pre">stdin</span></code>, <code class="docutils literal notranslate"><span class="pre">stdout</span></code> and <code class="docutils literal notranslate"><span class="pre">stderr</span></code> as well as the
|
||
original values <code class="docutils literal notranslate"><span class="pre">__stdin__</span></code>, <code class="docutils literal notranslate"><span class="pre">__stdout__</span></code> and <code class="docutils literal notranslate"><span class="pre">__stderr__</span></code> can be
|
||
<code class="docutils literal notranslate"><span class="pre">None</span></code>. It is usually the case for Windows GUI apps that aren’t connected
|
||
to a console and Python apps started with <strong class="program">pythonw</strong>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.thread_info">
|
||
<code class="descclassname">sys.</code><code class="descname">thread_info</code><a class="headerlink" href="#sys.thread_info" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="../glossary.html#term-struct-sequence"><span class="xref std std-term">struct sequence</span></a> holding information about the thread
|
||
implementation.</p>
|
||
<table class="docutils align-center">
|
||
<colgroup>
|
||
<col style="width: 24%" />
|
||
<col style="width: 76%" />
|
||
</colgroup>
|
||
<thead>
|
||
<tr class="row-odd"><th class="head"><p>Attribute</p></th>
|
||
<th class="head"><p>Explanation</p></th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr class="row-even"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">name</span></code></p></td>
|
||
<td><p>Name of the thread implementation:</p>
|
||
<blockquote>
|
||
<div><ul class="simple">
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">'nt'</span></code>: Windows threads</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">'pthread'</span></code>: POSIX threads</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">'solaris'</span></code>: Solaris threads</p></li>
|
||
</ul>
|
||
</div></blockquote>
|
||
</td>
|
||
</tr>
|
||
<tr class="row-odd"><td><p><code class="xref py py-const docutils literal notranslate"><span class="pre">lock</span></code></p></td>
|
||
<td><p>Name of the lock implementation:</p>
|
||
<blockquote>
|
||
<div><ul class="simple">
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">'semaphore'</span></code>: a lock uses a semaphore</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">'mutex+cond'</span></code>: a lock uses a mutex
|
||
and a condition variable</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">None</span></code> if this information is unknown</p></li>
|
||
</ul>
|
||
</div></blockquote>
|
||
</td>
|
||
</tr>
|
||
<tr class="row-even"><td><p><a class="reference internal" href="#sys.version" title="sys.version"><code class="xref py py-const docutils literal notranslate"><span class="pre">version</span></code></a></p></td>
|
||
<td><p>Name and version of the thread library. It is a string,
|
||
or <code class="docutils literal notranslate"><span class="pre">None</span></code> if this information is unknown.</p></td>
|
||
</tr>
|
||
</tbody>
|
||
</table>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.3.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.tracebacklimit">
|
||
<code class="descclassname">sys.</code><code class="descname">tracebacklimit</code><a class="headerlink" href="#sys.tracebacklimit" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>When this variable is set to an integer value, it determines the maximum number
|
||
of levels of traceback information printed when an unhandled exception occurs.
|
||
The default is <code class="docutils literal notranslate"><span class="pre">1000</span></code>. When set to <code class="docutils literal notranslate"><span class="pre">0</span></code> or less, all traceback information
|
||
is suppressed and only the exception type and value are printed.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.version">
|
||
<code class="descclassname">sys.</code><code class="descname">version</code><a class="headerlink" href="#sys.version" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A string containing the version number of the Python interpreter plus additional
|
||
information on the build number and compiler used. This string is displayed
|
||
when the interactive interpreter is started. Do not extract version information
|
||
out of it, rather, use <a class="reference internal" href="#sys.version_info" title="sys.version_info"><code class="xref py py-data docutils literal notranslate"><span class="pre">version_info</span></code></a> and the functions provided by the
|
||
<a class="reference internal" href="platform.html#module-platform" title="platform: Retrieves as much platform identifying data as possible."><code class="xref py py-mod docutils literal notranslate"><span class="pre">platform</span></code></a> module.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.api_version">
|
||
<code class="descclassname">sys.</code><code class="descname">api_version</code><a class="headerlink" href="#sys.api_version" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>The C API version for this interpreter. Programmers may find this useful when
|
||
debugging version conflicts between Python and extension modules.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.version_info">
|
||
<code class="descclassname">sys.</code><code class="descname">version_info</code><a class="headerlink" href="#sys.version_info" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A tuple containing the five components of the version number: <em>major</em>, <em>minor</em>,
|
||
<em>micro</em>, <em>releaselevel</em>, and <em>serial</em>. All values except <em>releaselevel</em> are
|
||
integers; the release level is <code class="docutils literal notranslate"><span class="pre">'alpha'</span></code>, <code class="docutils literal notranslate"><span class="pre">'beta'</span></code>, <code class="docutils literal notranslate"><span class="pre">'candidate'</span></code>, or
|
||
<code class="docutils literal notranslate"><span class="pre">'final'</span></code>. The <code class="docutils literal notranslate"><span class="pre">version_info</span></code> value corresponding to the Python version 2.0
|
||
is <code class="docutils literal notranslate"><span class="pre">(2,</span> <span class="pre">0,</span> <span class="pre">0,</span> <span class="pre">'final',</span> <span class="pre">0)</span></code>. The components can also be accessed by name,
|
||
so <code class="docutils literal notranslate"><span class="pre">sys.version_info[0]</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">sys.version_info.major</span></code>
|
||
and so on.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.1: </span>Added named component attributes.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.warnoptions">
|
||
<code class="descclassname">sys.</code><code class="descname">warnoptions</code><a class="headerlink" href="#sys.warnoptions" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>This is an implementation detail of the warnings framework; do not modify this
|
||
value. Refer to the <a class="reference internal" href="warnings.html#module-warnings" title="warnings: Issue warning messages and control their disposition."><code class="xref py py-mod docutils literal notranslate"><span class="pre">warnings</span></code></a> module for more information on the warnings
|
||
framework.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys.winver">
|
||
<code class="descclassname">sys.</code><code class="descname">winver</code><a class="headerlink" href="#sys.winver" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>The version number used to form registry keys on Windows platforms. This is
|
||
stored as string resource 1000 in the Python DLL. The value is normally the
|
||
first three characters of <a class="reference internal" href="#sys.version" title="sys.version"><code class="xref py py-const docutils literal notranslate"><span class="pre">version</span></code></a>. It is provided in the <a class="reference internal" href="#module-sys" title="sys: Access system-specific parameters and functions."><code class="xref py py-mod docutils literal notranslate"><span class="pre">sys</span></code></a>
|
||
module for informational purposes; modifying this value has no effect on the
|
||
registry keys used by Python.</p>
|
||
<p class="availability"><a class="reference internal" href="intro.html#availability"><span class="std std-ref">Availability</span></a>: Windows.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="data">
|
||
<dt id="sys._xoptions">
|
||
<code class="descclassname">sys.</code><code class="descname">_xoptions</code><a class="headerlink" href="#sys._xoptions" title="Permalink to this definition">¶</a></dt>
|
||
<dd><p>A dictionary of the various implementation-specific flags passed through
|
||
the <a class="reference internal" href="../using/cmdline.html#id5"><code class="xref std std-option docutils literal notranslate"><span class="pre">-X</span></code></a> command-line option. Option names are either mapped to
|
||
their values, if given explicitly, or to <a class="reference internal" href="constants.html#True" title="True"><code class="xref py py-const docutils literal notranslate"><span class="pre">True</span></code></a>. Example:</p>
|
||
<div class="highlight-shell-session notranslate"><div class="highlight"><pre><span></span><span class="gp">$</span> ./python -Xa<span class="o">=</span>b -Xc
|
||
<span class="go">Python 3.2a3+ (py3k, Oct 16 2010, 20:14:50)</span>
|
||
<span class="go">[GCC 4.4.3] on linux2</span>
|
||
<span class="go">Type "help", "copyright", "credits" or "license" for more information.</span>
|
||
<span class="gp">></span>>> import sys
|
||
<span class="gp">></span>>> sys._xoptions
|
||
<span class="go">{'a': 'b', 'c': True}</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="impl-detail compound">
|
||
<p><strong>CPython implementation detail:</strong> This is a CPython-specific way of accessing options passed through
|
||
<a class="reference internal" href="../using/cmdline.html#id5"><code class="xref std std-option docutils literal notranslate"><span class="pre">-X</span></code></a>. Other implementations may export them through other
|
||
means, or not at all.</p>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">New in version 3.2.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<p class="rubric">Citations</p>
|
||
<dl class="citation">
|
||
<dt class="label" id="c99"><span class="brackets"><a class="fn-backref" href="#id1">C99</a></span></dt>
|
||
<dd><p>ISO/IEC 9899:1999. “Programming languages – C.” A public draft of this standard is available at <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf">http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf</a>.</p>
|
||
</dd>
|
||
</dl>
|
||
</div>
|
||
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
|
||
<div class="sphinxsidebarwrapper">
|
||
<h4>Previous topic</h4>
|
||
<p class="topless"><a href="python.html"
|
||
title="previous chapter">Python Runtime Services</a></p>
|
||
<h4>Next topic</h4>
|
||
<p class="topless"><a href="sysconfig.html"
|
||
title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">sysconfig</span></code> — Provide access to Python’s configuration information</a></p>
|
||
<div role="note" aria-label="source link">
|
||
<h3>This Page</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">Report a Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/3.7/Doc/library/sys.rst"
|
||
rel="nofollow">Show Source
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="clearer"></div>
|
||
</div>
|
||
<div class="related" role="navigation" aria-label="related navigation">
|
||
<h3>Navigation</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="General Index"
|
||
>index</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python Module Index"
|
||
>modules</a> |</li>
|
||
<li class="right" >
|
||
<a href="sysconfig.html" title="sysconfig — Provide access to Python’s configuration information"
|
||
>next</a> |</li>
|
||
<li class="right" >
|
||
<a href="python.html" title="Python Runtime Services"
|
||
>previous</a> |</li>
|
||
<li><img src="../_static/py.png" alt=""
|
||
style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li>
|
||
<span class="language_switcher_placeholder">en</span>
|
||
<span class="version_switcher_placeholder">3.7.4</span>
|
||
<a href="../index.html">Documentation </a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> »</li>
|
||
<li class="nav-item nav-item-2"><a href="python.html" >Python Runtime Services</a> »</li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" style="display: none" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="Quick search" type="text" name="q" />
|
||
<input type="submit" value="Go" />
|
||
<input type="hidden" name="check_keywords" value="yes" />
|
||
<input type="hidden" name="area" value="default" />
|
||
</form>
|
||
</div>
|
||
<script type="text/javascript">$('.inline-search').show(0);</script>
|
||
|
|
||
</li>
|
||
|
||
</ul>
|
||
</div>
|
||
<div class="footer">
|
||
© <a href="../copyright.html">Copyright</a> 2001-2019, Python Software Foundation.
|
||
<br />
|
||
The Python Software Foundation is a non-profit corporation.
|
||
<a href="https://www.python.org/psf/donations/">Please donate.</a>
|
||
<br />
|
||
Last updated on Jul 13, 2019.
|
||
<a href="../bugs.html">Found a bug</a>?
|
||
<br />
|
||
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 2.0.1.
|
||
</div>
|
||
|
||
</body>
|
||
</html> |