Spaces:
Sleeping
Sleeping
| <html lang="en" data-content_root="../"> | |
| <head> | |
| <meta charset="utf-8" /> | |
| <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" /> | |
| <meta property="og:title" content="ast — Abstract syntax trees" /> | |
| <meta property="og:type" content="website" /> | |
| <meta property="og:url" content="https://docs.python.org/3/library/ast.html" /> | |
| <meta property="og:site_name" content="Python documentation" /> | |
| <meta property="og:description" content="Source code: Lib/ast.py The ast module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this modul..." /> | |
| <meta property="og:image:width" content="1146" /> | |
| <meta property="og:image:height" content="600" /> | |
| <meta property="og:image" content="https://docs.python.org/3.15/_images/social_previews/summary_library_ast_6f4ec67a.png" /> | |
| <meta property="og:image:alt" content="Source code: Lib/ast.py The ast module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this modul..." /> | |
| <meta name="description" content="Source code: Lib/ast.py The ast module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this modul..." /> | |
| <meta name="twitter:card" content="summary_large_image" /> | |
| <meta name="theme-color" content="#3776ab"> | |
| <title>ast — Abstract syntax trees — Python 3.15.0a6 documentation</title><meta name="viewport" content="width=device-width, initial-scale=1.0"> | |
| <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=b86133f3" /> | |
| <link rel="stylesheet" type="text/css" href="../_static/classic.css?v=234b1a7c" /> | |
| <link rel="stylesheet" type="text/css" href="../_static/pydoctheme.css?v=89a2f22a" /> | |
| <link rel="stylesheet" type="text/css" href="../_static/profiling-sampling-visualization.css?v=0c2600ae" /> | |
| <link id="pygments_dark_css" media="(prefers-color-scheme: dark)" rel="stylesheet" type="text/css" href="../_static/pygments_dark.css?v=5349f25f" /> | |
| <script src="../_static/documentation_options.js?v=6b7c9ff5"></script> | |
| <script src="../_static/doctools.js?v=9bcbadda"></script> | |
| <script src="../_static/sphinx_highlight.js?v=dc90522c"></script> | |
| <script src="../_static/profiling-sampling-visualization.js?v=9811ed04"></script> | |
| <script src="../_static/sidebar.js"></script> | |
| <link rel="search" type="application/opensearchdescription+xml" | |
| title="Search within Python 3.15.0a6 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="symtable — Access to the compiler’s symbol tables" href="symtable.html" /> | |
| <link rel="prev" title="Python Language Services" href="language.html" /> | |
| <script defer file-types="bz2,epub,zip" data-domain="docs.python.org" src="https://analytics.python.org/js/script.file-downloads.outbound-links.js"></script> | |
| <link rel="canonical" href="https://docs.python.org/3/library/ast.html"> | |
| <style> | |
| @media only screen { | |
| table.full-width-table { | |
| width: 100%; | |
| } | |
| } | |
| </style> | |
| <link rel="stylesheet" href="../_static/pydoctheme_dark.css" media="(prefers-color-scheme: dark)" id="pydoctheme_dark_css"> | |
| <link rel="shortcut icon" type="image/png" href="../_static/py.svg"> | |
| <script type="text/javascript" src="../_static/copybutton.js"></script> | |
| <script type="text/javascript" src="../_static/menu.js"></script> | |
| <script type="text/javascript" src="../_static/search-focus.js"></script> | |
| <script type="text/javascript" src="../_static/themetoggle.js"></script> | |
| <script type="text/javascript" src="../_static/rtd_switcher.js"></script> | |
| <meta name="readthedocs-addons-api-version" content="1"> | |
| </head> | |
| <body> | |
| <div class="mobile-nav"> | |
| <input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation" | |
| aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu"> | |
| <nav class="nav-content" role="navigation"> | |
| <label for="menuToggler" class="toggler__label"> | |
| <span></span> | |
| </label> | |
| <span class="nav-items-wrapper"> | |
| <a href="https://www.python.org/" class="nav-logo"> | |
| <img src="../_static/py.svg" alt="Python logo"> | |
| </a> | |
| <span class="version_switcher_placeholder"></span> | |
| <form role="search" class="search" action="../search.html" method="get"> | |
| <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" class="search-icon"> | |
| <path fill-rule="nonzero" fill="currentColor" d="M15.5 14h-.79l-.28-.27a6.5 6.5 0 001.48-5.34c-.47-2.78-2.79-5-5.59-5.34a6.505 6.505 0 00-7.27 7.27c.34 2.8 2.56 5.12 5.34 5.59a6.5 6.5 0 005.34-1.48l.27.28v.79l4.25 4.25c.41.41 1.08.41 1.49 0 .41-.41.41-1.08 0-1.49L15.5 14zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path> | |
| </svg> | |
| <input placeholder="Quick search" aria-label="Quick search" type="search" name="q"> | |
| <input type="submit" value="Go"> | |
| </form> | |
| </span> | |
| </nav> | |
| <div class="menu-wrapper"> | |
| <nav class="menu" role="navigation" aria-label="main navigation"> | |
| <div class="language_switcher_placeholder"></div> | |
| <label class="theme-selector-label"> | |
| Theme | |
| <select class="theme-selector" oninput="activateTheme(this.value)"> | |
| <option value="auto" selected>Auto</option> | |
| <option value="light">Light</option> | |
| <option value="dark">Dark</option> | |
| </select> | |
| </label> | |
| <div> | |
| <h3><a href="../contents.html">Table of Contents</a></h3> | |
| <ul> | |
| <li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract syntax trees</a><ul> | |
| <li><a class="reference internal" href="#abstract-grammar">Abstract grammar</a></li> | |
| <li><a class="reference internal" href="#node-classes">Node classes</a><ul> | |
| <li><a class="reference internal" href="#root-nodes">Root nodes</a></li> | |
| <li><a class="reference internal" href="#literals">Literals</a></li> | |
| <li><a class="reference internal" href="#variables">Variables</a></li> | |
| <li><a class="reference internal" href="#expressions">Expressions</a><ul> | |
| <li><a class="reference internal" href="#subscripting">Subscripting</a></li> | |
| <li><a class="reference internal" href="#comprehensions">Comprehensions</a></li> | |
| </ul> | |
| </li> | |
| <li><a class="reference internal" href="#statements">Statements</a><ul> | |
| <li><a class="reference internal" href="#imports">Imports</a></li> | |
| </ul> | |
| </li> | |
| <li><a class="reference internal" href="#control-flow">Control flow</a></li> | |
| <li><a class="reference internal" href="#pattern-matching">Pattern matching</a></li> | |
| <li><a class="reference internal" href="#type-annotations">Type annotations</a></li> | |
| <li><a class="reference internal" href="#type-parameters">Type parameters</a></li> | |
| <li><a class="reference internal" href="#function-and-class-definitions">Function and class definitions</a></li> | |
| <li><a class="reference internal" href="#async-and-await">Async and await</a></li> | |
| </ul> | |
| </li> | |
| <li><a class="reference internal" href="#ast-helpers"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> helpers</a></li> | |
| <li><a class="reference internal" href="#compiler-flags">Compiler flags</a></li> | |
| <li><a class="reference internal" href="#command-line-usage">Command-line usage</a></li> | |
| </ul> | |
| </li> | |
| </ul> | |
| </div> | |
| <div> | |
| <h4>Previous topic</h4> | |
| <p class="topless"><a href="language.html" | |
| title="previous chapter">Python Language Services</a></p> | |
| </div> | |
| <div> | |
| <h4>Next topic</h4> | |
| <p class="topless"><a href="symtable.html" | |
| title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">symtable</span></code> — Access to the compiler’s symbol tables</a></p> | |
| </div> | |
| <script> | |
| document.addEventListener('DOMContentLoaded', () => { | |
| const title = document.querySelector('meta[property="og:title"]').content; | |
| const elements = document.querySelectorAll('.improvepage'); | |
| const pageurl = window.location.href.split('?')[0]; | |
| elements.forEach(element => { | |
| const url = new URL(element.href.split('?')[0].replace("-nojs", "")); | |
| url.searchParams.set('pagetitle', title); | |
| url.searchParams.set('pageurl', pageurl); | |
| url.searchParams.set('pagesource', "library/ast.rst"); | |
| element.href = url.toString(); | |
| }); | |
| }); | |
| </script> | |
| <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 class="improvepage" href="../improve-page-nojs.html">Improve this page</a></li> | |
| <li> | |
| <a href="https://github.com/python/cpython/blob/main/Doc/library/ast.rst?plain=1" | |
| rel="nofollow">Show source | |
| </a> | |
| </li> | |
| </ul> | |
| </div> | |
| </nav> | |
| </div> | |
| </div> | |
| <div class="related" role="navigation" aria-label="Related"> | |
| <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="symtable.html" title="symtable — Access to the compiler’s symbol tables" | |
| accesskey="N">next</a> |</li> | |
| <li class="right" > | |
| <a href="language.html" title="Python Language Services" | |
| accesskey="P">previous</a> |</li> | |
| <li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"></li> | |
| <li><a href="https://www.python.org/">Python</a> »</li> | |
| <li class="switchers"> | |
| <div class="language_switcher_placeholder"></div> | |
| <div class="version_switcher_placeholder"></div> | |
| </li> | |
| <li> | |
| </li> | |
| <li id="cpython-language-and-version"> | |
| <a href="../index.html">3.15.0a6 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="language.html" accesskey="U">Python Language Services</a> »</li> | |
| <li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract syntax trees</a></li> | |
| <li class="right"> | |
| <div class="inline-search" role="search"> | |
| <form class="inline-search" action="../search.html" method="get"> | |
| <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box"> | |
| <input type="submit" value="Go"> | |
| </form> | |
| </div> | |
| | | |
| </li> | |
| <li class="right"> | |
| <label class="theme-selector-label"> | |
| Theme | |
| <select class="theme-selector" oninput="activateTheme(this.value)"> | |
| <option value="auto" selected>Auto</option> | |
| <option value="light">Light</option> | |
| <option value="dark">Dark</option> | |
| </select> | |
| </label> |</li> | |
| </ul> | |
| </div> | |
| <div class="document"> | |
| <div class="documentwrapper"> | |
| <div class="bodywrapper"> | |
| <div class="body" role="main"> | |
| <section id="module-ast"> | |
| <span id="ast-abstract-syntax-trees"></span><h1><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract syntax trees<a class="headerlink" href="#module-ast" title="Link to this heading">¶</a></h1> | |
| <p><strong>Source code:</strong> <a class="extlink-source reference external" href="https://github.com/python/cpython/tree/main/Lib/ast.py">Lib/ast.py</a></p> | |
| <hr class="docutils" /> | |
| <p>The <code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> module helps Python applications to process trees of the Python | |
| abstract syntax grammar. The abstract syntax itself might change with each | |
| Python release; this module helps to find out programmatically what the current | |
| grammar looks like.</p> | |
| <p>An abstract syntax tree can be generated by passing <a class="reference internal" href="#ast.PyCF_ONLY_AST" title="ast.PyCF_ONLY_AST"><code class="xref py py-data docutils literal notranslate"><span class="pre">ast.PyCF_ONLY_AST</span></code></a> as | |
| a flag to the <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a> built-in function, or using the <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">parse()</span></code></a> | |
| helper provided in this module. The result will be a tree of objects whose | |
| classes all inherit from <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.AST</span></code></a>. An abstract syntax tree can be | |
| compiled into a Python code object using the built-in <code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code> function.</p> | |
| <section id="abstract-grammar"> | |
| <span id="id1"></span><h2>Abstract grammar<a class="headerlink" href="#abstract-grammar" title="Link to this heading">¶</a></h2> | |
| <p>The abstract grammar is currently defined as follows:</p> | |
| <div class="highlight-asdl notranslate"><div class="highlight"><pre><span></span><span class="c c-Singleline">-- ASDL's 4 builtin types are:</span> | |
| <span class="c c-Singleline">-- identifier, int, string, constant</span> | |
| <span class="k">module</span> <span class="nt">Python</span> | |
| <span class="p">{</span> | |
| <span class="n">mod</span> <span class="o">=</span> <span class="nc">Module</span><span class="p">(</span><span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">type_ignore</span><span class="o">* </span><span class="n">type_ignores</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Interactive</span><span class="p">(</span><span class="bp">stmt</span><span class="o">* </span><span class="n">body</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Expression</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">body</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">FunctionType</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">argtypes</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">returns</span><span class="p">)</span> | |
| <span class="n">stmt</span> <span class="o">=</span> <span class="nc">FunctionDef</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">arguments</span><span class="o"> </span><span class="n">args</span>, | |
| <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">decorator_list</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">returns</span>, | |
| <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span>, <span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">AsyncFunctionDef</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">arguments</span><span class="o"> </span><span class="n">args</span>, | |
| <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">decorator_list</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">returns</span>, | |
| <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span>, <span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">ClassDef</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, | |
| <span class="bp">expr</span><span class="o">* </span><span class="n">bases</span>, | |
| <span class="bp">keyword</span><span class="o">* </span><span class="n">keywords</span>, | |
| <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, | |
| <span class="bp">expr</span><span class="o">* </span><span class="n">decorator_list</span>, | |
| <span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Return</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Delete</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">targets</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Assign</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">targets</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">TypeAlias</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">name</span>, <span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">AugAssign</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">operator</span><span class="o"> </span><span class="n">op</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- 'simple' indicates that we annotate simple name without parens</span> | |
| <span class="o">|</span> <span class="nc">AnnAssign</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">annotation</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">value</span>, <span class="bp">int</span><span class="o"> </span><span class="n">simple</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- use 'orelse' because else is a keyword in target languages</span> | |
| <span class="o">|</span> <span class="nc">For</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">iter</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">AsyncFor</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">iter</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">While</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">test</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">If</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">test</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">With</span><span class="p">(</span><span class="bp">withitem</span><span class="o">* </span><span class="n">items</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">AsyncWith</span><span class="p">(</span><span class="bp">withitem</span><span class="o">* </span><span class="n">items</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Match</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">subject</span>, <span class="bp">match_case</span><span class="o">* </span><span class="n">cases</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Raise</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">exc</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">cause</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Try</span><span class="p">(</span><span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">excepthandler</span><span class="o">* </span><span class="n">handlers</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">finalbody</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">TryStar</span><span class="p">(</span><span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">excepthandler</span><span class="o">* </span><span class="n">handlers</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">finalbody</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Assert</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">test</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">msg</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Import</span><span class="p">(</span><span class="bp">alias</span><span class="o">* </span><span class="n">names</span>, <span class="bp">int</span><span class="o">? </span><span class="n">is_lazy</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">ImportFrom</span><span class="p">(</span><span class="bp">identifier</span><span class="o">? </span><span class="n">module</span>, <span class="bp">alias</span><span class="o">* </span><span class="n">names</span>, <span class="bp">int</span><span class="o">? </span><span class="n">level</span>, <span class="bp">int</span><span class="o">? </span><span class="n">is_lazy</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Global</span><span class="p">(</span><span class="bp">identifier</span><span class="o">* </span><span class="n">names</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Nonlocal</span><span class="p">(</span><span class="bp">identifier</span><span class="o">* </span><span class="n">names</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Expr</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Pass</span> <span class="o">|</span> <span class="nc">Break</span> <span class="o">|</span> <span class="nc">Continue</span> | |
| <span class="c c-Singleline">-- col_offset is the byte offset in the utf8 string the parser uses</span> | |
| <span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- BoolOp() can use left & right?</span> | |
| <span class="n">expr</span> <span class="o">=</span> <span class="nc">BoolOp</span><span class="p">(</span><span class="bp">boolop</span><span class="o"> </span><span class="n">op</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">values</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">NamedExpr</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">BinOp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">left</span>, <span class="bp">operator</span><span class="o"> </span><span class="n">op</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">right</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">UnaryOp</span><span class="p">(</span><span class="bp">unaryop</span><span class="o"> </span><span class="n">op</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">operand</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Lambda</span><span class="p">(</span><span class="bp">arguments</span><span class="o"> </span><span class="n">args</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">body</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">IfExp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">test</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">body</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">orelse</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Dict</span><span class="p">(</span><span class="bp">expr</span><span class="o">?* </span><span class="n">keys</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">values</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Set</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">elts</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">ListComp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">elt</span>, <span class="bp">comprehension</span><span class="o">* </span><span class="n">generators</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">SetComp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">elt</span>, <span class="bp">comprehension</span><span class="o">* </span><span class="n">generators</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">DictComp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">key</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">value</span>, <span class="bp">comprehension</span><span class="o">* </span><span class="n">generators</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">GeneratorExp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">elt</span>, <span class="bp">comprehension</span><span class="o">* </span><span class="n">generators</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- the grammar constrains where yield expressions can occur</span> | |
| <span class="o">|</span> <span class="nc">Await</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Yield</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">YieldFrom</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- need sequences for compare to distinguish between</span> | |
| <span class="c c-Singleline">-- x < 4 < 3 and (x < 4) < 3</span> | |
| <span class="o">|</span> <span class="nc">Compare</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">left</span>, <span class="bp">cmpop</span><span class="o">* </span><span class="n">ops</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">comparators</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Call</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">func</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">args</span>, <span class="bp">keyword</span><span class="o">* </span><span class="n">keywords</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">FormattedValue</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">int</span><span class="o"> </span><span class="n">conversion</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">format_spec</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Interpolation</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">constant</span><span class="o"> </span><span class="n">str</span>, <span class="bp">int</span><span class="o"> </span><span class="n">conversion</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">format_spec</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">JoinedStr</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">values</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">TemplateStr</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">values</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Constant</span><span class="p">(</span><span class="bp">constant</span><span class="o"> </span><span class="n">value</span>, <span class="bp">string</span><span class="o">? </span><span class="n">kind</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- the following expression can appear in assignment context</span> | |
| <span class="o">|</span> <span class="nc">Attribute</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">identifier</span><span class="o"> </span><span class="n">attr</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Subscript</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">slice</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Starred</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Name</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">id</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">List</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">elts</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">Tuple</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">elts</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- can appear only in Subscript</span> | |
| <span class="o">|</span> <span class="nc">Slice</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">lower</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">upper</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">step</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- col_offset is the byte offset in the utf8 string the parser uses</span> | |
| <span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span> | |
| <span class="n">expr_context</span> <span class="o">=</span> <span class="nc">Load</span> <span class="o">|</span> <span class="nc">Store</span> <span class="o">|</span> <span class="nc">Del</span> | |
| <span class="n">boolop</span> <span class="o">=</span> <span class="nc">And</span> <span class="o">|</span> <span class="nc">Or</span> | |
| <span class="n">operator</span> <span class="o">=</span> <span class="nc">Add</span> <span class="o">|</span> <span class="nc">Sub</span> <span class="o">|</span> <span class="nc">Mult</span> <span class="o">|</span> <span class="nc">MatMult</span> <span class="o">|</span> <span class="nc">Div</span> <span class="o">|</span> <span class="nc">Mod</span> <span class="o">|</span> <span class="nc">Pow</span> <span class="o">|</span> <span class="nc">LShift</span> | |
| <span class="o">|</span> <span class="nc">RShift</span> <span class="o">|</span> <span class="nc">BitOr</span> <span class="o">|</span> <span class="nc">BitXor</span> <span class="o">|</span> <span class="nc">BitAnd</span> <span class="o">|</span> <span class="nc">FloorDiv</span> | |
| <span class="n">unaryop</span> <span class="o">=</span> <span class="nc">Invert</span> <span class="o">|</span> <span class="nc">Not</span> <span class="o">|</span> <span class="nc">UAdd</span> <span class="o">|</span> <span class="nc">USub</span> | |
| <span class="n">cmpop</span> <span class="o">=</span> <span class="nc">Eq</span> <span class="o">|</span> <span class="nc">NotEq</span> <span class="o">|</span> <span class="nc">Lt</span> <span class="o">|</span> <span class="nc">LtE</span> <span class="o">|</span> <span class="nc">Gt</span> <span class="o">|</span> <span class="nc">GtE</span> <span class="o">|</span> <span class="nc">Is</span> <span class="o">|</span> <span class="nc">IsNot</span> <span class="o">|</span> <span class="nc">In</span> <span class="o">|</span> <span class="nc">NotIn</span> | |
| <span class="n">comprehension</span> <span class="o">=</span> <span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">iter</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">ifs</span>, <span class="bp">int</span><span class="o"> </span><span class="n">is_async</span><span class="p">)</span> | |
| <span class="n">excepthandler</span> <span class="o">=</span> <span class="nc">ExceptHandler</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">type</span>, <span class="bp">identifier</span><span class="o">? </span><span class="n">name</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span><span class="p">)</span> | |
| <span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span> | |
| <span class="n">arguments</span> <span class="o">=</span> <span class="p">(</span><span class="bp">arg</span><span class="o">* </span><span class="n">posonlyargs</span>, <span class="bp">arg</span><span class="o">* </span><span class="n">args</span>, <span class="bp">arg</span><span class="o">? </span><span class="n">vararg</span>, <span class="bp">arg</span><span class="o">* </span><span class="n">kwonlyargs</span>, | |
| <span class="bp">expr</span><span class="o">?* </span><span class="n">kw_defaults</span>, <span class="bp">arg</span><span class="o">? </span><span class="n">kwarg</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">defaults</span><span class="p">)</span> | |
| <span class="n">arg</span> <span class="o">=</span> <span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">arg</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">annotation</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span> | |
| <span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- keyword arguments supplied to call (NULL identifier for **kwargs)</span> | |
| <span class="n">keyword</span> <span class="o">=</span> <span class="p">(</span><span class="bp">identifier</span><span class="o">? </span><span class="n">arg</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- import name with optional 'as' alias.</span> | |
| <span class="n">alias</span> <span class="o">=</span> <span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">identifier</span><span class="o">? </span><span class="n">asname</span><span class="p">)</span> | |
| <span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span> | |
| <span class="n">withitem</span> <span class="o">=</span> <span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">context_expr</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">optional_vars</span><span class="p">)</span> | |
| <span class="n">match_case</span> <span class="o">=</span> <span class="p">(</span><span class="bp">pattern</span><span class="o"> </span><span class="n">pattern</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">guard</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span><span class="p">)</span> | |
| <span class="n">pattern</span> <span class="o">=</span> <span class="nc">MatchValue</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">MatchSingleton</span><span class="p">(</span><span class="bp">constant</span><span class="o"> </span><span class="n">value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">MatchSequence</span><span class="p">(</span><span class="bp">pattern</span><span class="o">* </span><span class="n">patterns</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">MatchMapping</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">keys</span>, <span class="bp">pattern</span><span class="o">* </span><span class="n">patterns</span>, <span class="bp">identifier</span><span class="o">? </span><span class="n">rest</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">MatchClass</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">cls</span>, <span class="bp">pattern</span><span class="o">* </span><span class="n">patterns</span>, <span class="bp">identifier</span><span class="o">* </span><span class="n">kwd_attrs</span>, <span class="bp">pattern</span><span class="o">* </span><span class="n">kwd_patterns</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">MatchStar</span><span class="p">(</span><span class="bp">identifier</span><span class="o">? </span><span class="n">name</span><span class="p">)</span> | |
| <span class="c c-Singleline">-- The optional "rest" MatchMapping parameter handles capturing extra mapping keys</span> | |
| <span class="o">|</span> <span class="nc">MatchAs</span><span class="p">(</span><span class="bp">pattern</span><span class="o">? </span><span class="n">pattern</span>, <span class="bp">identifier</span><span class="o">? </span><span class="n">name</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">MatchOr</span><span class="p">(</span><span class="bp">pattern</span><span class="o">* </span><span class="n">patterns</span><span class="p">)</span> | |
| <span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o"> </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">end_col_offset</span><span class="p">)</span> | |
| <span class="n">type_ignore</span> <span class="o">=</span> <span class="nc">TypeIgnore</span><span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">string</span><span class="o"> </span><span class="n">tag</span><span class="p">)</span> | |
| <span class="n">type_param</span> <span class="o">=</span> <span class="nc">TypeVar</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">bound</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">default_value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">ParamSpec</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">default_value</span><span class="p">)</span> | |
| <span class="o">|</span> <span class="nc">TypeVarTuple</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">default_value</span><span class="p">)</span> | |
| <span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o"> </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">end_col_offset</span><span class="p">)</span> | |
| <span class="p">}</span> | |
| </pre></div> | |
| </div> | |
| </section> | |
| <section id="node-classes"> | |
| <h2>Node classes<a class="headerlink" href="#node-classes" title="Link to this heading">¶</a></h2> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.AST"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AST</span></span><a class="headerlink" href="#ast.AST" title="Link to this definition">¶</a></dt> | |
| <dd><p>This is the base of all AST node classes. The actual node classes are | |
| derived from the <code class="file docutils literal notranslate"><span class="pre">Parser/Python.asdl</span></code> file, which is reproduced | |
| <a class="reference internal" href="#abstract-grammar"><span class="std std-ref">above</span></a>. They are defined in the <code class="xref py py-mod docutils literal notranslate"><span class="pre">_ast</span></code> C | |
| module and re-exported in <code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code>.</p> | |
| <p>There is one class defined for each left-hand side symbol in the abstract | |
| grammar (for example, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.stmt</span></code> or <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr</span></code>). In addition, | |
| there is one class defined for each constructor on the right-hand side; these | |
| classes inherit from the classes for the left-hand side trees. For example, | |
| <a class="reference internal" href="#ast.BinOp" title="ast.BinOp"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.BinOp</span></code></a> inherits from <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr</span></code>. For production rules | |
| with alternatives (aka “sums”), the left-hand side class is abstract: only | |
| instances of specific constructor nodes are ever created.</p> | |
| <dl class="py attribute" id="index-1"> | |
| <span id="index-0"></span><dt class="sig sig-object py" id="ast.AST._fields"> | |
| <span class="sig-name descname"><span class="pre">_fields</span></span><a class="headerlink" href="#ast.AST._fields" title="Link to this definition">¶</a></dt> | |
| <dd><p>Each concrete class has an attribute <code class="xref py py-attr docutils literal notranslate"><span class="pre">_fields</span></code> which gives the names | |
| of all child nodes.</p> | |
| <p>Each instance of a concrete class has one attribute for each child node, | |
| of the type as defined in the grammar. For example, <a class="reference internal" href="#ast.BinOp" title="ast.BinOp"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.BinOp</span></code></a> | |
| instances have an attribute <code class="xref py py-attr docutils literal notranslate"><span class="pre">left</span></code> of type <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr</span></code>.</p> | |
| <p>If these attributes are marked as optional in the grammar (using a | |
| question mark), the value might be <code class="docutils literal notranslate"><span class="pre">None</span></code>. If the attributes can have | |
| zero-or-more values (marked with an asterisk), the values are represented | |
| as Python lists. All possible attributes must be present and have valid | |
| values when compiling an AST with <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a>.</p> | |
| </dd></dl> | |
| <dl class="py attribute"> | |
| <dt class="sig sig-object py" id="ast.AST._field_types"> | |
| <span class="sig-name descname"><span class="pre">_field_types</span></span><a class="headerlink" href="#ast.AST._field_types" title="Link to this definition">¶</a></dt> | |
| <dd><p>The <code class="xref py py-attr docutils literal notranslate"><span class="pre">_field_types</span></code> attribute on each concrete class is a dictionary | |
| mapping field names (as also listed in <a class="reference internal" href="#ast.AST._fields" title="ast.AST._fields"><code class="xref py py-attr docutils literal notranslate"><span class="pre">_fields</span></code></a>) to their types.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">ast</span><span class="o">.</span><span class="n">TypeVar</span><span class="o">.</span><span class="n">_field_types</span> | |
| <span class="go">{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr | None}</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.13.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py attribute"> | |
| <dt class="sig sig-object py" id="ast.AST.lineno"> | |
| <span class="sig-name descname"><span class="pre">lineno</span></span><a class="headerlink" href="#ast.AST.lineno" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.AST.col_offset"> | |
| <span class="sig-name descname"><span class="pre">col_offset</span></span><a class="headerlink" href="#ast.AST.col_offset" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.AST.end_lineno"> | |
| <span class="sig-name descname"><span class="pre">end_lineno</span></span><a class="headerlink" href="#ast.AST.end_lineno" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.AST.end_col_offset"> | |
| <span class="sig-name descname"><span class="pre">end_col_offset</span></span><a class="headerlink" href="#ast.AST.end_col_offset" title="Link to this definition">¶</a></dt> | |
| <dd><p>Instances of <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr</span></code> and <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.stmt</span></code> subclasses have | |
| <a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a>, <a class="reference internal" href="#ast.AST.col_offset" title="ast.AST.col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code></a>, <a class="reference internal" href="#ast.AST.end_lineno" title="ast.AST.end_lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_lineno</span></code></a>, and | |
| <a class="reference internal" href="#ast.AST.end_col_offset" title="ast.AST.end_col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_col_offset</span></code></a> attributes. The <code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">end_lineno</span></code> | |
| are the first and last line numbers of source text span (1-indexed so the | |
| first line is line 1) and the <code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">end_col_offset</span></code> | |
| are the corresponding UTF-8 byte offsets of the first and last tokens that | |
| generated the node. The UTF-8 offset is recorded because the parser uses | |
| UTF-8 internally.</p> | |
| <p>Note that the end positions are not required by the compiler and are | |
| therefore optional. The end offset is <em>after</em> the last symbol, for example | |
| one can get the source segment of a one-line expression node using | |
| <code class="docutils literal notranslate"><span class="pre">source_line[node.col_offset</span> <span class="pre">:</span> <span class="pre">node.end_col_offset]</span></code>.</p> | |
| </dd></dl> | |
| <p>The constructor of a class <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.T</span></code> parses its arguments as follows:</p> | |
| <ul class="simple"> | |
| <li><p>If there are positional arguments, there must be as many as there are items | |
| in <code class="xref py py-attr docutils literal notranslate"><span class="pre">T._fields</span></code>; they will be assigned as attributes of these names.</p></li> | |
| <li><p>If there are keyword arguments, they will set the attributes of the same | |
| names to the given values.</p></li> | |
| </ul> | |
| <p>For example, to create and populate an <a class="reference internal" href="#ast.UnaryOp" title="ast.UnaryOp"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.UnaryOp</span></code></a> node, you could | |
| use</p> | |
| <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">node</span> <span class="o">=</span> <span class="n">ast</span><span class="o">.</span><span class="n">UnaryOp</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">USub</span><span class="p">(),</span> <span class="n">ast</span><span class="o">.</span><span class="n">Constant</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="n">lineno</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">col_offset</span><span class="o">=</span><span class="mi">0</span><span class="p">),</span> | |
| <span class="n">lineno</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">col_offset</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span> | |
| </pre></div> | |
| </div> | |
| <p>If a field that is optional in the grammar is omitted from the constructor, | |
| it defaults to <code class="docutils literal notranslate"><span class="pre">None</span></code>. If a list field is omitted, it defaults to the empty | |
| list. If a field of type <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr_context</span></code> is omitted, it defaults to | |
| <a class="reference internal" href="#ast.Load" title="ast.Load"><code class="xref py py-class docutils literal notranslate"><span class="pre">Load()</span></code></a>. If any other field is omitted, a <a class="reference internal" href="exceptions.html#DeprecationWarning" title="DeprecationWarning"><code class="xref py py-exc docutils literal notranslate"><span class="pre">DeprecationWarning</span></code></a> is raised | |
| and the AST node will not have this field. In Python 3.15, this condition will | |
| raise an error.</p> | |
| </dd></dl> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.8: </span>Class <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Constant</span></code></a> is now used for all constants.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.9: </span>Simple indices are represented by their value, extended slices are | |
| represented as tuples.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.14: </span>The <a class="reference internal" href="../reference/datamodel.html#object.__repr__" title="object.__repr__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__repr__()</span></code></a> output of <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">AST</span></code></a> nodes includes | |
| the values of the node fields.</p> | |
| </div> | |
| <div class="deprecated-removed"> | |
| <p><span class="versionmodified removed">Deprecated since version 3.8, removed in version 3.14: </span>Previous versions of Python provided the AST classes <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Num</span></code>, | |
| <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Str</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Bytes</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.NameConstant</span></code> and | |
| <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Ellipsis</span></code>, which were deprecated in Python 3.8. These classes | |
| were removed in Python 3.14, and their functionality has been replaced with | |
| <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Constant</span></code></a>.</p> | |
| </div> | |
| <div class="deprecated"> | |
| <p><span class="versionmodified deprecated">Deprecated since version 3.9: </span>Old classes <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Index</span></code> and <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.ExtSlice</span></code> are still | |
| available, but they will be removed in future Python releases. | |
| In the meantime, instantiating them will return an instance of | |
| a different class.</p> | |
| </div> | |
| <div class="deprecated-removed"> | |
| <p><span class="versionmodified removed">Deprecated since version 3.13, removed in version 3.15: </span>Previous versions of Python allowed the creation of AST nodes that were missing | |
| required fields. Similarly, AST node constructors allowed arbitrary keyword | |
| arguments that were set as attributes of the AST node, even if they did not | |
| match any of the fields of the AST node. This behavior is deprecated and will | |
| be removed in Python 3.15.</p> | |
| </div> | |
| <div class="admonition note"> | |
| <p class="admonition-title">Note</p> | |
| <p>The descriptions of the specific node classes displayed here | |
| were initially adapted from the fantastic <a class="reference external" href="https://greentreesnakes.readthedocs.io/en/latest/">Green Tree | |
| Snakes</a> project and | |
| all its contributors.</p> | |
| </div> | |
| <section id="root-nodes"> | |
| <span id="ast-root-nodes"></span><h3>Root nodes<a class="headerlink" href="#root-nodes" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Module"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Module</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_ignores</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Module" title="Link to this definition">¶</a></dt> | |
| <dd><p>A Python module, as with <a class="reference internal" href="../reference/toplevel_components.html#file-input"><span class="std std-ref">file input</span></a>. | |
| Node type generated by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> in the default <code class="docutils literal notranslate"><span class="pre">"exec"</span></code> <em>mode</em>.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> of the module’s <a class="reference internal" href="#ast-statements"><span class="std std-ref">Statements</span></a>.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">type_ignores</span></code> is a <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> of the module’s type ignore comments; | |
| see <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> for more details.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x = 1'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Assign(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Name(id='x', ctx=Store())],</span> | |
| <span class="go"> value=Constant(value=1))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Expression"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Expression</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Expression" title="Link to this definition">¶</a></dt> | |
| <dd><p>A single Python <a class="reference internal" href="../reference/toplevel_components.html#expression-input"><span class="std std-ref">expression input</span></a>. | |
| Node type generated by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> when <em>mode</em> is <code class="docutils literal notranslate"><span class="pre">"eval"</span></code>.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a single node, | |
| one of the <a class="reference internal" href="#ast-expressions"><span class="std std-ref">expression types</span></a>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'123'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Constant(value=123))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Interactive"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Interactive</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Interactive" title="Link to this definition">¶</a></dt> | |
| <dd><p>A single <a class="reference internal" href="../reference/toplevel_components.html#interactive"><span class="std std-ref">interactive input</span></a>, like in <a class="reference internal" href="../tutorial/appendix.html#tut-interac"><span class="std std-ref">Interactive Mode</span></a>. | |
| Node type generated by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> when <em>mode</em> is <code class="docutils literal notranslate"><span class="pre">"single"</span></code>.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> of <a class="reference internal" href="#ast-statements"><span class="std std-ref">statement nodes</span></a>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x = 1; y = 2'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'single'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Interactive(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Assign(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Name(id='x', ctx=Store())],</span> | |
| <span class="go"> value=Constant(value=1)),</span> | |
| <span class="go"> Assign(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Name(id='y', ctx=Store())],</span> | |
| <span class="go"> value=Constant(value=2))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.FunctionType"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">FunctionType</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">argtypes</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">returns</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.FunctionType" title="Link to this definition">¶</a></dt> | |
| <dd><p>A representation of an old-style type comments for functions, | |
| as Python versions prior to 3.5 didn’t support <span class="target" id="index-2"></span><a class="pep reference external" href="https://peps.python.org/pep-0484/"><strong>PEP 484</strong></a> annotations. | |
| Node type generated by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> when <em>mode</em> is <code class="docutils literal notranslate"><span class="pre">"func_type"</span></code>.</p> | |
| <p>Such type comments would look like this:</p> | |
| <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">sum_two_number</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span> | |
| <span class="c1"># type: (int, int) -> int</span> | |
| <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span> | |
| </pre></div> | |
| </div> | |
| <p><code class="docutils literal notranslate"><span class="pre">argtypes</span></code> is a <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> of <a class="reference internal" href="#ast-expressions"><span class="std std-ref">expression nodes</span></a>.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">returns</span></code> is a single <a class="reference internal" href="#ast-expressions"><span class="std std-ref">expression node</span></a>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(int, str) -> List[int]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'func_type'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">FunctionType(</span> | |
| <span class="go"> argtypes=[</span> | |
| <span class="go"> Name(id='int'),</span> | |
| <span class="go"> Name(id='str')],</span> | |
| <span class="go"> returns=Subscript(</span> | |
| <span class="go"> value=Name(id='List'),</span> | |
| <span class="go"> slice=Name(id='int')))</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.8.</span></p> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="literals"> | |
| <h3>Literals<a class="headerlink" href="#literals" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Constant"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Constant</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Constant" title="Link to this definition">¶</a></dt> | |
| <dd><p>A constant value. The <code class="docutils literal notranslate"><span class="pre">value</span></code> attribute of the <code class="docutils literal notranslate"><span class="pre">Constant</span></code> literal contains the | |
| Python object it represents. The values represented can be instances of <a class="reference internal" href="stdtypes.html#str" title="str"><code class="xref py py-class docutils literal notranslate"><span class="pre">str</span></code></a>, | |
| <a class="reference internal" href="stdtypes.html#bytes" title="bytes"><code class="xref py py-class docutils literal notranslate"><span class="pre">bytes</span></code></a>, <a class="reference internal" href="functions.html#int" title="int"><code class="xref py py-class docutils literal notranslate"><span class="pre">int</span></code></a>, <a class="reference internal" href="functions.html#float" title="float"><code class="xref py py-class docutils literal notranslate"><span class="pre">float</span></code></a>, <a class="reference internal" href="functions.html#complex" title="complex"><code class="xref py py-class docutils literal notranslate"><span class="pre">complex</span></code></a>, and <a class="reference internal" href="functions.html#bool" title="bool"><code class="xref py py-class docutils literal notranslate"><span class="pre">bool</span></code></a>, | |
| and the constants <a class="reference internal" href="constants.html#None" title="None"><code class="xref py py-data docutils literal notranslate"><span class="pre">None</span></code></a> and <a class="reference internal" href="constants.html#Ellipsis" title="Ellipsis"><code class="xref py py-data docutils literal notranslate"><span class="pre">Ellipsis</span></code></a>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'123'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Constant(value=123))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.FormattedValue"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">FormattedValue</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">conversion</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">format_spec</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.FormattedValue" title="Link to this definition">¶</a></dt> | |
| <dd><p>Node representing a single formatting field in an f-string. If the string | |
| contains a single formatting field and nothing else the node can be | |
| isolated otherwise it appears in <a class="reference internal" href="#ast.JoinedStr" title="ast.JoinedStr"><code class="xref py py-class docutils literal notranslate"><span class="pre">JoinedStr</span></code></a>.</p> | |
| <ul class="simple"> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">value</span></code> is any expression node (such as a literal, a variable, or a | |
| function call).</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">conversion</span></code> is an integer:</p> | |
| <ul> | |
| <li><p>-1: no formatting</p></li> | |
| <li><p>97 (<code class="docutils literal notranslate"><span class="pre">ord('a')</span></code>): <code class="docutils literal notranslate"><span class="pre">!a</span></code> <a class="reference internal" href="functions.html#ascii" title="ascii"><code class="xref py py-func docutils literal notranslate"><span class="pre">ASCII</span></code></a> formatting</p></li> | |
| <li><p>114 (<code class="docutils literal notranslate"><span class="pre">ord('r')</span></code>): <code class="docutils literal notranslate"><span class="pre">!r</span></code> <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> formatting</p></li> | |
| <li><p>115 (<code class="docutils literal notranslate"><span class="pre">ord('s')</span></code>): <code class="docutils literal notranslate"><span class="pre">!s</span></code> <a class="reference internal" href="stdtypes.html#str" title="str"><code class="xref py py-func docutils literal notranslate"><span class="pre">string</span></code></a> formatting</p></li> | |
| </ul> | |
| </li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">format_spec</span></code> is a <a class="reference internal" href="#ast.JoinedStr" title="ast.JoinedStr"><code class="xref py py-class docutils literal notranslate"><span class="pre">JoinedStr</span></code></a> node representing the formatting | |
| of the value, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if no format was specified. Both | |
| <code class="docutils literal notranslate"><span class="pre">conversion</span></code> and <code class="docutils literal notranslate"><span class="pre">format_spec</span></code> can be set at the same time.</p></li> | |
| </ul> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.JoinedStr"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">JoinedStr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">values</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.JoinedStr" title="Link to this definition">¶</a></dt> | |
| <dd><p>An f-string, comprising a series of <a class="reference internal" href="#ast.FormattedValue" title="ast.FormattedValue"><code class="xref py py-class docutils literal notranslate"><span class="pre">FormattedValue</span></code></a> and <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a> | |
| nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'f"sin(</span><span class="si">{a}</span><span class="s1">) is {sin(a):.3}"'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=JoinedStr(</span> | |
| <span class="go"> values=[</span> | |
| <span class="go"> Constant(value='sin('),</span> | |
| <span class="go"> FormattedValue(</span> | |
| <span class="go"> value=Name(id='a'),</span> | |
| <span class="go"> conversion=-1),</span> | |
| <span class="go"> Constant(value=') is '),</span> | |
| <span class="go"> FormattedValue(</span> | |
| <span class="go"> value=Call(</span> | |
| <span class="go"> func=Name(id='sin'),</span> | |
| <span class="go"> args=[</span> | |
| <span class="go"> Name(id='a')]),</span> | |
| <span class="go"> conversion=-1,</span> | |
| <span class="go"> format_spec=JoinedStr(</span> | |
| <span class="go"> values=[</span> | |
| <span class="go"> Constant(value='.3')]))]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.TemplateStr"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TemplateStr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">values</span></span></em>, <em class="sig-param"><span class="positional-only-separator o"><abbr title="Positional-only parameter separator (PEP 570)"><span class="pre">/</span></abbr></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TemplateStr" title="Link to this definition">¶</a></dt> | |
| <dd><div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.14.</span></p> | |
| </div> | |
| <p>Node representing a template string literal, comprising a series of | |
| <a class="reference internal" href="#ast.Interpolation" title="ast.Interpolation"><code class="xref py py-class docutils literal notranslate"><span class="pre">Interpolation</span></code></a> and <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a> nodes. | |
| These nodes may be any order, and do not need to be interleaved.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">expr</span> <span class="o">=</span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'t"</span><span class="si">{name}</span><span class="s1"> finished {place:ordinal}"'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">)</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">expr</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=TemplateStr(</span> | |
| <span class="go"> values=[</span> | |
| <span class="go"> Interpolation(</span> | |
| <span class="go"> value=Name(id='name'),</span> | |
| <span class="go"> str='name',</span> | |
| <span class="go"> conversion=-1),</span> | |
| <span class="go"> Constant(value=' finished '),</span> | |
| <span class="go"> Interpolation(</span> | |
| <span class="go"> value=Name(id='place'),</span> | |
| <span class="go"> str='place',</span> | |
| <span class="go"> conversion=-1,</span> | |
| <span class="go"> format_spec=JoinedStr(</span> | |
| <span class="go"> values=[</span> | |
| <span class="go"> Constant(value='ordinal')]))]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Interpolation"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Interpolation</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">str</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">conversion</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">format_spec</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Interpolation" title="Link to this definition">¶</a></dt> | |
| <dd><div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.14.</span></p> | |
| </div> | |
| <p>Node representing a single interpolation field in a template string literal.</p> | |
| <ul> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">value</span></code> is any expression node (such as a literal, a variable, or a | |
| function call). | |
| This has the same meaning as <code class="docutils literal notranslate"><span class="pre">FormattedValue.value</span></code>.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">str</span></code> is a constant containing the text of the interpolation expression.</p> | |
| <p>If <code class="docutils literal notranslate"><span class="pre">str</span></code> is set to <code class="docutils literal notranslate"><span class="pre">None</span></code>, then <code class="docutils literal notranslate"><span class="pre">value</span></code> is used to generate code | |
| when calling <a class="reference internal" href="#ast.unparse" title="ast.unparse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.unparse()</span></code></a>. This no longer guarantees that the | |
| generated code is identical to the original and is intended for code | |
| generation.</p> | |
| </li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">conversion</span></code> is an integer:</p> | |
| <ul class="simple"> | |
| <li><p>-1: no conversion</p></li> | |
| <li><p>97 (<code class="docutils literal notranslate"><span class="pre">ord('a')</span></code>): <code class="docutils literal notranslate"><span class="pre">!a</span></code> <a class="reference internal" href="functions.html#ascii" title="ascii"><code class="xref py py-func docutils literal notranslate"><span class="pre">ASCII</span></code></a> conversion</p></li> | |
| <li><p>114 (<code class="docutils literal notranslate"><span class="pre">ord('r')</span></code>): <code class="docutils literal notranslate"><span class="pre">!r</span></code> <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> conversion</p></li> | |
| <li><p>115 (<code class="docutils literal notranslate"><span class="pre">ord('s')</span></code>): <code class="docutils literal notranslate"><span class="pre">!s</span></code> <a class="reference internal" href="stdtypes.html#str" title="str"><code class="xref py py-func docutils literal notranslate"><span class="pre">string</span></code></a> conversion</p></li> | |
| </ul> | |
| <p>This has the same meaning as <code class="docutils literal notranslate"><span class="pre">FormattedValue.conversion</span></code>.</p> | |
| </li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">format_spec</span></code> is a <a class="reference internal" href="#ast.JoinedStr" title="ast.JoinedStr"><code class="xref py py-class docutils literal notranslate"><span class="pre">JoinedStr</span></code></a> node representing the formatting | |
| of the value, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if no format was specified. Both | |
| <code class="docutils literal notranslate"><span class="pre">conversion</span></code> and <code class="docutils literal notranslate"><span class="pre">format_spec</span></code> can be set at the same time. | |
| This has the same meaning as <code class="docutils literal notranslate"><span class="pre">FormattedValue.format_spec</span></code>.</p></li> | |
| </ul> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.List"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">List</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elts</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.List" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Tuple"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Tuple</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elts</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Tuple" title="Link to this definition">¶</a></dt> | |
| <dd><p>A list or tuple. <code class="docutils literal notranslate"><span class="pre">elts</span></code> holds a list of nodes representing the elements. | |
| <code class="docutils literal notranslate"><span class="pre">ctx</span></code> is <a class="reference internal" href="#ast.Store" title="ast.Store"><code class="xref py py-class docutils literal notranslate"><span class="pre">Store</span></code></a> if the container is an assignment target (i.e. | |
| <code class="docutils literal notranslate"><span class="pre">(x,y)=something</span></code>), and <a class="reference internal" href="#ast.Load" title="ast.Load"><code class="xref py py-class docutils literal notranslate"><span class="pre">Load</span></code></a> otherwise.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'[1, 2, 3]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=List(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Constant(value=1),</span> | |
| <span class="go"> Constant(value=2),</span> | |
| <span class="go"> Constant(value=3)]))</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(1, 2, 3)'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Tuple(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Constant(value=1),</span> | |
| <span class="go"> Constant(value=2),</span> | |
| <span class="go"> Constant(value=3)]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Set"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Set</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elts</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Set" title="Link to this definition">¶</a></dt> | |
| <dd><p>A set. <code class="docutils literal notranslate"><span class="pre">elts</span></code> holds a list of nodes representing the set’s elements.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'{1, 2, 3}'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Set(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Constant(value=1),</span> | |
| <span class="go"> Constant(value=2),</span> | |
| <span class="go"> Constant(value=3)]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Dict"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Dict</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">keys</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">values</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Dict" title="Link to this definition">¶</a></dt> | |
| <dd><p>A dictionary. <code class="docutils literal notranslate"><span class="pre">keys</span></code> and <code class="docutils literal notranslate"><span class="pre">values</span></code> hold lists of nodes representing the | |
| keys and the values respectively, in matching order (what would be returned | |
| when calling <code class="code docutils literal notranslate"><span class="pre">dictionary.keys()</span></code> and <code class="code docutils literal notranslate"><span class="pre">dictionary.values()</span></code>).</p> | |
| <p>When doing dictionary unpacking using dictionary literals the expression to be | |
| expanded goes in the <code class="docutils literal notranslate"><span class="pre">values</span></code> list, with a <code class="docutils literal notranslate"><span class="pre">None</span></code> at the corresponding | |
| position in <code class="docutils literal notranslate"><span class="pre">keys</span></code>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'{"a":1, **d}'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Dict(</span> | |
| <span class="go"> keys=[</span> | |
| <span class="go"> Constant(value='a'),</span> | |
| <span class="go"> None],</span> | |
| <span class="go"> values=[</span> | |
| <span class="go"> Constant(value=1),</span> | |
| <span class="go"> Name(id='d')]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="variables"> | |
| <h3>Variables<a class="headerlink" href="#variables" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Name"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Name</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">id</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Name" title="Link to this definition">¶</a></dt> | |
| <dd><p>A variable name. <code class="docutils literal notranslate"><span class="pre">id</span></code> holds the name as a string, and <code class="docutils literal notranslate"><span class="pre">ctx</span></code> is one of | |
| the following types.</p> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Load"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Load</span></span><a class="headerlink" href="#ast.Load" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Store"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Store</span></span><a class="headerlink" href="#ast.Store" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Del"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Del</span></span><a class="headerlink" href="#ast.Del" title="Link to this definition">¶</a></dt> | |
| <dd><p>Variable references can be used to load the value of a variable, to assign | |
| a new value to it, or to delete it. Variable references are given a context | |
| to distinguish these cases.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Name(id='a'))])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a = 1'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Assign(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Name(id='a', ctx=Store())],</span> | |
| <span class="go"> value=Constant(value=1))])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'del a'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Delete(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Name(id='a', ctx=Del())])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Starred"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Starred</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Starred" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">*var</span></code> variable reference. <code class="docutils literal notranslate"><span class="pre">value</span></code> holds the variable, typically a | |
| <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node. This type must be used when building a <a class="reference internal" href="#ast.Call" title="ast.Call"><code class="xref py py-class docutils literal notranslate"><span class="pre">Call</span></code></a> | |
| node with <code class="docutils literal notranslate"><span class="pre">*args</span></code>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a, *b = it'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Assign(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Tuple(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Name(id='a', ctx=Store()),</span> | |
| <span class="go"> Starred(</span> | |
| <span class="go"> value=Name(id='b', ctx=Store()),</span> | |
| <span class="go"> ctx=Store())],</span> | |
| <span class="go"> ctx=Store())],</span> | |
| <span class="go"> value=Name(id='it'))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="expressions"> | |
| <span id="ast-expressions"></span><h3>Expressions<a class="headerlink" href="#expressions" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Expr"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Expr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Expr" title="Link to this definition">¶</a></dt> | |
| <dd><p>When an expression, such as a function call, appears as a statement by itself | |
| with its return value not used or stored, it is wrapped in this container. | |
| <code class="docutils literal notranslate"><span class="pre">value</span></code> holds one of the other nodes in this section, a <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a>, a | |
| <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, a <a class="reference internal" href="#ast.Lambda" title="ast.Lambda"><code class="xref py py-class docutils literal notranslate"><span class="pre">Lambda</span></code></a>, a <a class="reference internal" href="#ast.Yield" title="ast.Yield"><code class="xref py py-class docutils literal notranslate"><span class="pre">Yield</span></code></a> or <a class="reference internal" href="#ast.YieldFrom" title="ast.YieldFrom"><code class="xref py py-class docutils literal notranslate"><span class="pre">YieldFrom</span></code></a> node.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'-a'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=UnaryOp(</span> | |
| <span class="go"> op=USub(),</span> | |
| <span class="go"> operand=Name(id='a')))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.UnaryOp"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">UnaryOp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">operand</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.UnaryOp" title="Link to this definition">¶</a></dt> | |
| <dd><p>A unary operation. <code class="docutils literal notranslate"><span class="pre">op</span></code> is the operator, and <code class="docutils literal notranslate"><span class="pre">operand</span></code> any expression | |
| node.</p> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.UAdd"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">UAdd</span></span><a class="headerlink" href="#ast.UAdd" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.USub"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">USub</span></span><a class="headerlink" href="#ast.USub" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Not"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Not</span></span><a class="headerlink" href="#ast.Not" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Invert"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Invert</span></span><a class="headerlink" href="#ast.Invert" title="Link to this definition">¶</a></dt> | |
| <dd><p>Unary operator tokens. <code class="xref py py-class docutils literal notranslate"><span class="pre">Not</span></code> is the <code class="docutils literal notranslate"><span class="pre">not</span></code> keyword, <code class="xref py py-class docutils literal notranslate"><span class="pre">Invert</span></code> | |
| is the <code class="docutils literal notranslate"><span class="pre">~</span></code> operator.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'not x'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=UnaryOp(</span> | |
| <span class="go"> op=Not(),</span> | |
| <span class="go"> operand=Name(id='x')))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.BinOp"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BinOp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">left</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">right</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.BinOp" title="Link to this definition">¶</a></dt> | |
| <dd><p>A binary operation (like addition or division). <code class="docutils literal notranslate"><span class="pre">op</span></code> is the operator, and | |
| <code class="docutils literal notranslate"><span class="pre">left</span></code> and <code class="docutils literal notranslate"><span class="pre">right</span></code> are any expression nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x + y'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=BinOp(</span> | |
| <span class="go"> left=Name(id='x'),</span> | |
| <span class="go"> op=Add(),</span> | |
| <span class="go"> right=Name(id='y')))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Add"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Add</span></span><a class="headerlink" href="#ast.Add" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Sub"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Sub</span></span><a class="headerlink" href="#ast.Sub" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Mult"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Mult</span></span><a class="headerlink" href="#ast.Mult" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Div"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Div</span></span><a class="headerlink" href="#ast.Div" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.FloorDiv"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">FloorDiv</span></span><a class="headerlink" href="#ast.FloorDiv" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Mod"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Mod</span></span><a class="headerlink" href="#ast.Mod" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Pow"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Pow</span></span><a class="headerlink" href="#ast.Pow" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.LShift"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">LShift</span></span><a class="headerlink" href="#ast.LShift" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.RShift"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">RShift</span></span><a class="headerlink" href="#ast.RShift" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.BitOr"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BitOr</span></span><a class="headerlink" href="#ast.BitOr" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.BitXor"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BitXor</span></span><a class="headerlink" href="#ast.BitXor" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.BitAnd"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BitAnd</span></span><a class="headerlink" href="#ast.BitAnd" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.MatMult"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatMult</span></span><a class="headerlink" href="#ast.MatMult" title="Link to this definition">¶</a></dt> | |
| <dd><p>Binary operator tokens.</p> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.BoolOp"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BoolOp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">values</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.BoolOp" title="Link to this definition">¶</a></dt> | |
| <dd><p>A boolean operation, ‘or’ or ‘and’. <code class="docutils literal notranslate"><span class="pre">op</span></code> is <a class="reference internal" href="#ast.Or" title="ast.Or"><code class="xref py py-class docutils literal notranslate"><span class="pre">Or</span></code></a> or <a class="reference internal" href="#ast.And" title="ast.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a>. | |
| <code class="docutils literal notranslate"><span class="pre">values</span></code> are the values involved. Consecutive operations with the same | |
| operator, such as <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">or</span> <span class="pre">b</span> <span class="pre">or</span> <span class="pre">c</span></code>, are collapsed into one node with several | |
| values.</p> | |
| <p>This doesn’t include <code class="docutils literal notranslate"><span class="pre">not</span></code>, which is a <a class="reference internal" href="#ast.UnaryOp" title="ast.UnaryOp"><code class="xref py py-class docutils literal notranslate"><span class="pre">UnaryOp</span></code></a>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x or y'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=BoolOp(</span> | |
| <span class="go"> op=Or(),</span> | |
| <span class="go"> values=[</span> | |
| <span class="go"> Name(id='x'),</span> | |
| <span class="go"> Name(id='y')]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.And"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">And</span></span><a class="headerlink" href="#ast.And" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Or"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Or</span></span><a class="headerlink" href="#ast.Or" title="Link to this definition">¶</a></dt> | |
| <dd><p>Boolean operator tokens.</p> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Compare"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Compare</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">left</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ops</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">comparators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Compare" title="Link to this definition">¶</a></dt> | |
| <dd><p>A comparison of two or more values. <code class="docutils literal notranslate"><span class="pre">left</span></code> is the first value in the | |
| comparison, <code class="docutils literal notranslate"><span class="pre">ops</span></code> the list of operators, and <code class="docutils literal notranslate"><span class="pre">comparators</span></code> the list | |
| of values after the first element in the comparison.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'1 <= a < 10'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Compare(</span> | |
| <span class="go"> left=Constant(value=1),</span> | |
| <span class="go"> ops=[</span> | |
| <span class="go"> LtE(),</span> | |
| <span class="go"> Lt()],</span> | |
| <span class="go"> comparators=[</span> | |
| <span class="go"> Name(id='a'),</span> | |
| <span class="go"> Constant(value=10)]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Eq"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Eq</span></span><a class="headerlink" href="#ast.Eq" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.NotEq"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NotEq</span></span><a class="headerlink" href="#ast.NotEq" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Lt"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Lt</span></span><a class="headerlink" href="#ast.Lt" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.LtE"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">LtE</span></span><a class="headerlink" href="#ast.LtE" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Gt"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Gt</span></span><a class="headerlink" href="#ast.Gt" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.GtE"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">GtE</span></span><a class="headerlink" href="#ast.GtE" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Is"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Is</span></span><a class="headerlink" href="#ast.Is" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.IsNot"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">IsNot</span></span><a class="headerlink" href="#ast.IsNot" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.In"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">In</span></span><a class="headerlink" href="#ast.In" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.NotIn"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NotIn</span></span><a class="headerlink" href="#ast.NotIn" title="Link to this definition">¶</a></dt> | |
| <dd><p>Comparison operator tokens.</p> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Call"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Call</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">func</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keywords</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Call" title="Link to this definition">¶</a></dt> | |
| <dd><p>A function call. <code class="docutils literal notranslate"><span class="pre">func</span></code> is the function, which will often be a | |
| <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> or <a class="reference internal" href="#ast.Attribute" title="ast.Attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">Attribute</span></code></a> object. Of the arguments:</p> | |
| <ul class="simple"> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">args</span></code> holds a list of the arguments passed by position.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">keywords</span></code> holds a list of <a class="reference internal" href="#ast.keyword" title="ast.keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">keyword</span></code></a> objects representing | |
| arguments passed by keyword.</p></li> | |
| </ul> | |
| <p>The <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">keywords</span></code> arguments are optional and default to empty lists.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'func(a, b=c, *d, **e)'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Call(</span> | |
| <span class="go"> func=Name(id='func'),</span> | |
| <span class="go"> args=[</span> | |
| <span class="go"> Name(id='a'),</span> | |
| <span class="go"> Starred(</span> | |
| <span class="go"> value=Name(id='d'))],</span> | |
| <span class="go"> keywords=[</span> | |
| <span class="go"> keyword(</span> | |
| <span class="go"> arg='b',</span> | |
| <span class="go"> value=Name(id='c')),</span> | |
| <span class="go"> keyword(</span> | |
| <span class="go"> value=Name(id='e'))]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.keyword"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">keyword</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">arg</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.keyword" title="Link to this definition">¶</a></dt> | |
| <dd><p>A keyword argument to a function call or class definition. <code class="docutils literal notranslate"><span class="pre">arg</span></code> is a raw | |
| string of the parameter name, <code class="docutils literal notranslate"><span class="pre">value</span></code> is a node to pass in.</p> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.IfExp"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">IfExp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">test</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.IfExp" title="Link to this definition">¶</a></dt> | |
| <dd><p>An expression such as <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">if</span> <span class="pre">b</span> <span class="pre">else</span> <span class="pre">c</span></code>. Each field holds a single node, so | |
| in the following example, all three are <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a if b else c'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=IfExp(</span> | |
| <span class="go"> test=Name(id='b'),</span> | |
| <span class="go"> body=Name(id='a'),</span> | |
| <span class="go"> orelse=Name(id='c')))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Attribute"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Attribute</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">attr</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Attribute" title="Link to this definition">¶</a></dt> | |
| <dd><p>Attribute access, e.g. <code class="docutils literal notranslate"><span class="pre">d.keys</span></code>. <code class="docutils literal notranslate"><span class="pre">value</span></code> is a node, typically a | |
| <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>. <code class="docutils literal notranslate"><span class="pre">attr</span></code> is a bare string giving the name of the attribute, | |
| and <code class="docutils literal notranslate"><span class="pre">ctx</span></code> is <a class="reference internal" href="#ast.Load" title="ast.Load"><code class="xref py py-class docutils literal notranslate"><span class="pre">Load</span></code></a>, <a class="reference internal" href="#ast.Store" title="ast.Store"><code class="xref py py-class docutils literal notranslate"><span class="pre">Store</span></code></a> or <a class="reference internal" href="#ast.Del" title="ast.Del"><code class="xref py py-class docutils literal notranslate"><span class="pre">Del</span></code></a> according to how | |
| the attribute is acted on.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'snake.colour'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Attribute(</span> | |
| <span class="go"> value=Name(id='snake'),</span> | |
| <span class="go"> attr='colour'))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.NamedExpr"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NamedExpr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.NamedExpr" title="Link to this definition">¶</a></dt> | |
| <dd><p>A named expression. This AST node is produced by the assignment expressions | |
| operator (also known as the walrus operator). As opposed to the <a class="reference internal" href="#ast.Assign" title="ast.Assign"><code class="xref py py-class docutils literal notranslate"><span class="pre">Assign</span></code></a> | |
| node in which the first argument can be multiple nodes, in this case both | |
| <code class="docutils literal notranslate"><span class="pre">target</span></code> and <code class="docutils literal notranslate"><span class="pre">value</span></code> must be single nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(x := 4)'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=NamedExpr(</span> | |
| <span class="go"> target=Name(id='x', ctx=Store()),</span> | |
| <span class="go"> value=Constant(value=4)))</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.8.</span></p> | |
| </div> | |
| </dd></dl> | |
| <section id="subscripting"> | |
| <h4>Subscripting<a class="headerlink" href="#subscripting" title="Link to this heading">¶</a></h4> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Subscript"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Subscript</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">slice</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Subscript" title="Link to this definition">¶</a></dt> | |
| <dd><p>A subscript, such as <code class="docutils literal notranslate"><span class="pre">l[1]</span></code>. <code class="docutils literal notranslate"><span class="pre">value</span></code> is the subscripted object | |
| (usually sequence or mapping). <code class="docutils literal notranslate"><span class="pre">slice</span></code> is an index, slice or key. | |
| It can be a <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> and contain a <a class="reference internal" href="#ast.Slice" title="ast.Slice"><code class="xref py py-class docutils literal notranslate"><span class="pre">Slice</span></code></a>. | |
| <code class="docutils literal notranslate"><span class="pre">ctx</span></code> is <a class="reference internal" href="#ast.Load" title="ast.Load"><code class="xref py py-class docutils literal notranslate"><span class="pre">Load</span></code></a>, <a class="reference internal" href="#ast.Store" title="ast.Store"><code class="xref py py-class docutils literal notranslate"><span class="pre">Store</span></code></a> or <a class="reference internal" href="#ast.Del" title="ast.Del"><code class="xref py py-class docutils literal notranslate"><span class="pre">Del</span></code></a> | |
| according to the action performed with the subscript.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'l[1:2, 3]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Subscript(</span> | |
| <span class="go"> value=Name(id='l'),</span> | |
| <span class="go"> slice=Tuple(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Slice(</span> | |
| <span class="go"> lower=Constant(value=1),</span> | |
| <span class="go"> upper=Constant(value=2)),</span> | |
| <span class="go"> Constant(value=3)])))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Slice"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Slice</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">lower</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">upper</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">step</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Slice" title="Link to this definition">¶</a></dt> | |
| <dd><p>Regular slicing (on the form <code class="docutils literal notranslate"><span class="pre">lower:upper</span></code> or <code class="docutils literal notranslate"><span class="pre">lower:upper:step</span></code>). | |
| Can occur only inside the <em>slice</em> field of <a class="reference internal" href="#ast.Subscript" title="ast.Subscript"><code class="xref py py-class docutils literal notranslate"><span class="pre">Subscript</span></code></a>, either | |
| directly or as an element of <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'l[1:2]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Subscript(</span> | |
| <span class="go"> value=Name(id='l'),</span> | |
| <span class="go"> slice=Slice(</span> | |
| <span class="go"> lower=Constant(value=1),</span> | |
| <span class="go"> upper=Constant(value=2))))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="comprehensions"> | |
| <h4>Comprehensions<a class="headerlink" href="#comprehensions" title="Link to this heading">¶</a></h4> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.ListComp"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ListComp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elt</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">generators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ListComp" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.SetComp"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">SetComp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elt</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">generators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.SetComp" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.GeneratorExp"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">GeneratorExp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elt</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">generators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.GeneratorExp" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.DictComp"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">DictComp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">key</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">generators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.DictComp" title="Link to this definition">¶</a></dt> | |
| <dd><p>List and set comprehensions, generator expressions, and dictionary | |
| comprehensions. <code class="docutils literal notranslate"><span class="pre">elt</span></code> (or <code class="docutils literal notranslate"><span class="pre">key</span></code> and <code class="docutils literal notranslate"><span class="pre">value</span></code>) is a single node | |
| representing the part that will be evaluated for each item.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">generators</span></code> is a list of <a class="reference internal" href="#ast.comprehension" title="ast.comprehension"><code class="xref py py-class docutils literal notranslate"><span class="pre">comprehension</span></code></a> nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span> | |
| <span class="gp">... </span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'[x for x in numbers]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> | |
| <span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> | |
| <span class="gp">... </span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=ListComp(</span> | |
| <span class="go"> elt=Name(id='x'),</span> | |
| <span class="go"> generators=[</span> | |
| <span class="go"> comprehension(</span> | |
| <span class="go"> target=Name(id='x', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='numbers'),</span> | |
| <span class="go"> is_async=0)]))</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span> | |
| <span class="gp">... </span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'{x: x**2 for x in numbers}'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> | |
| <span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> | |
| <span class="gp">... </span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=DictComp(</span> | |
| <span class="go"> key=Name(id='x'),</span> | |
| <span class="go"> value=BinOp(</span> | |
| <span class="go"> left=Name(id='x'),</span> | |
| <span class="go"> op=Pow(),</span> | |
| <span class="go"> right=Constant(value=2)),</span> | |
| <span class="go"> generators=[</span> | |
| <span class="go"> comprehension(</span> | |
| <span class="go"> target=Name(id='x', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='numbers'),</span> | |
| <span class="go"> is_async=0)]))</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span> | |
| <span class="gp">... </span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'{x for x in numbers}'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> | |
| <span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> | |
| <span class="gp">... </span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=SetComp(</span> | |
| <span class="go"> elt=Name(id='x'),</span> | |
| <span class="go"> generators=[</span> | |
| <span class="go"> comprehension(</span> | |
| <span class="go"> target=Name(id='x', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='numbers'),</span> | |
| <span class="go"> is_async=0)]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.comprehension"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">comprehension</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">iter</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ifs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">is_async</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.comprehension" title="Link to this definition">¶</a></dt> | |
| <dd><p>One <code class="docutils literal notranslate"><span class="pre">for</span></code> clause in a comprehension. <code class="docutils literal notranslate"><span class="pre">target</span></code> is the reference to use for | |
| each element - typically a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> or <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> node. <code class="docutils literal notranslate"><span class="pre">iter</span></code> | |
| is the object to iterate over. <code class="docutils literal notranslate"><span class="pre">ifs</span></code> is a list of test expressions: each | |
| <code class="docutils literal notranslate"><span class="pre">for</span></code> clause can have multiple <code class="docutils literal notranslate"><span class="pre">ifs</span></code>.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">is_async</span></code> indicates a comprehension is asynchronous (using an | |
| <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">for</span></code> instead of <code class="docutils literal notranslate"><span class="pre">for</span></code>). The value is an integer (0 or 1).</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'[ord(c) for line in file for c in line]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> | |
| <span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Multiple comprehensions in one.</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=ListComp(</span> | |
| <span class="go"> elt=Call(</span> | |
| <span class="go"> func=Name(id='ord'),</span> | |
| <span class="go"> args=[</span> | |
| <span class="go"> Name(id='c')]),</span> | |
| <span class="go"> generators=[</span> | |
| <span class="go"> comprehension(</span> | |
| <span class="go"> target=Name(id='line', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='file'),</span> | |
| <span class="go"> is_async=0),</span> | |
| <span class="go"> comprehension(</span> | |
| <span class="go"> target=Name(id='c', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='line'),</span> | |
| <span class="go"> is_async=0)]))</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(n**2 for n in it if n>5 if n<10)'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> | |
| <span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># generator comprehension</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=GeneratorExp(</span> | |
| <span class="go"> elt=BinOp(</span> | |
| <span class="go"> left=Name(id='n'),</span> | |
| <span class="go"> op=Pow(),</span> | |
| <span class="go"> right=Constant(value=2)),</span> | |
| <span class="go"> generators=[</span> | |
| <span class="go"> comprehension(</span> | |
| <span class="go"> target=Name(id='n', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='it'),</span> | |
| <span class="go"> ifs=[</span> | |
| <span class="go"> Compare(</span> | |
| <span class="go"> left=Name(id='n'),</span> | |
| <span class="go"> ops=[</span> | |
| <span class="go"> Gt()],</span> | |
| <span class="go"> comparators=[</span> | |
| <span class="go"> Constant(value=5)]),</span> | |
| <span class="go"> Compare(</span> | |
| <span class="go"> left=Name(id='n'),</span> | |
| <span class="go"> ops=[</span> | |
| <span class="go"> Lt()],</span> | |
| <span class="go"> comparators=[</span> | |
| <span class="go"> Constant(value=10)])],</span> | |
| <span class="go"> is_async=0)]))</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'[i async for i in soc]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> | |
| <span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Async comprehension</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=ListComp(</span> | |
| <span class="go"> elt=Name(id='i'),</span> | |
| <span class="go"> generators=[</span> | |
| <span class="go"> comprehension(</span> | |
| <span class="go"> target=Name(id='i', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='soc'),</span> | |
| <span class="go"> is_async=1)]))</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| </section> | |
| <section id="statements"> | |
| <span id="ast-statements"></span><h3>Statements<a class="headerlink" href="#statements" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Assign"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Assign</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">targets</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Assign" title="Link to this definition">¶</a></dt> | |
| <dd><p>An assignment. <code class="docutils literal notranslate"><span class="pre">targets</span></code> is a list of nodes, and <code class="docutils literal notranslate"><span class="pre">value</span></code> is a single node.</p> | |
| <p>Multiple nodes in <code class="docutils literal notranslate"><span class="pre">targets</span></code> represents assigning the same value to each. | |
| Unpacking is represented by putting a <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> or <a class="reference internal" href="#ast.List" title="ast.List"><code class="xref py py-class docutils literal notranslate"><span class="pre">List</span></code></a> | |
| within <code class="docutils literal notranslate"><span class="pre">targets</span></code>.</p> | |
| <dl class="py attribute"> | |
| <dt class="sig sig-object py" id="ast.Assign.type_comment"> | |
| <span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.Assign.type_comment" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment.</p> | |
| </dd></dl> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a = b = 1'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Multiple assignment</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Assign(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Name(id='a', ctx=Store()),</span> | |
| <span class="go"> Name(id='b', ctx=Store())],</span> | |
| <span class="go"> value=Constant(value=1))])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a,b = c'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Unpacking</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Assign(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Tuple(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Name(id='a', ctx=Store()),</span> | |
| <span class="go"> Name(id='b', ctx=Store())],</span> | |
| <span class="go"> ctx=Store())],</span> | |
| <span class="go"> value=Name(id='c'))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.AnnAssign"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AnnAssign</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">annotation</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">simple</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AnnAssign" title="Link to this definition">¶</a></dt> | |
| <dd><p>An assignment with a type annotation. <code class="docutils literal notranslate"><span class="pre">target</span></code> is a single node and can | |
| be a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, an <a class="reference internal" href="#ast.Attribute" title="ast.Attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">Attribute</span></code></a> or a <a class="reference internal" href="#ast.Subscript" title="ast.Subscript"><code class="xref py py-class docutils literal notranslate"><span class="pre">Subscript</span></code></a>. | |
| <code class="docutils literal notranslate"><span class="pre">annotation</span></code> is the annotation, such as a <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a> or <code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code> | |
| node. <code class="docutils literal notranslate"><span class="pre">value</span></code> is a single optional node.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">simple</span></code> is always either 0 (indicating a “complex” target) or 1 | |
| (indicating a “simple” target). A “simple” target consists solely of a | |
| <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node that does not appear between parentheses; all other | |
| targets are considered complex. Only simple targets appear in | |
| the <a class="reference internal" href="../reference/datamodel.html#object.__annotations__" title="object.__annotations__"><code class="xref py py-attr docutils literal notranslate"><span class="pre">__annotations__</span></code></a> dictionary of modules and classes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'c: int'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> AnnAssign(</span> | |
| <span class="go"> target=Name(id='c', ctx=Store()),</span> | |
| <span class="go"> annotation=Name(id='int'),</span> | |
| <span class="go"> simple=1)])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(a): int = 1'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Annotation with parenthesis</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> AnnAssign(</span> | |
| <span class="go"> target=Name(id='a', ctx=Store()),</span> | |
| <span class="go"> annotation=Name(id='int'),</span> | |
| <span class="go"> value=Constant(value=1),</span> | |
| <span class="go"> simple=0)])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a.b: int'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Attribute annotation</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> AnnAssign(</span> | |
| <span class="go"> target=Attribute(</span> | |
| <span class="go"> value=Name(id='a'),</span> | |
| <span class="go"> attr='b',</span> | |
| <span class="go"> ctx=Store()),</span> | |
| <span class="go"> annotation=Name(id='int'),</span> | |
| <span class="go"> simple=0)])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a[1]: int'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Subscript annotation</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> AnnAssign(</span> | |
| <span class="go"> target=Subscript(</span> | |
| <span class="go"> value=Name(id='a'),</span> | |
| <span class="go"> slice=Constant(value=1),</span> | |
| <span class="go"> ctx=Store()),</span> | |
| <span class="go"> annotation=Name(id='int'),</span> | |
| <span class="go"> simple=0)])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.AugAssign"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AugAssign</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AugAssign" title="Link to this definition">¶</a></dt> | |
| <dd><p>Augmented assignment, such as <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">+=</span> <span class="pre">1</span></code>. In the following example, | |
| <code class="docutils literal notranslate"><span class="pre">target</span></code> is a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node for <code class="docutils literal notranslate"><span class="pre">x</span></code> (with the <a class="reference internal" href="#ast.Store" title="ast.Store"><code class="xref py py-class docutils literal notranslate"><span class="pre">Store</span></code></a> | |
| context), <code class="docutils literal notranslate"><span class="pre">op</span></code> is <a class="reference internal" href="#ast.Add" title="ast.Add"><code class="xref py py-class docutils literal notranslate"><span class="pre">Add</span></code></a>, and <code class="docutils literal notranslate"><span class="pre">value</span></code> is a <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a> with | |
| value for 1.</p> | |
| <p>The <code class="docutils literal notranslate"><span class="pre">target</span></code> attribute cannot be of class <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> or <a class="reference internal" href="#ast.List" title="ast.List"><code class="xref py py-class docutils literal notranslate"><span class="pre">List</span></code></a>, | |
| unlike the targets of <a class="reference internal" href="#ast.Assign" title="ast.Assign"><code class="xref py py-class docutils literal notranslate"><span class="pre">Assign</span></code></a>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x += 2'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> AugAssign(</span> | |
| <span class="go"> target=Name(id='x', ctx=Store()),</span> | |
| <span class="go"> op=Add(),</span> | |
| <span class="go"> value=Constant(value=2))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Raise"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Raise</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">exc</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">cause</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Raise" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">raise</span></code> statement. <code class="docutils literal notranslate"><span class="pre">exc</span></code> is the exception object to be raised, normally a | |
| <a class="reference internal" href="#ast.Call" title="ast.Call"><code class="xref py py-class docutils literal notranslate"><span class="pre">Call</span></code></a> or <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, or <code class="docutils literal notranslate"><span class="pre">None</span></code> for a standalone <code class="docutils literal notranslate"><span class="pre">raise</span></code>. | |
| <code class="docutils literal notranslate"><span class="pre">cause</span></code> is the optional part for <code class="docutils literal notranslate"><span class="pre">y</span></code> in <code class="docutils literal notranslate"><span class="pre">raise</span> <span class="pre">x</span> <span class="pre">from</span> <span class="pre">y</span></code>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'raise x from y'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Raise(</span> | |
| <span class="go"> exc=Name(id='x'),</span> | |
| <span class="go"> cause=Name(id='y'))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Assert"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Assert</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">test</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">msg</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Assert" title="Link to this definition">¶</a></dt> | |
| <dd><p>An assertion. <code class="docutils literal notranslate"><span class="pre">test</span></code> holds the condition, such as a <a class="reference internal" href="#ast.Compare" title="ast.Compare"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compare</span></code></a> node. | |
| <code class="docutils literal notranslate"><span class="pre">msg</span></code> holds the failure message.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'assert x,y'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Assert(</span> | |
| <span class="go"> test=Name(id='x'),</span> | |
| <span class="go"> msg=Name(id='y'))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Delete"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Delete</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">targets</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Delete" title="Link to this definition">¶</a></dt> | |
| <dd><p>Represents a <code class="docutils literal notranslate"><span class="pre">del</span></code> statement. <code class="docutils literal notranslate"><span class="pre">targets</span></code> is a list of nodes, such as | |
| <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, <a class="reference internal" href="#ast.Attribute" title="ast.Attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">Attribute</span></code></a> or <a class="reference internal" href="#ast.Subscript" title="ast.Subscript"><code class="xref py py-class docutils literal notranslate"><span class="pre">Subscript</span></code></a> nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'del x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Delete(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Name(id='x', ctx=Del()),</span> | |
| <span class="go"> Name(id='y', ctx=Del()),</span> | |
| <span class="go"> Name(id='z', ctx=Del())])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Pass"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Pass</span></span><a class="headerlink" href="#ast.Pass" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">pass</span></code> statement.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'pass'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Pass()])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.TypeAlias"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TypeAlias</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_params</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TypeAlias" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <a class="reference internal" href="typing.html#type-aliases"><span class="std std-ref">type alias</span></a> created through the <a class="reference internal" href="../reference/simple_stmts.html#type"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">type</span></code></a> | |
| statement. <code class="docutils literal notranslate"><span class="pre">name</span></code> is the name of the alias, <code class="docutils literal notranslate"><span class="pre">type_params</span></code> is a list of | |
| <a class="reference internal" href="#ast-type-params"><span class="std std-ref">type parameters</span></a>, and <code class="docutils literal notranslate"><span class="pre">value</span></code> is the value of the | |
| type alias.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'type Alias = int'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> TypeAlias(</span> | |
| <span class="go"> name=Name(id='Alias', ctx=Store()),</span> | |
| <span class="go"> value=Name(id='int'))])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.12.</span></p> | |
| </div> | |
| </dd></dl> | |
| <p>Other statements which are only applicable inside functions or loops are | |
| described in other sections.</p> | |
| <section id="imports"> | |
| <h4>Imports<a class="headerlink" href="#imports" title="Link to this heading">¶</a></h4> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Import"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Import</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">names</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Import" title="Link to this definition">¶</a></dt> | |
| <dd><p>An import statement. <code class="docutils literal notranslate"><span class="pre">names</span></code> is a list of <a class="reference internal" href="#ast.alias" title="ast.alias"><code class="xref py py-class docutils literal notranslate"><span class="pre">alias</span></code></a> nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'import x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Import(</span> | |
| <span class="go"> names=[</span> | |
| <span class="go"> alias(name='x'),</span> | |
| <span class="go"> alias(name='y'),</span> | |
| <span class="go"> alias(name='z')],</span> | |
| <span class="go"> is_lazy=0)])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.ImportFrom"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ImportFrom</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">module</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">names</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">level</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ImportFrom" title="Link to this definition">¶</a></dt> | |
| <dd><p>Represents <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">x</span> <span class="pre">import</span> <span class="pre">y</span></code>. <code class="docutils literal notranslate"><span class="pre">module</span></code> is a raw string of the ‘from’ name, | |
| without any leading dots, or <code class="docutils literal notranslate"><span class="pre">None</span></code> for statements such as <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">.</span> <span class="pre">import</span> <span class="pre">foo</span></code>. | |
| <code class="docutils literal notranslate"><span class="pre">level</span></code> is an integer holding the level of the relative import (0 means | |
| absolute import).</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'from y import x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> ImportFrom(</span> | |
| <span class="go"> module='y',</span> | |
| <span class="go"> names=[</span> | |
| <span class="go"> alias(name='x'),</span> | |
| <span class="go"> alias(name='y'),</span> | |
| <span class="go"> alias(name='z')],</span> | |
| <span class="go"> level=0,</span> | |
| <span class="go"> is_lazy=0)])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.alias"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">alias</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">asname</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.alias" title="Link to this definition">¶</a></dt> | |
| <dd><p>Both parameters are raw strings of the names. <code class="docutils literal notranslate"><span class="pre">asname</span></code> can be <code class="docutils literal notranslate"><span class="pre">None</span></code> if | |
| the regular name is to be used.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'from ..foo.bar import a as b, c'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> ImportFrom(</span> | |
| <span class="go"> module='foo.bar',</span> | |
| <span class="go"> names=[</span> | |
| <span class="go"> alias(name='a', asname='b'),</span> | |
| <span class="go"> alias(name='c')],</span> | |
| <span class="go"> level=2,</span> | |
| <span class="go"> is_lazy=0)])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| </section> | |
| <section id="control-flow"> | |
| <h3>Control flow<a class="headerlink" href="#control-flow" title="Link to this heading">¶</a></h3> | |
| <div class="admonition note"> | |
| <p class="admonition-title">Note</p> | |
| <p>Optional clauses such as <code class="docutils literal notranslate"><span class="pre">else</span></code> are stored as an empty list if they’re | |
| not present.</p> | |
| </div> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.If"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">If</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">test</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.If" title="Link to this definition">¶</a></dt> | |
| <dd><p>An <code class="docutils literal notranslate"><span class="pre">if</span></code> statement. <code class="docutils literal notranslate"><span class="pre">test</span></code> holds a single node, such as a <a class="reference internal" href="#ast.Compare" title="ast.Compare"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compare</span></code></a> | |
| node. <code class="docutils literal notranslate"><span class="pre">body</span></code> and <code class="docutils literal notranslate"><span class="pre">orelse</span></code> each hold a list of nodes.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">elif</span></code> clauses don’t have a special representation in the AST, but rather | |
| appear as extra <code class="xref py py-class docutils literal notranslate"><span class="pre">If</span></code> nodes within the <code class="docutils literal notranslate"><span class="pre">orelse</span></code> section of the | |
| previous one.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">if x:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">elif y:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">else:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> If(</span> | |
| <span class="go"> test=Name(id='x'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))],</span> | |
| <span class="go"> orelse=[</span> | |
| <span class="go"> If(</span> | |
| <span class="go"> test=Name(id='y'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))],</span> | |
| <span class="go"> orelse=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.For"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">For</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">iter</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.For" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">for</span></code> loop. <code class="docutils literal notranslate"><span class="pre">target</span></code> holds the variable(s) the loop assigns to, as a | |
| single <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a>, <a class="reference internal" href="#ast.List" title="ast.List"><code class="xref py py-class docutils literal notranslate"><span class="pre">List</span></code></a>, <a class="reference internal" href="#ast.Attribute" title="ast.Attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">Attribute</span></code></a> or | |
| <a class="reference internal" href="#ast.Subscript" title="ast.Subscript"><code class="xref py py-class docutils literal notranslate"><span class="pre">Subscript</span></code></a> node. <code class="docutils literal notranslate"><span class="pre">iter</span></code> holds the item to be looped over, again | |
| as a single node. <code class="docutils literal notranslate"><span class="pre">body</span></code> and <code class="docutils literal notranslate"><span class="pre">orelse</span></code> contain lists of nodes to execute. | |
| Those in <code class="docutils literal notranslate"><span class="pre">orelse</span></code> are executed if the loop finishes normally, rather than | |
| via a <code class="docutils literal notranslate"><span class="pre">break</span></code> statement.</p> | |
| <dl class="py attribute"> | |
| <dt class="sig sig-object py" id="ast.For.type_comment"> | |
| <span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.For.type_comment" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment.</p> | |
| </dd></dl> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">for x in y:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">else:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> For(</span> | |
| <span class="go"> target=Name(id='x', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='y'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))],</span> | |
| <span class="go"> orelse=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.While"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">While</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">test</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.While" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">while</span></code> loop. <code class="docutils literal notranslate"><span class="pre">test</span></code> holds the condition, such as a <a class="reference internal" href="#ast.Compare" title="ast.Compare"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compare</span></code></a> | |
| node.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">while x:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">else:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> While(</span> | |
| <span class="go"> test=Name(id='x'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))],</span> | |
| <span class="go"> orelse=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Break"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Break</span></span><a class="headerlink" href="#ast.Break" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Continue"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Continue</span></span><a class="headerlink" href="#ast.Continue" title="Link to this definition">¶</a></dt> | |
| <dd><p>The <code class="docutils literal notranslate"><span class="pre">break</span></code> and <code class="docutils literal notranslate"><span class="pre">continue</span></code> statements.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span> | |
| <span class="gp">... </span><span class="s2">for a in b:</span> | |
| <span class="gp">... </span><span class="s2"> if a > 5:</span> | |
| <span class="gp">... </span><span class="s2"> break</span> | |
| <span class="gp">... </span><span class="s2"> else:</span> | |
| <span class="gp">... </span><span class="s2"> continue</span> | |
| <span class="gp">...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> For(</span> | |
| <span class="go"> target=Name(id='a', ctx=Store()),</span> | |
| <span class="go"> iter=Name(id='b'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> If(</span> | |
| <span class="go"> test=Compare(</span> | |
| <span class="go"> left=Name(id='a'),</span> | |
| <span class="go"> ops=[</span> | |
| <span class="go"> Gt()],</span> | |
| <span class="go"> comparators=[</span> | |
| <span class="go"> Constant(value=5)]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Break()],</span> | |
| <span class="go"> orelse=[</span> | |
| <span class="go"> Continue()])])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Try"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Try</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">handlers</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">finalbody</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Try" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">try</span></code> blocks. All attributes are list of nodes to execute, except for | |
| <code class="docutils literal notranslate"><span class="pre">handlers</span></code>, which is a list of <a class="reference internal" href="#ast.ExceptHandler" title="ast.ExceptHandler"><code class="xref py py-class docutils literal notranslate"><span class="pre">ExceptHandler</span></code></a> nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">try:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">except Exception:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">except OtherException as e:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">else:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">finally:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Try(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))],</span> | |
| <span class="go"> handlers=[</span> | |
| <span class="go"> ExceptHandler(</span> | |
| <span class="go"> type=Name(id='Exception'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))]),</span> | |
| <span class="go"> ExceptHandler(</span> | |
| <span class="go"> type=Name(id='OtherException'),</span> | |
| <span class="go"> name='e',</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])],</span> | |
| <span class="go"> orelse=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))],</span> | |
| <span class="go"> finalbody=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.TryStar"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TryStar</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">handlers</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">finalbody</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TryStar" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">try</span></code> blocks which are followed by <code class="docutils literal notranslate"><span class="pre">except*</span></code> clauses. The attributes are the | |
| same as for <a class="reference internal" href="#ast.Try" title="ast.Try"><code class="xref py py-class docutils literal notranslate"><span class="pre">Try</span></code></a> but the <a class="reference internal" href="#ast.ExceptHandler" title="ast.ExceptHandler"><code class="xref py py-class docutils literal notranslate"><span class="pre">ExceptHandler</span></code></a> nodes in <code class="docutils literal notranslate"><span class="pre">handlers</span></code> | |
| are interpreted as <code class="docutils literal notranslate"><span class="pre">except*</span></code> blocks rather then <code class="docutils literal notranslate"><span class="pre">except</span></code>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">try:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">except* Exception:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> TryStar(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))],</span> | |
| <span class="go"> handlers=[</span> | |
| <span class="go"> ExceptHandler(</span> | |
| <span class="go"> type=Name(id='Exception'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.11.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.ExceptHandler"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ExceptHandler</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">type</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ExceptHandler" title="Link to this definition">¶</a></dt> | |
| <dd><p>A single <code class="docutils literal notranslate"><span class="pre">except</span></code> clause. <code class="docutils literal notranslate"><span class="pre">type</span></code> is the exception type it will match, | |
| typically a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node (or <code class="docutils literal notranslate"><span class="pre">None</span></code> for a catch-all <code class="docutils literal notranslate"><span class="pre">except:</span></code> clause). | |
| <code class="docutils literal notranslate"><span class="pre">name</span></code> is a raw string for the name to hold the exception, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if | |
| the clause doesn’t have <code class="docutils literal notranslate"><span class="pre">as</span> <span class="pre">foo</span></code>. <code class="docutils literal notranslate"><span class="pre">body</span></code> is a list of nodes.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span> | |
| <span class="gp">... </span><span class="s2">try:</span> | |
| <span class="gp">... </span><span class="s2"> a + 1</span> | |
| <span class="gp">... </span><span class="s2">except TypeError:</span> | |
| <span class="gp">... </span><span class="s2"> pass</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Try(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=BinOp(</span> | |
| <span class="go"> left=Name(id='a'),</span> | |
| <span class="go"> op=Add(),</span> | |
| <span class="go"> right=Constant(value=1)))],</span> | |
| <span class="go"> handlers=[</span> | |
| <span class="go"> ExceptHandler(</span> | |
| <span class="go"> type=Name(id='TypeError'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Pass()])])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.With"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">With</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">items</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.With" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">with</span></code> block. <code class="docutils literal notranslate"><span class="pre">items</span></code> is a list of <a class="reference internal" href="#ast.withitem" title="ast.withitem"><code class="xref py py-class docutils literal notranslate"><span class="pre">withitem</span></code></a> nodes representing | |
| the context managers, and <code class="docutils literal notranslate"><span class="pre">body</span></code> is the indented block inside the context.</p> | |
| <dl class="py attribute"> | |
| <dt class="sig sig-object py" id="ast.With.type_comment"> | |
| <span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.With.type_comment" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment.</p> | |
| </dd></dl> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.withitem"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">withitem</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">context_expr</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">optional_vars</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.withitem" title="Link to this definition">¶</a></dt> | |
| <dd><p>A single context manager in a <code class="docutils literal notranslate"><span class="pre">with</span></code> block. <code class="docutils literal notranslate"><span class="pre">context_expr</span></code> is the context | |
| manager, often a <a class="reference internal" href="#ast.Call" title="ast.Call"><code class="xref py py-class docutils literal notranslate"><span class="pre">Call</span></code></a> node. <code class="docutils literal notranslate"><span class="pre">optional_vars</span></code> is a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, | |
| <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> or <a class="reference internal" href="#ast.List" title="ast.List"><code class="xref py py-class docutils literal notranslate"><span class="pre">List</span></code></a> for the <code class="docutils literal notranslate"><span class="pre">as</span> <span class="pre">foo</span></code> part, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if that | |
| isn’t used.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span> | |
| <span class="gp">... </span><span class="s2">with a as b, c as d:</span> | |
| <span class="gp">... </span><span class="s2"> something(b, d)</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> With(</span> | |
| <span class="go"> items=[</span> | |
| <span class="go"> withitem(</span> | |
| <span class="go"> context_expr=Name(id='a'),</span> | |
| <span class="go"> optional_vars=Name(id='b', ctx=Store())),</span> | |
| <span class="go"> withitem(</span> | |
| <span class="go"> context_expr=Name(id='c'),</span> | |
| <span class="go"> optional_vars=Name(id='d', ctx=Store()))],</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Call(</span> | |
| <span class="go"> func=Name(id='something'),</span> | |
| <span class="go"> args=[</span> | |
| <span class="go"> Name(id='b'),</span> | |
| <span class="go"> Name(id='d')]))])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="pattern-matching"> | |
| <h3>Pattern matching<a class="headerlink" href="#pattern-matching" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Match"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Match</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subject</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">cases</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Match" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">match</span></code> statement. <code class="docutils literal notranslate"><span class="pre">subject</span></code> holds the subject of the match (the object | |
| that is being matched against the cases) and <code class="docutils literal notranslate"><span class="pre">cases</span></code> contains an iterable of | |
| <a class="reference internal" href="#ast.match_case" title="ast.match_case"><code class="xref py py-class docutils literal notranslate"><span class="pre">match_case</span></code></a> nodes with the different cases.</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.match_case"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">match_case</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">pattern</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">guard</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.match_case" title="Link to this definition">¶</a></dt> | |
| <dd><p>A single case pattern in a <code class="docutils literal notranslate"><span class="pre">match</span></code> statement. <code class="docutils literal notranslate"><span class="pre">pattern</span></code> contains the | |
| match pattern that the subject will be matched against. Note that the | |
| <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">AST</span></code></a> nodes produced for patterns differ from those produced for | |
| expressions, even when they share the same syntax.</p> | |
| <p>The <code class="docutils literal notranslate"><span class="pre">guard</span></code> attribute contains an expression that will be evaluated if | |
| the pattern matches the subject.</p> | |
| <p><code class="docutils literal notranslate"><span class="pre">body</span></code> contains a list of nodes to execute if the pattern matches and | |
| the result of evaluating the guard expression is true.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case [x] if x>0:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2"> case tuple():</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchSequence(</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchAs(name='x')]),</span> | |
| <span class="go"> guard=Compare(</span> | |
| <span class="go"> left=Name(id='x'),</span> | |
| <span class="go"> ops=[</span> | |
| <span class="go"> Gt()],</span> | |
| <span class="go"> comparators=[</span> | |
| <span class="go"> Constant(value=0)]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))]),</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchClass(</span> | |
| <span class="go"> cls=Name(id='tuple')),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.MatchValue"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchValue</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchValue" title="Link to this definition">¶</a></dt> | |
| <dd><p>A match literal or value pattern that compares by equality. <code class="docutils literal notranslate"><span class="pre">value</span></code> is | |
| an expression node. Permitted value nodes are restricted as described in | |
| the match statement documentation. This pattern succeeds if the match | |
| subject is equal to the evaluated value.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case "Relevant":</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchValue(</span> | |
| <span class="go"> value=Constant(value='Relevant')),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.MatchSingleton"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchSingleton</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchSingleton" title="Link to this definition">¶</a></dt> | |
| <dd><p>A match literal pattern that compares by identity. <code class="docutils literal notranslate"><span class="pre">value</span></code> is the | |
| singleton to be compared against: <code class="docutils literal notranslate"><span class="pre">None</span></code>, <code class="docutils literal notranslate"><span class="pre">True</span></code>, or <code class="docutils literal notranslate"><span class="pre">False</span></code>. This | |
| pattern succeeds if the match subject is the given constant.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case None:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchSingleton(value=None),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.MatchSequence"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchSequence</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">patterns</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchSequence" title="Link to this definition">¶</a></dt> | |
| <dd><p>A match sequence pattern. <code class="docutils literal notranslate"><span class="pre">patterns</span></code> contains the patterns to be matched | |
| against the subject elements if the subject is a sequence. Matches a variable | |
| length sequence if one of the subpatterns is a <code class="docutils literal notranslate"><span class="pre">MatchStar</span></code> node, otherwise | |
| matches a fixed length sequence.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case [1, 2]:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchSequence(</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=1)),</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=2))]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.MatchStar"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchStar</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchStar" title="Link to this definition">¶</a></dt> | |
| <dd><p>Matches the rest of the sequence in a variable length match sequence pattern. | |
| If <code class="docutils literal notranslate"><span class="pre">name</span></code> is not <code class="docutils literal notranslate"><span class="pre">None</span></code>, a list containing the remaining sequence | |
| elements is bound to that name if the overall sequence pattern is successful.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case [1, 2, *rest]:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2"> case [*_]:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchSequence(</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=1)),</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=2)),</span> | |
| <span class="go"> MatchStar(name='rest')]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))]),</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchSequence(</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchStar()]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.MatchMapping"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchMapping</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">keys</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">patterns</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">rest</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchMapping" title="Link to this definition">¶</a></dt> | |
| <dd><p>A match mapping pattern. <code class="docutils literal notranslate"><span class="pre">keys</span></code> is a sequence of expression nodes. | |
| <code class="docutils literal notranslate"><span class="pre">patterns</span></code> is a corresponding sequence of pattern nodes. <code class="docutils literal notranslate"><span class="pre">rest</span></code> is an | |
| optional name that can be specified to capture the remaining mapping elements. | |
| Permitted key expressions are restricted as described in the match statement | |
| documentation.</p> | |
| <p>This pattern succeeds if the subject is a mapping, all evaluated key | |
| expressions are present in the mapping, and the value corresponding to each | |
| key matches the corresponding subpattern. If <code class="docutils literal notranslate"><span class="pre">rest</span></code> is not <code class="docutils literal notranslate"><span class="pre">None</span></code>, a dict | |
| containing the remaining mapping elements is bound to that name if the overall | |
| mapping pattern is successful.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case {1: _, 2: _}:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2"> case {**rest}:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchMapping(</span> | |
| <span class="go"> keys=[</span> | |
| <span class="go"> Constant(value=1),</span> | |
| <span class="go"> Constant(value=2)],</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchAs(),</span> | |
| <span class="go"> MatchAs()]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))]),</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchMapping(rest='rest'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.MatchClass"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchClass</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">cls</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">patterns</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwd_attrs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwd_patterns</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchClass" title="Link to this definition">¶</a></dt> | |
| <dd><p>A match class pattern. <code class="docutils literal notranslate"><span class="pre">cls</span></code> is an expression giving the nominal class to | |
| be matched. <code class="docutils literal notranslate"><span class="pre">patterns</span></code> is a sequence of pattern nodes to be matched against | |
| the class defined sequence of pattern matching attributes. <code class="docutils literal notranslate"><span class="pre">kwd_attrs</span></code> is a | |
| sequence of additional attributes to be matched (specified as keyword arguments | |
| in the class pattern), <code class="docutils literal notranslate"><span class="pre">kwd_patterns</span></code> are the corresponding patterns | |
| (specified as keyword values in the class pattern).</p> | |
| <p>This pattern succeeds if the subject is an instance of the nominated class, | |
| all positional patterns match the corresponding class-defined attributes, and | |
| any specified keyword attributes match their corresponding pattern.</p> | |
| <p>Note: classes may define a property that returns self in order to match a | |
| pattern node against the instance being matched. Several builtin types are | |
| also matched that way, as described in the match statement documentation.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case Point2D(0, 0):</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2"> case Point3D(x=0, y=0, z=0):</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchClass(</span> | |
| <span class="go"> cls=Name(id='Point2D'),</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=0)),</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=0))]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))]),</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchClass(</span> | |
| <span class="go"> cls=Name(id='Point3D'),</span> | |
| <span class="go"> kwd_attrs=[</span> | |
| <span class="go"> 'x',</span> | |
| <span class="go"> 'y',</span> | |
| <span class="go"> 'z'],</span> | |
| <span class="go"> kwd_patterns=[</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=0)),</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=0)),</span> | |
| <span class="go"> MatchValue(</span> | |
| <span class="go"> value=Constant(value=0))]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.MatchAs"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchAs</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">pattern</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchAs" title="Link to this definition">¶</a></dt> | |
| <dd><p>A match “as-pattern”, capture pattern or wildcard pattern. <code class="docutils literal notranslate"><span class="pre">pattern</span></code> | |
| contains the match pattern that the subject will be matched against. | |
| If the pattern is <code class="docutils literal notranslate"><span class="pre">None</span></code>, the node represents a capture pattern (i.e a | |
| bare name) and will always succeed.</p> | |
| <p>The <code class="docutils literal notranslate"><span class="pre">name</span></code> attribute contains the name that will be bound if the pattern | |
| is successful. If <code class="docutils literal notranslate"><span class="pre">name</span></code> is <code class="docutils literal notranslate"><span class="pre">None</span></code>, <code class="docutils literal notranslate"><span class="pre">pattern</span></code> must also be <code class="docutils literal notranslate"><span class="pre">None</span></code> | |
| and the node represents the wildcard pattern.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case [x] as y:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2"> case _:</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchAs(</span> | |
| <span class="go"> pattern=MatchSequence(</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchAs(name='x')]),</span> | |
| <span class="go"> name='y'),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))]),</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchAs(),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.MatchOr"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchOr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">patterns</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchOr" title="Link to this definition">¶</a></dt> | |
| <dd><p>A match “or-pattern”. An or-pattern matches each of its subpatterns in turn | |
| to the subject, until one succeeds. The or-pattern is then deemed to | |
| succeed. If none of the subpatterns succeed the or-pattern fails. The | |
| <code class="docutils literal notranslate"><span class="pre">patterns</span></code> attribute contains a list of match pattern nodes that will be | |
| matched against the subject.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span> | |
| <span class="gp">... </span><span class="s2">match x:</span> | |
| <span class="gp">... </span><span class="s2"> case [x] | (y):</span> | |
| <span class="gp">... </span><span class="s2"> ...</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Match(</span> | |
| <span class="go"> subject=Name(id='x'),</span> | |
| <span class="go"> cases=[</span> | |
| <span class="go"> match_case(</span> | |
| <span class="go"> pattern=MatchOr(</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchSequence(</span> | |
| <span class="go"> patterns=[</span> | |
| <span class="go"> MatchAs(name='x')]),</span> | |
| <span class="go"> MatchAs(name='y')]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Constant(value=Ellipsis))])])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.10.</span></p> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="type-annotations"> | |
| <h3>Type annotations<a class="headerlink" href="#type-annotations" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.TypeIgnore"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TypeIgnore</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">lineno</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tag</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TypeIgnore" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span> <span class="pre">ignore</span></code> comment located at <em>lineno</em>. | |
| <em>tag</em> is the optional tag specified by the form <code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span> <span class="pre">ignore</span> <span class="pre"><tag></span></code>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x = 1 # type: ignore'</span><span class="p">,</span> <span class="n">type_comments</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Assign(</span> | |
| <span class="go"> targets=[</span> | |
| <span class="go"> Name(id='x', ctx=Store())],</span> | |
| <span class="go"> value=Constant(value=1))],</span> | |
| <span class="go"> type_ignores=[</span> | |
| <span class="go"> TypeIgnore(lineno=1, tag='')])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x: bool = 1 # type: ignore[assignment]'</span><span class="p">,</span> <span class="n">type_comments</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> AnnAssign(</span> | |
| <span class="go"> target=Name(id='x', ctx=Store()),</span> | |
| <span class="go"> annotation=Name(id='bool'),</span> | |
| <span class="go"> value=Constant(value=1),</span> | |
| <span class="go"> simple=1)],</span> | |
| <span class="go"> type_ignores=[</span> | |
| <span class="go"> TypeIgnore(lineno=1, tag='[assignment]')])</span> | |
| </pre></div> | |
| </div> | |
| <div class="admonition note"> | |
| <p class="admonition-title">Note</p> | |
| <p><code class="xref py py-class docutils literal notranslate"><span class="pre">TypeIgnore</span></code> nodes are not generated when the <em>type_comments</em> parameter | |
| is set to <code class="docutils literal notranslate"><span class="pre">False</span></code> (default). See <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> for more details.</p> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.8.</span></p> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="type-parameters"> | |
| <span id="ast-type-params"></span><h3>Type parameters<a class="headerlink" href="#type-parameters" title="Link to this heading">¶</a></h3> | |
| <p><a class="reference internal" href="../reference/compound_stmts.html#type-params"><span class="std std-ref">Type parameters</span></a> can exist on classes, functions, and type | |
| aliases.</p> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.TypeVar"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TypeVar</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">bound</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">default_value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TypeVar" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <a class="reference internal" href="typing.html#typing.TypeVar" title="typing.TypeVar"><code class="xref py py-class docutils literal notranslate"><span class="pre">typing.TypeVar</span></code></a>. <code class="docutils literal notranslate"><span class="pre">name</span></code> is the name of the type variable. | |
| <code class="docutils literal notranslate"><span class="pre">bound</span></code> is the bound or constraints, if any. If <code class="docutils literal notranslate"><span class="pre">bound</span></code> is a <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a>, | |
| it represents constraints; otherwise it represents the bound. <code class="docutils literal notranslate"><span class="pre">default_value</span></code> | |
| is the default value; if the <code class="xref py py-class docutils literal notranslate"><span class="pre">TypeVar</span></code> has no default, this | |
| attribute will be set to <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"type Alias[T: int = bool] = list[T]"</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> TypeAlias(</span> | |
| <span class="go"> name=Name(id='Alias', ctx=Store()),</span> | |
| <span class="go"> type_params=[</span> | |
| <span class="go"> TypeVar(</span> | |
| <span class="go"> name='T',</span> | |
| <span class="go"> bound=Name(id='int'),</span> | |
| <span class="go"> default_value=Name(id='bool'))],</span> | |
| <span class="go"> value=Subscript(</span> | |
| <span class="go"> value=Name(id='list'),</span> | |
| <span class="go"> slice=Name(id='T')))])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.12.</span></p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.13: </span>Added the <em>default_value</em> parameter.</p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.ParamSpec"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ParamSpec</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">default_value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ParamSpec" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <a class="reference internal" href="typing.html#typing.ParamSpec" title="typing.ParamSpec"><code class="xref py py-class docutils literal notranslate"><span class="pre">typing.ParamSpec</span></code></a>. <code class="docutils literal notranslate"><span class="pre">name</span></code> is the name of the parameter specification. | |
| <code class="docutils literal notranslate"><span class="pre">default_value</span></code> is the default value; if the <code class="xref py py-class docutils literal notranslate"><span class="pre">ParamSpec</span></code> has no default, | |
| this attribute will be set to <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"type Alias[**P = [int, str]] = Callable[P, int]"</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> TypeAlias(</span> | |
| <span class="go"> name=Name(id='Alias', ctx=Store()),</span> | |
| <span class="go"> type_params=[</span> | |
| <span class="go"> ParamSpec(</span> | |
| <span class="go"> name='P',</span> | |
| <span class="go"> default_value=List(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Name(id='int'),</span> | |
| <span class="go"> Name(id='str')]))],</span> | |
| <span class="go"> value=Subscript(</span> | |
| <span class="go"> value=Name(id='Callable'),</span> | |
| <span class="go"> slice=Tuple(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Name(id='P'),</span> | |
| <span class="go"> Name(id='int')])))])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.12.</span></p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.13: </span>Added the <em>default_value</em> parameter.</p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.TypeVarTuple"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TypeVarTuple</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">default_value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TypeVarTuple" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <a class="reference internal" href="typing.html#typing.TypeVarTuple" title="typing.TypeVarTuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">typing.TypeVarTuple</span></code></a>. <code class="docutils literal notranslate"><span class="pre">name</span></code> is the name of the type variable tuple. | |
| <code class="docutils literal notranslate"><span class="pre">default_value</span></code> is the default value; if the <code class="xref py py-class docutils literal notranslate"><span class="pre">TypeVarTuple</span></code> has no | |
| default, this attribute will be set to <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"type Alias[*Ts = ()] = tuple[*Ts]"</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> TypeAlias(</span> | |
| <span class="go"> name=Name(id='Alias', ctx=Store()),</span> | |
| <span class="go"> type_params=[</span> | |
| <span class="go"> TypeVarTuple(name='Ts', default_value=Tuple())],</span> | |
| <span class="go"> value=Subscript(</span> | |
| <span class="go"> value=Name(id='tuple'),</span> | |
| <span class="go"> slice=Tuple(</span> | |
| <span class="go"> elts=[</span> | |
| <span class="go"> Starred(</span> | |
| <span class="go"> value=Name(id='Ts'))])))])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.12.</span></p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.13: </span>Added the <em>default_value</em> parameter.</p> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="function-and-class-definitions"> | |
| <h3>Function and class definitions<a class="headerlink" href="#function-and-class-definitions" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.FunctionDef"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">FunctionDef</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">decorator_list</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">returns</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_params</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.FunctionDef" title="Link to this definition">¶</a></dt> | |
| <dd><p>A function definition.</p> | |
| <ul class="simple"> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">name</span></code> is a raw string of the function name.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">args</span></code> is an <a class="reference internal" href="#ast.arguments" title="ast.arguments"><code class="xref py py-class docutils literal notranslate"><span class="pre">arguments</span></code></a> node.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">body</span></code> is the list of nodes inside the function.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">decorator_list</span></code> is the list of decorators to be applied, stored outermost | |
| first (i.e. the first in the list will be applied last).</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">returns</span></code> is the return annotation.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">type_params</span></code> is a list of <a class="reference internal" href="#ast-type-params"><span class="std std-ref">type parameters</span></a>.</p></li> | |
| </ul> | |
| <dl class="py attribute"> | |
| <dt class="sig sig-object py" id="ast.FunctionDef.type_comment"> | |
| <span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.FunctionDef.type_comment" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment.</p> | |
| </dd></dl> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.12: </span>Added <code class="docutils literal notranslate"><span class="pre">type_params</span></code>.</p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Lambda"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Lambda</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Lambda" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">lambda</span></code> is a minimal function definition that can be used inside an | |
| expression. Unlike <a class="reference internal" href="#ast.FunctionDef" title="ast.FunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">FunctionDef</span></code></a>, <code class="docutils literal notranslate"><span class="pre">body</span></code> holds a single node.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'lambda x,y: ...'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Lambda(</span> | |
| <span class="go"> args=arguments(</span> | |
| <span class="go"> args=[</span> | |
| <span class="go"> arg(arg='x'),</span> | |
| <span class="go"> arg(arg='y')]),</span> | |
| <span class="go"> body=Constant(value=Ellipsis)))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.arguments"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">arguments</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">posonlyargs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">vararg</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwonlyargs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kw_defaults</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwarg</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">defaults</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.arguments" title="Link to this definition">¶</a></dt> | |
| <dd><p>The arguments for a function.</p> | |
| <ul class="simple"> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">posonlyargs</span></code>, <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwonlyargs</span></code> are lists of <a class="reference internal" href="#ast.arg" title="ast.arg"><code class="xref py py-class docutils literal notranslate"><span class="pre">arg</span></code></a> nodes.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">vararg</span></code> and <code class="docutils literal notranslate"><span class="pre">kwarg</span></code> are single <a class="reference internal" href="#ast.arg" title="ast.arg"><code class="xref py py-class docutils literal notranslate"><span class="pre">arg</span></code></a> nodes, referring to the | |
| <code class="docutils literal notranslate"><span class="pre">*args,</span> <span class="pre">**kwargs</span></code> parameters.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">kw_defaults</span></code> is a list of default values for keyword-only arguments. If | |
| one is <code class="docutils literal notranslate"><span class="pre">None</span></code>, the corresponding argument is required.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">defaults</span></code> is a list of default values for arguments that can be passed | |
| positionally. If there are fewer defaults, they correspond to the last n | |
| arguments.</p></li> | |
| </ul> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.arg"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">arg</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">arg</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">annotation</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.arg" title="Link to this definition">¶</a></dt> | |
| <dd><p>A single argument in a list. <code class="docutils literal notranslate"><span class="pre">arg</span></code> is a raw string of the argument | |
| name; <code class="docutils literal notranslate"><span class="pre">annotation</span></code> is its annotation, such as a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node.</p> | |
| <dl class="py attribute"> | |
| <dt class="sig sig-object py" id="ast.arg.type_comment"> | |
| <span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.arg.type_comment" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment</p> | |
| </dd></dl> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span> | |
| <span class="gp">... </span><span class="s2">@decorator1</span> | |
| <span class="gp">... </span><span class="s2">@decorator2</span> | |
| <span class="gp">... </span><span class="s2">def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':</span> | |
| <span class="gp">... </span><span class="s2"> pass</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> FunctionDef(</span> | |
| <span class="go"> name='f',</span> | |
| <span class="go"> args=arguments(</span> | |
| <span class="go"> args=[</span> | |
| <span class="go"> arg(</span> | |
| <span class="go"> arg='a',</span> | |
| <span class="go"> annotation=Constant(value='annotation')),</span> | |
| <span class="go"> arg(arg='b'),</span> | |
| <span class="go"> arg(arg='c')],</span> | |
| <span class="go"> vararg=arg(arg='d'),</span> | |
| <span class="go"> kwonlyargs=[</span> | |
| <span class="go"> arg(arg='e'),</span> | |
| <span class="go"> arg(arg='f')],</span> | |
| <span class="go"> kw_defaults=[</span> | |
| <span class="go"> None,</span> | |
| <span class="go"> Constant(value=3)],</span> | |
| <span class="go"> kwarg=arg(arg='g'),</span> | |
| <span class="go"> defaults=[</span> | |
| <span class="go"> Constant(value=1),</span> | |
| <span class="go"> Constant(value=2)]),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Pass()],</span> | |
| <span class="go"> decorator_list=[</span> | |
| <span class="go"> Name(id='decorator1'),</span> | |
| <span class="go"> Name(id='decorator2')],</span> | |
| <span class="go"> returns=Constant(value='return annotation'))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Return"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Return</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Return" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">return</span></code> statement.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'return 4'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Return(</span> | |
| <span class="go"> value=Constant(value=4))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Yield"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Yield</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Yield" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.YieldFrom"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">YieldFrom</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.YieldFrom" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <code class="docutils literal notranslate"><span class="pre">yield</span></code> or <code class="docutils literal notranslate"><span class="pre">yield</span> <span class="pre">from</span></code> expression. Because these are expressions, they | |
| must be wrapped in an <a class="reference internal" href="#ast.Expr" title="ast.Expr"><code class="xref py py-class docutils literal notranslate"><span class="pre">Expr</span></code></a> node if the value sent back is not used.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'yield x'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Yield(</span> | |
| <span class="go"> value=Name(id='x')))])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'yield from x'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=YieldFrom(</span> | |
| <span class="go"> value=Name(id='x')))])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Global"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Global</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">names</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Global" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.Nonlocal"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Nonlocal</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">names</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Nonlocal" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">global</span></code> and <code class="docutils literal notranslate"><span class="pre">nonlocal</span></code> statements. <code class="docutils literal notranslate"><span class="pre">names</span></code> is a list of raw strings.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'global x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Global(</span> | |
| <span class="go"> names=[</span> | |
| <span class="go"> 'x',</span> | |
| <span class="go"> 'y',</span> | |
| <span class="go"> 'z'])])</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'nonlocal x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Nonlocal(</span> | |
| <span class="go"> names=[</span> | |
| <span class="go"> 'x',</span> | |
| <span class="go"> 'y',</span> | |
| <span class="go"> 'z'])])</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.ClassDef"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ClassDef</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">bases</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keywords</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">decorator_list</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_params</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ClassDef" title="Link to this definition">¶</a></dt> | |
| <dd><p>A class definition.</p> | |
| <ul class="simple"> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">name</span></code> is a raw string for the class name</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">bases</span></code> is a list of nodes for explicitly specified base classes.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">keywords</span></code> is a list of <a class="reference internal" href="#ast.keyword" title="ast.keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">keyword</span></code></a> nodes, principally for ‘metaclass’. | |
| Other keywords will be passed to the metaclass, as per <span class="target" id="index-3"></span><a class="pep reference external" href="https://peps.python.org/pep-3115/"><strong>PEP 3115</strong></a>.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a list of nodes representing the code within the class | |
| definition.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">decorator_list</span></code> is a list of nodes, as in <a class="reference internal" href="#ast.FunctionDef" title="ast.FunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">FunctionDef</span></code></a>.</p></li> | |
| <li><p><code class="docutils literal notranslate"><span class="pre">type_params</span></code> is a list of <a class="reference internal" href="#ast-type-params"><span class="std std-ref">type parameters</span></a>.</p></li> | |
| </ul> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span> | |
| <span class="gp">... </span><span class="s2">@decorator1</span> | |
| <span class="gp">... </span><span class="s2">@decorator2</span> | |
| <span class="gp">... </span><span class="s2">class Foo(base1, base2, metaclass=meta):</span> | |
| <span class="gp">... </span><span class="s2"> pass</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> ClassDef(</span> | |
| <span class="go"> name='Foo',</span> | |
| <span class="go"> bases=[</span> | |
| <span class="go"> Name(id='base1'),</span> | |
| <span class="go"> Name(id='base2')],</span> | |
| <span class="go"> keywords=[</span> | |
| <span class="go"> keyword(</span> | |
| <span class="go"> arg='metaclass',</span> | |
| <span class="go"> value=Name(id='meta'))],</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Pass()],</span> | |
| <span class="go"> decorator_list=[</span> | |
| <span class="go"> Name(id='decorator1'),</span> | |
| <span class="go"> Name(id='decorator2')])])</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.12: </span>Added <code class="docutils literal notranslate"><span class="pre">type_params</span></code>.</p> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="async-and-await"> | |
| <h3>Async and await<a class="headerlink" href="#async-and-await" title="Link to this heading">¶</a></h3> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.AsyncFunctionDef"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AsyncFunctionDef</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">decorator_list</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">returns</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_params</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AsyncFunctionDef" title="Link to this definition">¶</a></dt> | |
| <dd><p>An <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">def</span></code> function definition. Has the same fields as | |
| <a class="reference internal" href="#ast.FunctionDef" title="ast.FunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">FunctionDef</span></code></a>.</p> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.12: </span>Added <code class="docutils literal notranslate"><span class="pre">type_params</span></code>.</p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.Await"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Await</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Await" title="Link to this definition">¶</a></dt> | |
| <dd><p>An <code class="docutils literal notranslate"><span class="pre">await</span></code> expression. <code class="docutils literal notranslate"><span class="pre">value</span></code> is what it waits for. | |
| Only valid in the body of an <a class="reference internal" href="#ast.AsyncFunctionDef" title="ast.AsyncFunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">AsyncFunctionDef</span></code></a>.</p> | |
| </dd></dl> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span> | |
| <span class="gp">... </span><span class="s2">async def f():</span> | |
| <span class="gp">... </span><span class="s2"> await other_func()</span> | |
| <span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Module(</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> AsyncFunctionDef(</span> | |
| <span class="go"> name='f',</span> | |
| <span class="go"> args=arguments(),</span> | |
| <span class="go"> body=[</span> | |
| <span class="go"> Expr(</span> | |
| <span class="go"> value=Await(</span> | |
| <span class="go"> value=Call(</span> | |
| <span class="go"> func=Name(id='other_func'))))])])</span> | |
| </pre></div> | |
| </div> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.AsyncFor"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AsyncFor</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">iter</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AsyncFor" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object py" id="ast.AsyncWith"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AsyncWith</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">items</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AsyncWith" title="Link to this definition">¶</a></dt> | |
| <dd><p><code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">for</span></code> loops and <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">with</span></code> context managers. They have the same | |
| fields as <a class="reference internal" href="#ast.For" title="ast.For"><code class="xref py py-class docutils literal notranslate"><span class="pre">For</span></code></a> and <a class="reference internal" href="#ast.With" title="ast.With"><code class="xref py py-class docutils literal notranslate"><span class="pre">With</span></code></a>, respectively. Only valid in the | |
| body of an <a class="reference internal" href="#ast.AsyncFunctionDef" title="ast.AsyncFunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">AsyncFunctionDef</span></code></a>.</p> | |
| </dd></dl> | |
| <div class="admonition note"> | |
| <p class="admonition-title">Note</p> | |
| <p>When a string is parsed by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a>, operator nodes (subclasses | |
| of <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.operator</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.unaryop</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.cmpop</span></code>, | |
| <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.boolop</span></code> and <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr_context</span></code>) on the returned tree | |
| will be singletons. Changes to one will be reflected in all other | |
| occurrences of the same value (for example, <a class="reference internal" href="#ast.Add" title="ast.Add"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Add</span></code></a>).</p> | |
| </div> | |
| </section> | |
| </section> | |
| <section id="ast-helpers"> | |
| <h2><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> helpers<a class="headerlink" href="#ast-helpers" title="Link to this heading">¶</a></h2> | |
| <p>Apart from the node classes, the <code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> module defines these utility functions | |
| and classes for traversing abstract syntax trees:</p> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.parse"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">parse</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">source</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">filename</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'<unknown>'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">mode</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'exec'</span></span></em>, <em class="sig-param"><span class="keyword-only-separator o"><abbr title="Keyword-only parameters separator (PEP 3102)"><span class="pre">*</span></abbr></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comments</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">feature_version</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">optimize</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">-1</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">module</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.parse" title="Link to this definition">¶</a></dt> | |
| <dd><p>Parse the source into an AST node. Equivalent to <code class="docutils literal notranslate"><span class="pre">compile(source,</span> | |
| <span class="pre">filename,</span> <span class="pre">mode,</span> <span class="pre">flags=FLAGS_VALUE,</span> <span class="pre">optimize=optimize,</span> <span class="pre">module=module)</span></code>, | |
| where <code class="docutils literal notranslate"><span class="pre">FLAGS_VALUE</span></code> is <code class="docutils literal notranslate"><span class="pre">ast.PyCF_ONLY_AST</span></code> if <code class="docutils literal notranslate"><span class="pre">optimize</span> <span class="pre"><=</span> <span class="pre">0</span></code> | |
| and <code class="docutils literal notranslate"><span class="pre">ast.PyCF_OPTIMIZED_AST</span></code> otherwise.</p> | |
| <p>If <code class="docutils literal notranslate"><span class="pre">type_comments=True</span></code> is given, the parser is modified to check | |
| and return type comments as specified by <span class="target" id="index-4"></span><a class="pep reference external" href="https://peps.python.org/pep-0484/"><strong>PEP 484</strong></a> and <span class="target" id="index-5"></span><a class="pep reference external" href="https://peps.python.org/pep-0526/"><strong>PEP 526</strong></a>. | |
| This is equivalent to adding <a class="reference internal" href="#ast.PyCF_TYPE_COMMENTS" title="ast.PyCF_TYPE_COMMENTS"><code class="xref py py-data docutils literal notranslate"><span class="pre">ast.PyCF_TYPE_COMMENTS</span></code></a> to the | |
| flags passed to <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a>. This will report syntax errors | |
| for misplaced type comments. Without this flag, type comments will | |
| be ignored, and the <code class="docutils literal notranslate"><span class="pre">type_comment</span></code> field on selected AST nodes | |
| will always be <code class="docutils literal notranslate"><span class="pre">None</span></code>. In addition, the locations of <code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span> | |
| <span class="pre">ignore</span></code> comments will be returned as the <code class="docutils literal notranslate"><span class="pre">type_ignores</span></code> | |
| attribute of <a class="reference internal" href="#ast.Module" title="ast.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">Module</span></code></a> (otherwise it is always an empty list).</p> | |
| <p>In addition, if <code class="docutils literal notranslate"><span class="pre">mode</span></code> is <code class="docutils literal notranslate"><span class="pre">'func_type'</span></code>, the input syntax is | |
| modified to correspond to <span class="target" id="index-6"></span><a class="pep reference external" href="https://peps.python.org/pep-0484/"><strong>PEP 484</strong></a> “signature type comments”, | |
| e.g. <code class="docutils literal notranslate"><span class="pre">(str,</span> <span class="pre">int)</span> <span class="pre">-></span> <span class="pre">List[str]</span></code>.</p> | |
| <p>Setting <code class="docutils literal notranslate"><span class="pre">feature_version</span></code> to a tuple <code class="docutils literal notranslate"><span class="pre">(major,</span> <span class="pre">minor)</span></code> will result in | |
| a “best-effort” attempt to parse using that Python version’s grammar. | |
| For example, setting <code class="docutils literal notranslate"><span class="pre">feature_version=(3,</span> <span class="pre">9)</span></code> will attempt to disallow | |
| parsing of <a class="reference internal" href="../reference/compound_stmts.html#match"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">match</span></code></a> statements. | |
| Currently <code class="docutils literal notranslate"><span class="pre">major</span></code> must equal to <code class="docutils literal notranslate"><span class="pre">3</span></code>. The lowest supported version is | |
| <code class="docutils literal notranslate"><span class="pre">(3,</span> <span class="pre">7)</span></code> (and this may increase in future Python versions); | |
| the highest is <code class="docutils literal notranslate"><span class="pre">sys.version_info[0:2]</span></code>. “Best-effort” attempt means there | |
| is no guarantee that the parse (or success of the parse) is the same as | |
| when run on the Python version corresponding to <code class="docutils literal notranslate"><span class="pre">feature_version</span></code>.</p> | |
| <p>If source contains a null character (<code class="docutils literal notranslate"><span class="pre">\0</span></code>), <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.</p> | |
| <div class="admonition warning"> | |
| <p class="admonition-title">Warning</p> | |
| <p>Note that successfully parsing source code into an AST object doesn’t | |
| guarantee that the source code provided is valid Python code that can | |
| be executed as the compilation step can raise further <a class="reference internal" href="exceptions.html#SyntaxError" title="SyntaxError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">SyntaxError</span></code></a> | |
| exceptions. For instance, the source <code class="docutils literal notranslate"><span class="pre">return</span> <span class="pre">42</span></code> generates a valid | |
| AST node for a return statement, but it cannot be compiled alone (it needs | |
| to be inside a function node).</p> | |
| <p>In particular, <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> won’t do any scoping checks, which the | |
| compilation step does.</p> | |
| </div> | |
| <div class="admonition warning"> | |
| <p class="admonition-title">Warning</p> | |
| <p>It is possible to crash the Python interpreter with a | |
| sufficiently large/complex string due to stack depth limitations | |
| in Python’s AST compiler.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.8: </span>Added <code class="docutils literal notranslate"><span class="pre">type_comments</span></code>, <code class="docutils literal notranslate"><span class="pre">mode='func_type'</span></code> and <code class="docutils literal notranslate"><span class="pre">feature_version</span></code>.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.13: </span>The minimum supported version for <code class="docutils literal notranslate"><span class="pre">feature_version</span></code> is now <code class="docutils literal notranslate"><span class="pre">(3,</span> <span class="pre">7)</span></code>. | |
| The <code class="docutils literal notranslate"><span class="pre">optimize</span></code> argument was added.</p> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.15: </span>Added the <em>module</em> parameter.</p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.unparse"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">unparse</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">ast_obj</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.unparse" title="Link to this definition">¶</a></dt> | |
| <dd><p>Unparse an <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.AST</span></code></a> object and generate a string with code | |
| that would produce an equivalent <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.AST</span></code> object if parsed | |
| back with <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a>.</p> | |
| <div class="admonition warning"> | |
| <p class="admonition-title">Warning</p> | |
| <p>The produced code string will not necessarily be equal to the original | |
| code that generated the <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.AST</span></code></a> object (without any compiler | |
| optimizations, such as constant tuples/frozensets).</p> | |
| </div> | |
| <div class="admonition warning"> | |
| <p class="admonition-title">Warning</p> | |
| <p>Trying to unparse a highly complex expression would result with | |
| <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>.</p> | |
| </div> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.9.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.literal_eval"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">literal_eval</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node_or_string</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.literal_eval" title="Link to this definition">¶</a></dt> | |
| <dd><p>Evaluate an expression node or a string containing only a Python literal or | |
| container display. The string or node provided may only consist of the | |
| following Python literal structures: strings, bytes, numbers, tuples, lists, | |
| dicts, sets, booleans, <code class="docutils literal notranslate"><span class="pre">None</span></code> and <code class="docutils literal notranslate"><span class="pre">Ellipsis</span></code>.</p> | |
| <p>This can be used for evaluating strings containing Python values without the | |
| need to parse the values oneself. It is not capable of evaluating | |
| arbitrarily complex expressions, for example involving operators or | |
| indexing.</p> | |
| <p>This function had been documented as “safe” in the past without defining | |
| what that meant. That was misleading. This is specifically designed not to | |
| execute Python code, unlike the more general <a class="reference internal" href="functions.html#eval" title="eval"><code class="xref py py-func docutils literal notranslate"><span class="pre">eval()</span></code></a>. There is no | |
| namespace, no name lookups, or ability to call out. But it is not free from | |
| attack: A relatively small input can lead to memory exhaustion or to C stack | |
| exhaustion, crashing the process. There is also the possibility for | |
| excessive CPU consumption denial of service on some inputs. Calling it on | |
| untrusted data is thus not recommended.</p> | |
| <div class="admonition warning"> | |
| <p class="admonition-title">Warning</p> | |
| <p>It is possible to crash the Python interpreter due to stack depth | |
| limitations in Python’s AST compiler.</p> | |
| <p>It can raise <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>, <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>, <a class="reference internal" href="exceptions.html#SyntaxError" title="SyntaxError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">SyntaxError</span></code></a>, | |
| <a class="reference internal" href="exceptions.html#MemoryError" title="MemoryError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">MemoryError</span></code></a> and <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> depending on the malformed | |
| input.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.2: </span>Now allows bytes and set literals.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.9: </span>Now supports creating empty sets with <code class="docutils literal notranslate"><span class="pre">'set()'</span></code>.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.10: </span>For string inputs, leading spaces and tabs are now stripped.</p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.get_docstring"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">get_docstring</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">clean</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.get_docstring" title="Link to this definition">¶</a></dt> | |
| <dd><p>Return the docstring of the given <em>node</em> (which must be a | |
| <a class="reference internal" href="#ast.FunctionDef" title="ast.FunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">FunctionDef</span></code></a>, <a class="reference internal" href="#ast.AsyncFunctionDef" title="ast.AsyncFunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">AsyncFunctionDef</span></code></a>, <a class="reference internal" href="#ast.ClassDef" title="ast.ClassDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClassDef</span></code></a>, | |
| or <a class="reference internal" href="#ast.Module" title="ast.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">Module</span></code></a> node), or <code class="docutils literal notranslate"><span class="pre">None</span></code> if it has no docstring. | |
| If <em>clean</em> is true, clean up the docstring’s indentation with | |
| <a class="reference internal" href="inspect.html#inspect.cleandoc" title="inspect.cleandoc"><code class="xref py py-func docutils literal notranslate"><span class="pre">inspect.cleandoc()</span></code></a>.</p> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.5: </span><a class="reference internal" href="#ast.AsyncFunctionDef" title="ast.AsyncFunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">AsyncFunctionDef</span></code></a> is now supported.</p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.get_source_segment"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">get_source_segment</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">source</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="keyword-only-separator o"><abbr title="Keyword-only parameters separator (PEP 3102)"><span class="pre">*</span></abbr></span></em>, <em class="sig-param"><span class="n"><span class="pre">padded</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.get_source_segment" title="Link to this definition">¶</a></dt> | |
| <dd><p>Get source code segment of the <em>source</em> that generated <em>node</em>. | |
| If some location information (<a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a>, <a class="reference internal" href="#ast.AST.end_lineno" title="ast.AST.end_lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_lineno</span></code></a>, | |
| <a class="reference internal" href="#ast.AST.col_offset" title="ast.AST.col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code></a>, or <a class="reference internal" href="#ast.AST.end_col_offset" title="ast.AST.end_col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_col_offset</span></code></a>) is missing, return <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p> | |
| <p>If <em>padded</em> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the first line of a multi-line statement will | |
| be padded with spaces to match its original position.</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.8.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.fix_missing_locations"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">fix_missing_locations</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.fix_missing_locations" title="Link to this definition">¶</a></dt> | |
| <dd><p>When you compile a node tree with <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a>, the compiler expects | |
| <a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a> and <a class="reference internal" href="#ast.AST.col_offset" title="ast.AST.col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code></a> attributes for every node that supports | |
| them. This is rather tedious to fill in for generated nodes, so this helper | |
| adds these attributes recursively where not already set, by setting them to | |
| the values of the parent node. It works recursively starting at <em>node</em>.</p> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.increment_lineno"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">increment_lineno</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">1</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.increment_lineno" title="Link to this definition">¶</a></dt> | |
| <dd><p>Increment the line number and end line number of each node in the tree | |
| starting at <em>node</em> by <em>n</em>. This is useful to “move code” to a different | |
| location in a file.</p> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.copy_location"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">copy_location</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">new_node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">old_node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.copy_location" title="Link to this definition">¶</a></dt> | |
| <dd><p>Copy source location (<a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a>, <a class="reference internal" href="#ast.AST.col_offset" title="ast.AST.col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code></a>, <a class="reference internal" href="#ast.AST.end_lineno" title="ast.AST.end_lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_lineno</span></code></a>, | |
| and <a class="reference internal" href="#ast.AST.end_col_offset" title="ast.AST.end_col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_col_offset</span></code></a>) from <em>old_node</em> to <em>new_node</em> if possible, | |
| and return <em>new_node</em>.</p> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.iter_fields"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">iter_fields</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.iter_fields" title="Link to this definition">¶</a></dt> | |
| <dd><p>Yield a tuple of <code class="docutils literal notranslate"><span class="pre">(fieldname,</span> <span class="pre">value)</span></code> for each field in <code class="docutils literal notranslate"><span class="pre">node._fields</span></code> | |
| that is present on <em>node</em>.</p> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.iter_child_nodes"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">iter_child_nodes</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.iter_child_nodes" title="Link to this definition">¶</a></dt> | |
| <dd><p>Yield all direct child nodes of <em>node</em>, that is, all fields that are nodes | |
| and all items of fields that are lists of nodes.</p> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.walk"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">walk</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.walk" title="Link to this definition">¶</a></dt> | |
| <dd><p>Recursively yield all descendant nodes in the tree starting at <em>node</em> | |
| (including <em>node</em> itself), in no specified order. This is useful if you only | |
| want to modify nodes in place and don’t care about the context.</p> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.NodeVisitor"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NodeVisitor</span></span><a class="headerlink" href="#ast.NodeVisitor" title="Link to this definition">¶</a></dt> | |
| <dd><p>A node visitor base class that walks the abstract syntax tree and calls a | |
| visitor function for every node found. This function may return a value | |
| which is forwarded by the <a class="reference internal" href="#ast.NodeVisitor.visit" title="ast.NodeVisitor.visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">visit()</span></code></a> method.</p> | |
| <p>This class is meant to be subclassed, with the subclass adding visitor | |
| methods.</p> | |
| <dl class="py method"> | |
| <dt class="sig sig-object py" id="ast.NodeVisitor.visit"> | |
| <span class="sig-name descname"><span class="pre">visit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.NodeVisitor.visit" title="Link to this definition">¶</a></dt> | |
| <dd><p>Visit a node. The default implementation calls the method called | |
| <code class="samp docutils literal notranslate"><span class="pre">self.visit_</span><em><span class="pre">classname</span></em></code> where <em>classname</em> is the name of the node | |
| class, or <a class="reference internal" href="#ast.NodeVisitor.generic_visit" title="ast.NodeVisitor.generic_visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">generic_visit()</span></code></a> if that method doesn’t exist.</p> | |
| </dd></dl> | |
| <dl class="py method"> | |
| <dt class="sig sig-object py" id="ast.NodeVisitor.generic_visit"> | |
| <span class="sig-name descname"><span class="pre">generic_visit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.NodeVisitor.generic_visit" title="Link to this definition">¶</a></dt> | |
| <dd><p>This visitor calls <a class="reference internal" href="#ast.NodeVisitor.visit" title="ast.NodeVisitor.visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">visit()</span></code></a> on all children of the node.</p> | |
| <p>Note that child nodes of nodes that have a custom visitor method won’t be | |
| visited unless the visitor calls <code class="xref py py-meth docutils literal notranslate"><span class="pre">generic_visit()</span></code> or visits them | |
| itself.</p> | |
| </dd></dl> | |
| <dl class="py method"> | |
| <dt class="sig sig-object py" id="ast.NodeVisitor.visit_Constant"> | |
| <span class="sig-name descname"><span class="pre">visit_Constant</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.NodeVisitor.visit_Constant" title="Link to this definition">¶</a></dt> | |
| <dd><p>Handles all constant nodes.</p> | |
| </dd></dl> | |
| <p>Don’t use the <code class="xref py py-class docutils literal notranslate"><span class="pre">NodeVisitor</span></code> if you want to apply changes to nodes | |
| during traversal. For this a special visitor exists | |
| (<a class="reference internal" href="#ast.NodeTransformer" title="ast.NodeTransformer"><code class="xref py py-class docutils literal notranslate"><span class="pre">NodeTransformer</span></code></a>) that allows modifications.</p> | |
| <div class="deprecated-removed"> | |
| <p><span class="versionmodified removed">Deprecated since version 3.8, removed in version 3.14: </span>Methods <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Num()</span></code>, <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Str()</span></code>, <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Bytes()</span></code>, | |
| <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_NameConstant()</span></code> and <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Ellipsis()</span></code> will not be called | |
| in Python 3.14+. Add the <a class="reference internal" href="#ast.NodeVisitor.visit_Constant" title="ast.NodeVisitor.visit_Constant"><code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Constant()</span></code></a> method instead to handle | |
| all constant nodes.</p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py class"> | |
| <dt class="sig sig-object py" id="ast.NodeTransformer"> | |
| <em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NodeTransformer</span></span><a class="headerlink" href="#ast.NodeTransformer" title="Link to this definition">¶</a></dt> | |
| <dd><p>A <a class="reference internal" href="#ast.NodeVisitor" title="ast.NodeVisitor"><code class="xref py py-class docutils literal notranslate"><span class="pre">NodeVisitor</span></code></a> subclass that walks the abstract syntax tree and | |
| allows modification of nodes.</p> | |
| <p>The <code class="xref py py-class docutils literal notranslate"><span class="pre">NodeTransformer</span></code> will walk the AST and use the return value of | |
| the visitor methods to replace or remove the old node. If the return value | |
| of the visitor method is <code class="docutils literal notranslate"><span class="pre">None</span></code>, the node will be removed from its | |
| location, otherwise it is replaced with the return value. The return value | |
| may be the original node in which case no replacement takes place.</p> | |
| <p>Here is an example transformer that rewrites all occurrences of name lookups | |
| (<code class="docutils literal notranslate"><span class="pre">foo</span></code>) to <code class="docutils literal notranslate"><span class="pre">data['foo']</span></code>:</p> | |
| <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span><span class="w"> </span><span class="nc">RewriteName</span><span class="p">(</span><span class="n">NodeTransformer</span><span class="p">):</span> | |
| <span class="k">def</span><span class="w"> </span><span class="nf">visit_Name</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">node</span><span class="p">):</span> | |
| <span class="k">return</span> <span class="n">Subscript</span><span class="p">(</span> | |
| <span class="n">value</span><span class="o">=</span><span class="n">Name</span><span class="p">(</span><span class="nb">id</span><span class="o">=</span><span class="s1">'data'</span><span class="p">),</span> | |
| <span class="nb">slice</span><span class="o">=</span><span class="n">Constant</span><span class="p">(</span><span class="n">value</span><span class="o">=</span><span class="n">node</span><span class="o">.</span><span class="n">id</span><span class="p">),</span> | |
| <span class="n">ctx</span><span class="o">=</span><span class="n">node</span><span class="o">.</span><span class="n">ctx</span> | |
| <span class="p">)</span> | |
| </pre></div> | |
| </div> | |
| <p>Keep in mind that if the node you’re operating on has child nodes you must | |
| either transform the child nodes yourself or call the <a class="reference internal" href="#ast.NodeVisitor.generic_visit" title="ast.NodeVisitor.generic_visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">generic_visit()</span></code></a> | |
| method for the node first.</p> | |
| <p>For nodes that were part of a collection of statements (that applies to all | |
| statement nodes), the visitor may also return a list of nodes rather than | |
| just a single node.</p> | |
| <p>If <code class="xref py py-class docutils literal notranslate"><span class="pre">NodeTransformer</span></code> introduces new nodes (that weren’t part of | |
| original tree) without giving them location information (such as | |
| <a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a>), <a class="reference internal" href="#ast.fix_missing_locations" title="ast.fix_missing_locations"><code class="xref py py-func docutils literal notranslate"><span class="pre">fix_missing_locations()</span></code></a> should be called with | |
| the new sub-tree to recalculate the location information:</p> | |
| <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tree</span> <span class="o">=</span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'foo'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">)</span> | |
| <span class="n">new_tree</span> <span class="o">=</span> <span class="n">fix_missing_locations</span><span class="p">(</span><span class="n">RewriteName</span><span class="p">()</span><span class="o">.</span><span class="n">visit</span><span class="p">(</span><span class="n">tree</span><span class="p">))</span> | |
| </pre></div> | |
| </div> | |
| <p>Usually you use the transformer like this:</p> | |
| <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">node</span> <span class="o">=</span> <span class="n">YourTransformer</span><span class="p">()</span><span class="o">.</span><span class="n">visit</span><span class="p">(</span><span class="n">node</span><span class="p">)</span> | |
| </pre></div> | |
| </div> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.dump"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">dump</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">annotate_fields</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">include_attributes</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="keyword-only-separator o"><abbr title="Keyword-only parameters separator (PEP 3102)"><span class="pre">*</span></abbr></span></em>, <em class="sig-param"><span class="n"><span class="pre">indent</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">show_empty</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.dump" title="Link to this definition">¶</a></dt> | |
| <dd><p>Return a formatted dump of the tree in <em>node</em>. This is mainly useful for | |
| debugging purposes. If <em>annotate_fields</em> is true (by default), | |
| the returned string will show the names and the values for fields. | |
| If <em>annotate_fields</em> is false, the result string will be more compact by | |
| omitting unambiguous field names. Attributes such as line | |
| numbers and column offsets are not dumped by default. If this is wanted, | |
| <em>include_attributes</em> can be set to true.</p> | |
| <p>If <em>indent</em> is a non-negative integer or string, then the tree will be | |
| pretty-printed with that indent level. An indent level | |
| of 0, negative, or <code class="docutils literal notranslate"><span class="pre">""</span></code> will only insert newlines. <code class="docutils literal notranslate"><span class="pre">None</span></code> (the default) | |
| selects the single line representation. Using a positive integer indent | |
| indents that many spaces per level. If <em>indent</em> is a string (such as <code class="docutils literal notranslate"><span class="pre">"\t"</span></code>), | |
| that string is used to indent each level.</p> | |
| <p>If <em>show_empty</em> is false (the default), optional empty lists and | |
| <code class="docutils literal notranslate"><span class="pre">Load()</span></code> values will be omitted from the output. | |
| Optional <code class="docutils literal notranslate"><span class="pre">None</span></code> values are always omitted.</p> | |
| <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">tree</span> <span class="o">=</span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'print(None)'</span><span class="p">,</span> <span class="s1">'?'</span><span class="p">,</span> <span class="s1">'eval'</span><span class="p">)</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">tree</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Call(</span> | |
| <span class="go"> func=Name(id='print'),</span> | |
| <span class="go"> args=[</span> | |
| <span class="go"> Constant(value=None)]))</span> | |
| <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">tree</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> <span class="n">show_empty</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span> | |
| <span class="go">Expression(</span> | |
| <span class="go"> body=Call(</span> | |
| <span class="go"> func=Name(id='print', ctx=Load()),</span> | |
| <span class="go"> args=[</span> | |
| <span class="go"> Constant(value=None)],</span> | |
| <span class="go"> keywords=[]))</span> | |
| </pre></div> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.9: </span>Added the <em>indent</em> option.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.13: </span>Added the <em>show_empty</em> option.</p> | |
| </div> | |
| <div class="versionchanged"> | |
| <p><span class="versionmodified changed">Changed in version 3.15: </span>Omit optional <code class="docutils literal notranslate"><span class="pre">Load()</span></code> values by default.</p> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="compiler-flags"> | |
| <span id="ast-compiler-flags"></span><h2>Compiler flags<a class="headerlink" href="#compiler-flags" title="Link to this heading">¶</a></h2> | |
| <p>The following flags may be passed to <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a> in order to change | |
| effects on the compilation of a program:</p> | |
| <dl class="py data"> | |
| <dt class="sig sig-object py" id="ast.PyCF_ALLOW_TOP_LEVEL_AWAIT"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">PyCF_ALLOW_TOP_LEVEL_AWAIT</span></span><a class="headerlink" href="#ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" title="Link to this definition">¶</a></dt> | |
| <dd><p>Enables support for top-level <code class="docutils literal notranslate"><span class="pre">await</span></code>, <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">for</span></code>, <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">with</span></code> | |
| and async comprehensions.</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.8.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py data"> | |
| <dt class="sig sig-object py" id="ast.PyCF_ONLY_AST"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">PyCF_ONLY_AST</span></span><a class="headerlink" href="#ast.PyCF_ONLY_AST" title="Link to this definition">¶</a></dt> | |
| <dd><p>Generates and returns an abstract syntax tree instead of returning a | |
| compiled code object.</p> | |
| </dd></dl> | |
| <dl class="py data"> | |
| <dt class="sig sig-object py" id="ast.PyCF_OPTIMIZED_AST"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">PyCF_OPTIMIZED_AST</span></span><a class="headerlink" href="#ast.PyCF_OPTIMIZED_AST" title="Link to this definition">¶</a></dt> | |
| <dd><p>The returned AST is optimized according to the <em>optimize</em> argument | |
| in <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a> or <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a>.</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.13.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py data"> | |
| <dt class="sig sig-object py" id="ast.PyCF_TYPE_COMMENTS"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">PyCF_TYPE_COMMENTS</span></span><a class="headerlink" href="#ast.PyCF_TYPE_COMMENTS" title="Link to this definition">¶</a></dt> | |
| <dd><p>Enables support for <span class="target" id="index-7"></span><a class="pep reference external" href="https://peps.python.org/pep-0484/"><strong>PEP 484</strong></a> and <span class="target" id="index-8"></span><a class="pep reference external" href="https://peps.python.org/pep-0526/"><strong>PEP 526</strong></a> style type comments | |
| (<code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span> <span class="pre"><type></span></code>, <code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span> <span class="pre">ignore</span> <span class="pre"><stuff></span></code>).</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.8.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="py function"> | |
| <dt class="sig sig-object py" id="ast.compare"> | |
| <span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">compare</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">b</span></span></em>, <em class="sig-param"><span class="positional-only-separator o"><abbr title="Positional-only parameter separator (PEP 570)"><span class="pre">/</span></abbr></span></em>, <em class="sig-param"><span class="keyword-only-separator o"><abbr title="Keyword-only parameters separator (PEP 3102)"><span class="pre">*</span></abbr></span></em>, <em class="sig-param"><span class="n"><span class="pre">compare_attributes</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.compare" title="Link to this definition">¶</a></dt> | |
| <dd><p>Recursively compares two ASTs.</p> | |
| <p><em>compare_attributes</em> affects whether AST attributes are considered | |
| in the comparison. If <em>compare_attributes</em> is <code class="docutils literal notranslate"><span class="pre">False</span></code> (default), then | |
| attributes are ignored. Otherwise they must all be equal. This | |
| option is useful to check whether the ASTs are structurally equal but | |
| differ in whitespace or similar details. Attributes include line numbers | |
| and column offsets.</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.14.</span></p> | |
| </div> | |
| </dd></dl> | |
| </section> | |
| <section id="command-line-usage"> | |
| <span id="ast-cli"></span><h2>Command-line usage<a class="headerlink" href="#command-line-usage" title="Link to this heading">¶</a></h2> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.9.</span></p> | |
| </div> | |
| <p>The <code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> module can be executed as a script from the command line. | |
| It is as simple as:</p> | |
| <div class="highlight-sh notranslate"><div class="highlight"><pre><span></span>python<span class="w"> </span>-m<span class="w"> </span>ast<span class="w"> </span><span class="o">[</span>-m<span class="w"> </span><mode><span class="o">]</span><span class="w"> </span><span class="o">[</span>-a<span class="o">]</span><span class="w"> </span><span class="o">[</span>infile<span class="o">]</span> | |
| </pre></div> | |
| </div> | |
| <p>The following options are accepted:</p> | |
| <dl class="std option"> | |
| <dt class="sig sig-object std" id="cmdoption-ast-h"> | |
| <span id="cmdoption-ast-help"></span><span class="sig-name descname"><span class="pre">-h</span></span><span class="sig-prename descclassname"></span><span class="sig-prename descclassname"><span class="pre">,</span> </span><span class="sig-name descname"><span class="pre">--help</span></span><span class="sig-prename descclassname"></span><a class="headerlink" href="#cmdoption-ast-h" title="Link to this definition">¶</a></dt> | |
| <dd><p>Show the help message and exit.</p> | |
| </dd></dl> | |
| <dl class="std option"> | |
| <dt class="sig sig-object std" id="cmdoption-ast-m"> | |
| <span class="sig-name descname"><span class="pre">-m</span></span><span class="sig-prename descclassname"> <span class="pre"><mode></span></span><a class="headerlink" href="#cmdoption-ast-m" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object std" id="cmdoption-ast-mode"> | |
| <span class="sig-name descname"><span class="pre">--mode</span></span><span class="sig-prename descclassname"> <span class="pre"><mode></span></span><a class="headerlink" href="#cmdoption-ast-mode" title="Link to this definition">¶</a></dt> | |
| <dd><p>Specify what kind of code must be compiled, like the <em>mode</em> argument | |
| in <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">parse()</span></code></a>.</p> | |
| </dd></dl> | |
| <dl class="std option"> | |
| <dt class="sig sig-object std" id="cmdoption-ast-no-type-comments"> | |
| <span class="sig-name descname"><span class="pre">--no-type-comments</span></span><span class="sig-prename descclassname"></span><a class="headerlink" href="#cmdoption-ast-no-type-comments" title="Link to this definition">¶</a></dt> | |
| <dd><p>Don’t parse type comments.</p> | |
| </dd></dl> | |
| <dl class="std option"> | |
| <dt class="sig sig-object std" id="cmdoption-ast-a"> | |
| <span id="cmdoption-ast-include-attributes"></span><span class="sig-name descname"><span class="pre">-a</span></span><span class="sig-prename descclassname"></span><span class="sig-prename descclassname"><span class="pre">,</span> </span><span class="sig-name descname"><span class="pre">--include-attributes</span></span><span class="sig-prename descclassname"></span><a class="headerlink" href="#cmdoption-ast-a" title="Link to this definition">¶</a></dt> | |
| <dd><p>Include attributes such as line numbers and column offsets.</p> | |
| </dd></dl> | |
| <dl class="std option"> | |
| <dt class="sig sig-object std" id="cmdoption-ast-i"> | |
| <span class="sig-name descname"><span class="pre">-i</span></span><span class="sig-prename descclassname"> <span class="pre"><indent></span></span><a class="headerlink" href="#cmdoption-ast-i" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object std" id="cmdoption-ast-indent"> | |
| <span class="sig-name descname"><span class="pre">--indent</span></span><span class="sig-prename descclassname"> <span class="pre"><indent></span></span><a class="headerlink" href="#cmdoption-ast-indent" title="Link to this definition">¶</a></dt> | |
| <dd><p>Indentation of nodes in AST (number of spaces).</p> | |
| </dd></dl> | |
| <dl class="std option"> | |
| <dt class="sig sig-object std" id="cmdoption-ast-feature-version"> | |
| <span class="sig-name descname"><span class="pre">--feature-version</span></span><span class="sig-prename descclassname"> <span class="pre"><version></span></span><a class="headerlink" href="#cmdoption-ast-feature-version" title="Link to this definition">¶</a></dt> | |
| <dd><p>Python version in the format 3.x (for example, 3.10). Defaults to the | |
| current version of the interpreter.</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.14.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="std option"> | |
| <dt class="sig sig-object std" id="cmdoption-ast-O"> | |
| <span class="sig-name descname"><span class="pre">-O</span></span><span class="sig-prename descclassname"> <span class="pre"><level></span></span><a class="headerlink" href="#cmdoption-ast-O" title="Link to this definition">¶</a></dt> | |
| <dt class="sig sig-object std" id="cmdoption-ast-optimize"> | |
| <span class="sig-name descname"><span class="pre">--optimize</span></span><span class="sig-prename descclassname"> <span class="pre"><level></span></span><a class="headerlink" href="#cmdoption-ast-optimize" title="Link to this definition">¶</a></dt> | |
| <dd><p>Optimization level for parser. Defaults to no optimization.</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.14.</span></p> | |
| </div> | |
| </dd></dl> | |
| <dl class="std option"> | |
| <dt class="sig sig-object std" id="cmdoption-ast-show-empty"> | |
| <span class="sig-name descname"><span class="pre">--show-empty</span></span><span class="sig-prename descclassname"></span><a class="headerlink" href="#cmdoption-ast-show-empty" title="Link to this definition">¶</a></dt> | |
| <dd><p>Show empty lists and fields that are <code class="docutils literal notranslate"><span class="pre">None</span></code>. Defaults to not showing empty | |
| objects.</p> | |
| <div class="versionadded"> | |
| <p><span class="versionmodified added">Added in version 3.14.</span></p> | |
| </div> | |
| </dd></dl> | |
| <p>If <code class="file docutils literal notranslate"><span class="pre">infile</span></code> is specified its contents are parsed to AST and dumped | |
| to stdout. Otherwise, the content is read from stdin.</p> | |
| <div class="admonition seealso"> | |
| <p class="admonition-title">See also</p> | |
| <p><a class="reference external" href="https://greentreesnakes.readthedocs.io/">Green Tree Snakes</a>, an external | |
| documentation resource, has good details on working with Python ASTs.</p> | |
| <p><a class="reference external" href="https://asttokens.readthedocs.io/en/latest/user-guide.html">ASTTokens</a> | |
| annotates Python ASTs with the positions of tokens and text in the source | |
| code that generated them. This is helpful for tools that make source code | |
| transformations.</p> | |
| <p><a class="reference external" href="https://leo-editor.github.io/leo-editor/appendices.html#leoast-py">leoAst.py</a> | |
| unifies the | |
| token-based and parse-tree-based views of python programs by inserting | |
| two-way links between tokens and ast nodes.</p> | |
| <p><a class="reference external" href="https://libcst.readthedocs.io/">LibCST</a> parses code as a Concrete Syntax | |
| Tree that looks like an ast tree and keeps all formatting details. It’s | |
| useful for building automated refactoring (codemod) applications and | |
| linters.</p> | |
| <p><a class="reference external" href="https://parso.readthedocs.io">Parso</a> is a Python parser that supports | |
| error recovery and round-trip parsing for different Python versions (in | |
| multiple Python versions). Parso is also able to list multiple syntax errors | |
| in your Python file.</p> | |
| </div> | |
| </section> | |
| </section> | |
| <div class="clearer"></div> | |
| </div> | |
| </div> | |
| </div> | |
| <div class="sphinxsidebar" role="navigation" aria-label="Main"> | |
| <div class="sphinxsidebarwrapper"> | |
| <div> | |
| <h3><a href="../contents.html">Table of Contents</a></h3> | |
| <ul> | |
| <li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract syntax trees</a><ul> | |
| <li><a class="reference internal" href="#abstract-grammar">Abstract grammar</a></li> | |
| <li><a class="reference internal" href="#node-classes">Node classes</a><ul> | |
| <li><a class="reference internal" href="#root-nodes">Root nodes</a></li> | |
| <li><a class="reference internal" href="#literals">Literals</a></li> | |
| <li><a class="reference internal" href="#variables">Variables</a></li> | |
| <li><a class="reference internal" href="#expressions">Expressions</a><ul> | |
| <li><a class="reference internal" href="#subscripting">Subscripting</a></li> | |
| <li><a class="reference internal" href="#comprehensions">Comprehensions</a></li> | |
| </ul> | |
| </li> | |
| <li><a class="reference internal" href="#statements">Statements</a><ul> | |
| <li><a class="reference internal" href="#imports">Imports</a></li> | |
| </ul> | |
| </li> | |
| <li><a class="reference internal" href="#control-flow">Control flow</a></li> | |
| <li><a class="reference internal" href="#pattern-matching">Pattern matching</a></li> | |
| <li><a class="reference internal" href="#type-annotations">Type annotations</a></li> | |
| <li><a class="reference internal" href="#type-parameters">Type parameters</a></li> | |
| <li><a class="reference internal" href="#function-and-class-definitions">Function and class definitions</a></li> | |
| <li><a class="reference internal" href="#async-and-await">Async and await</a></li> | |
| </ul> | |
| </li> | |
| <li><a class="reference internal" href="#ast-helpers"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> helpers</a></li> | |
| <li><a class="reference internal" href="#compiler-flags">Compiler flags</a></li> | |
| <li><a class="reference internal" href="#command-line-usage">Command-line usage</a></li> | |
| </ul> | |
| </li> | |
| </ul> | |
| </div> | |
| <div> | |
| <h4>Previous topic</h4> | |
| <p class="topless"><a href="language.html" | |
| title="previous chapter">Python Language Services</a></p> | |
| </div> | |
| <div> | |
| <h4>Next topic</h4> | |
| <p class="topless"><a href="symtable.html" | |
| title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">symtable</span></code> — Access to the compiler’s symbol tables</a></p> | |
| </div> | |
| <script> | |
| document.addEventListener('DOMContentLoaded', () => { | |
| const title = document.querySelector('meta[property="og:title"]').content; | |
| const elements = document.querySelectorAll('.improvepage'); | |
| const pageurl = window.location.href.split('?')[0]; | |
| elements.forEach(element => { | |
| const url = new URL(element.href.split('?')[0].replace("-nojs", "")); | |
| url.searchParams.set('pagetitle', title); | |
| url.searchParams.set('pageurl', pageurl); | |
| url.searchParams.set('pagesource', "library/ast.rst"); | |
| element.href = url.toString(); | |
| }); | |
| }); | |
| </script> | |
| <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 class="improvepage" href="../improve-page-nojs.html">Improve this page</a></li> | |
| <li> | |
| <a href="https://github.com/python/cpython/blob/main/Doc/library/ast.rst?plain=1" | |
| rel="nofollow">Show source | |
| </a> | |
| </li> | |
| </ul> | |
| </div> | |
| </div> | |
| <div id="sidebarbutton" title="Collapse sidebar"> | |
| <span>«</span> | |
| </div> | |
| </div> | |
| <div class="clearer"></div> | |
| </div> | |
| <div class="related" role="navigation" aria-label="Related"> | |
| <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="symtable.html" title="symtable — Access to the compiler’s symbol tables" | |
| >next</a> |</li> | |
| <li class="right" > | |
| <a href="language.html" title="Python Language Services" | |
| >previous</a> |</li> | |
| <li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"></li> | |
| <li><a href="https://www.python.org/">Python</a> »</li> | |
| <li class="switchers"> | |
| <div class="language_switcher_placeholder"></div> | |
| <div class="version_switcher_placeholder"></div> | |
| </li> | |
| <li> | |
| </li> | |
| <li id="cpython-language-and-version"> | |
| <a href="../index.html">3.15.0a6 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="language.html" >Python Language Services</a> »</li> | |
| <li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract syntax trees</a></li> | |
| <li class="right"> | |
| <div class="inline-search" role="search"> | |
| <form class="inline-search" action="../search.html" method="get"> | |
| <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box"> | |
| <input type="submit" value="Go"> | |
| </form> | |
| </div> | |
| | | |
| </li> | |
| <li class="right"> | |
| <label class="theme-selector-label"> | |
| Theme | |
| <select class="theme-selector" oninput="activateTheme(this.value)"> | |
| <option value="auto" selected>Auto</option> | |
| <option value="light">Light</option> | |
| <option value="dark">Dark</option> | |
| </select> | |
| </label> |</li> | |
| </ul> | |
| </div> | |
| <div class="footer"> | |
| © <a href="../copyright.html">Copyright</a> 2001 Python Software Foundation. | |
| <br> | |
| This page is licensed under the Python Software Foundation License Version 2. | |
| <br> | |
| Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License. | |
| <br> | |
| See <a href="/license.html">History and License</a> for more information.<br> | |
| <br> | |
| The Python Software Foundation is a non-profit corporation. | |
| <a href="https://www.python.org/psf/donations/">Please donate.</a> | |
| <br> | |
| <br> | |
| Last updated on Mar 10, 2026 (08:58 UTC). | |
| <a href="/bugs.html">Found a bug</a>? | |
| <br> | |
| Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 8.2.3. | |
| </div> | |
| </body> | |
| </html> |