Team Ai
Apppublic

parthtamu/rag-code-assistant

sourceHugging Faceupdated 7mo agoView on Hugging Face
0likes
ast.html3308 linesDownload Raw Back to docs
1<!DOCTYPE html>2 3<html lang="en" data-content_root="../">4  <head>5    <meta charset="utf-8" />6    <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />7<meta property="og:title" content="ast — Abstract syntax trees" />8<meta property="og:type" content="website" />9<meta property="og:url" content="https://docs.python.org/3/library/ast.html" />10<meta property="og:site_name" content="Python documentation" />11<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..." />12<meta property="og:image:width" content="1146" />13<meta property="og:image:height" content="600" />14<meta property="og:image" content="https://docs.python.org/3.15/_images/social_previews/summary_library_ast_6f4ec67a.png" />15<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..." />16<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..." />17<meta name="twitter:card" content="summary_large_image" />18<meta name="theme-color" content="#3776ab">19 20    <title>ast — Abstract syntax trees &#8212; Python 3.15.0a6 documentation</title><meta name="viewport" content="width=device-width, initial-scale=1.0">21    22    <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=b86133f3" />23    <link rel="stylesheet" type="text/css" href="../_static/classic.css?v=234b1a7c" />24    <link rel="stylesheet" type="text/css" href="../_static/pydoctheme.css?v=89a2f22a" />25    <link rel="stylesheet" type="text/css" href="../_static/profiling-sampling-visualization.css?v=0c2600ae" />26    <link id="pygments_dark_css" media="(prefers-color-scheme: dark)" rel="stylesheet" type="text/css" href="../_static/pygments_dark.css?v=5349f25f" />27    28    <script src="../_static/documentation_options.js?v=6b7c9ff5"></script>29    <script src="../_static/doctools.js?v=9bcbadda"></script>30    <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>31    <script src="../_static/profiling-sampling-visualization.js?v=9811ed04"></script>32    33    <script src="../_static/sidebar.js"></script>34    35    <link rel="search" type="application/opensearchdescription+xml"36          title="Search within Python 3.15.0a6 documentation"37          href="../_static/opensearch.xml"/>38    <link rel="author" title="About these documents" href="../about.html" />39    <link rel="index" title="Index" href="../genindex.html" />40    <link rel="search" title="Search" href="../search.html" />41    <link rel="copyright" title="Copyright" href="../copyright.html" />42    <link rel="next" title="symtable — Access to the compiler’s symbol tables" href="symtable.html" />43    <link rel="prev" title="Python Language Services" href="language.html" />44    45      46      <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>47      48      <link rel="canonical" href="https://docs.python.org/3/library/ast.html">49      50    51 52    53    <style>54      @media only screen {55        table.full-width-table {56            width: 100%;57        }58      }59    </style>60<link rel="stylesheet" href="../_static/pydoctheme_dark.css" media="(prefers-color-scheme: dark)" id="pydoctheme_dark_css">61    <link rel="shortcut icon" type="image/png" href="../_static/py.svg">62            <script type="text/javascript" src="../_static/copybutton.js"></script>63            <script type="text/javascript" src="../_static/menu.js"></script>64            <script type="text/javascript" src="../_static/search-focus.js"></script>65            <script type="text/javascript" src="../_static/themetoggle.js"></script> 66            <script type="text/javascript" src="../_static/rtd_switcher.js"></script>67            <meta name="readthedocs-addons-api-version" content="1">68 69  </head>70<body>71<div class="mobile-nav">72    <input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation"73           aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu">74    <nav class="nav-content" role="navigation">75        <label for="menuToggler" class="toggler__label">76            <span></span>77        </label>78        <span class="nav-items-wrapper">79            <a href="https://www.python.org/" class="nav-logo">80                <img src="../_static/py.svg" alt="Python logo">81            </a>82            <span class="version_switcher_placeholder"></span>83            <form role="search" class="search" action="../search.html" method="get">84                <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" class="search-icon">85                    <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>86                </svg>87                <input placeholder="Quick search" aria-label="Quick search" type="search" name="q">88                <input type="submit" value="Go">89            </form>90        </span>91    </nav>92    <div class="menu-wrapper">93        <nav class="menu" role="navigation" aria-label="main navigation">94            <div class="language_switcher_placeholder"></div>95            96<label class="theme-selector-label">97    Theme98    <select class="theme-selector" oninput="activateTheme(this.value)">99        <option value="auto" selected>Auto</option>100        <option value="light">Light</option>101        <option value="dark">Dark</option>102    </select>103</label>104  <div>105    <h3><a href="../contents.html">Table of Contents</a></h3>106    <ul>107<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>108<li><a class="reference internal" href="#abstract-grammar">Abstract grammar</a></li>109<li><a class="reference internal" href="#node-classes">Node classes</a><ul>110<li><a class="reference internal" href="#root-nodes">Root nodes</a></li>111<li><a class="reference internal" href="#literals">Literals</a></li>112<li><a class="reference internal" href="#variables">Variables</a></li>113<li><a class="reference internal" href="#expressions">Expressions</a><ul>114<li><a class="reference internal" href="#subscripting">Subscripting</a></li>115<li><a class="reference internal" href="#comprehensions">Comprehensions</a></li>116</ul>117</li>118<li><a class="reference internal" href="#statements">Statements</a><ul>119<li><a class="reference internal" href="#imports">Imports</a></li>120</ul>121</li>122<li><a class="reference internal" href="#control-flow">Control flow</a></li>123<li><a class="reference internal" href="#pattern-matching">Pattern matching</a></li>124<li><a class="reference internal" href="#type-annotations">Type annotations</a></li>125<li><a class="reference internal" href="#type-parameters">Type parameters</a></li>126<li><a class="reference internal" href="#function-and-class-definitions">Function and class definitions</a></li>127<li><a class="reference internal" href="#async-and-await">Async and await</a></li>128</ul>129</li>130<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>131<li><a class="reference internal" href="#compiler-flags">Compiler flags</a></li>132<li><a class="reference internal" href="#command-line-usage">Command-line usage</a></li>133</ul>134</li>135</ul>136 137  </div>138  <div>139    <h4>Previous topic</h4>140    <p class="topless"><a href="language.html"141                          title="previous chapter">Python Language Services</a></p>142  </div>143  <div>144    <h4>Next topic</h4>145    <p class="topless"><a href="symtable.html"146                          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>147  </div>148  <script>149    document.addEventListener('DOMContentLoaded', () => {150        const title = document.querySelector('meta[property="og:title"]').content;151        const elements = document.querySelectorAll('.improvepage');152        const pageurl = window.location.href.split('?')[0];153        elements.forEach(element => {154            const url = new URL(element.href.split('?')[0].replace("-nojs", ""));155            url.searchParams.set('pagetitle', title);156            url.searchParams.set('pageurl', pageurl);157            url.searchParams.set('pagesource', "library/ast.rst");158            element.href = url.toString();159        });160    });161  </script>162  <div role="note" aria-label="source link">163    <h3>This page</h3>164    <ul class="this-page-menu">165      <li><a href="../bugs.html">Report a bug</a></li>166      <li><a class="improvepage" href="../improve-page-nojs.html">Improve this page</a></li>167      <li>168        <a href="https://github.com/python/cpython/blob/main/Doc/library/ast.rst?plain=1"169            rel="nofollow">Show source170        </a>171      </li>172      173    </ul>174  </div>175        </nav>176    </div>177</div>178 179  180    <div class="related" role="navigation" aria-label="Related">181      <h3>Navigation</h3>182      <ul>183        <li class="right" style="margin-right: 10px">184          <a href="../genindex.html" title="General Index"185             accesskey="I">index</a></li>186        <li class="right" >187          <a href="../py-modindex.html" title="Python Module Index"188             >modules</a> |</li>189        <li class="right" >190          <a href="symtable.html" title="symtable — Access to the compiler’s symbol tables"191             accesskey="N">next</a> |</li>192        <li class="right" >193          <a href="language.html" title="Python Language Services"194             accesskey="P">previous</a> |</li>195 196          <li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"></li>197          <li><a href="https://www.python.org/">Python</a> &#187;</li>198          <li class="switchers">199            <div class="language_switcher_placeholder"></div>200            <div class="version_switcher_placeholder"></div>201          </li>202          <li>203              204          </li>205    <li id="cpython-language-and-version">206      <a href="../index.html">3.15.0a6 Documentation</a> &#187;207    </li>208 209          <li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> &#187;</li>210          <li class="nav-item nav-item-2"><a href="language.html" accesskey="U">Python Language Services</a> &#187;</li>211        <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>212                <li class="right">213                    214 215    <div class="inline-search" role="search">216        <form class="inline-search" action="../search.html" method="get">217          <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box">218          <input type="submit" value="Go">219        </form>220    </div>221                     |222                </li>223            <li class="right">224<label class="theme-selector-label">225    Theme226    <select class="theme-selector" oninput="activateTheme(this.value)">227        <option value="auto" selected>Auto</option>228        <option value="light">Light</option>229        <option value="dark">Dark</option>230    </select>231</label> |</li>232            233      </ul>234    </div>    235 236    <div class="document">237      <div class="documentwrapper">238        <div class="bodywrapper">239          <div class="body" role="main">240            241  <section id="module-ast">242<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>243<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>244<hr class="docutils" />245<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 Python246abstract syntax grammar.  The abstract syntax itself might change with each247Python release; this module helps to find out programmatically what the current248grammar looks like.</p>249<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> as250a 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>251helper provided in this module.  The result will be a tree of objects whose252classes 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 be253compiled 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>254<section id="abstract-grammar">255<span id="id1"></span><h2>Abstract grammar<a class="headerlink" href="#abstract-grammar" title="Link to this heading">¶</a></h2>256<p>The abstract grammar is currently defined as follows:</p>257<div class="highlight-asdl notranslate"><div class="highlight"><pre><span></span><span class="c c-Singleline">-- ASDL&#39;s 4 builtin types are:</span>258<span class="c c-Singleline">-- identifier, int, string, constant</span>259 260<span class="k">module</span> <span class="nt">Python</span>261<span class="p">{</span>262    <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>263        <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>264        <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>265        <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>266 267    <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>,268                       <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>,269                       <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>270          <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>,271                             <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>,272                             <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>273 274          <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>,275             <span class="bp">expr</span><span class="o">* </span><span class="n">bases</span>,276             <span class="bp">keyword</span><span class="o">* </span><span class="n">keywords</span>,277             <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>,278             <span class="bp">expr</span><span class="o">* </span><span class="n">decorator_list</span>,279             <span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span><span class="p">)</span>280          <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>281 282          <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>283          <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>284          <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>285          <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>286          <span class="c c-Singleline">-- &#39;simple&#39; indicates that we annotate simple name without parens</span>287          <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>288 289          <span class="c c-Singleline">-- use &#39;orelse&#39; because else is a keyword in target languages</span>290          <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>291          <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>292          <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>293          <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>294          <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>295          <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>296 297          <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>298 299          <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>300          <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>301          <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>302          <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>303 304          <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>305          <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>306 307          <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>308          <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>309          <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>310          <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>311 312          <span class="c c-Singleline">-- col_offset is the byte offset in the utf8 string the parser uses</span>313          <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>314 315          <span class="c c-Singleline">-- BoolOp() can use left &amp; right?</span>316    <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>317         <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>318         <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>319         <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>320         <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>321         <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>322         <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>323         <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>324         <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>325         <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>326         <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>327         <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>328         <span class="c c-Singleline">-- the grammar constrains where yield expressions can occur</span>329         <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>330         <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>331         <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>332         <span class="c c-Singleline">-- need sequences for compare to distinguish between</span>333         <span class="c c-Singleline">-- x &lt; 4 &lt; 3 and (x &lt; 4) &lt; 3</span>334         <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>335         <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>336         <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>337         <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>338         <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>339         <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>340         <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>341 342         <span class="c c-Singleline">-- the following expression can appear in assignment context</span>343         <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>344         <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>345         <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>346         <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>347         <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>348         <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>349 350         <span class="c c-Singleline">-- can appear only in Subscript</span>351         <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>352 353          <span class="c c-Singleline">-- col_offset is the byte offset in the utf8 string the parser uses</span>354          <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>355 356    <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>357 358    <span class="n">boolop</span> <span class="o">=</span> <span class="nc">And</span> <span class="o">|</span> <span class="nc">Or</span>359 360    <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>361                 <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>362 363    <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>364 365    <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>366 367    <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>368 369    <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>370                    <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>371 372    <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>,373                 <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>374 375    <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>376           <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>377 378    <span class="c c-Singleline">-- keyword arguments supplied to call (NULL identifier for **kwargs)</span>379    <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>380               <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>381 382    <span class="c c-Singleline">-- import name with optional &#39;as&#39; alias.</span>383    <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>384             <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>385 386    <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>387 388    <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>389 390    <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>391            <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>392            <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>393            <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>394            <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>395 396            <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>397            <span class="c c-Singleline">-- The optional &quot;rest&quot; MatchMapping parameter handles capturing extra mapping keys</span>398 399            <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>400            <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>401 402             <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>403 404    <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>405 406    <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>407               <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>408               <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>409               <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>410<span class="p">}</span>411</pre></div>412</div>413</section>414<section id="node-classes">415<h2>Node classes<a class="headerlink" href="#node-classes" title="Link to this heading">¶</a></h2>416<dl class="py class">417<dt class="sig sig-object py" id="ast.AST">418<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>419<dd><p>This is the base of all AST node classes.  The actual node classes are420derived from the <code class="file docutils literal notranslate"><span class="pre">Parser/Python.asdl</span></code> file, which is reproduced421<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> C422module and re-exported in <code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code>.</p>423<p>There is one class defined for each left-hand side symbol in the abstract424grammar (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,425there is one class defined for each constructor on the right-hand side; these426classes inherit from the classes for the left-hand side trees.  For example,427<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 rules428with alternatives (aka “sums”), the left-hand side class is abstract: only429instances of specific constructor nodes are ever created.</p>430<dl class="py attribute" id="index-1">431<span id="index-0"></span><dt class="sig sig-object py" id="ast.AST._fields">432<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>433<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 names434of all child nodes.</p>435<p>Each instance of a concrete class has one attribute for each child node,436of 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>437instances 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>438<p>If these attributes are marked as optional in the grammar (using a439question mark), the value might be <code class="docutils literal notranslate"><span class="pre">None</span></code>.  If the attributes can have440zero-or-more values (marked with an asterisk), the values are represented441as Python lists.  All possible attributes must be present and have valid442values 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>443</dd></dl>444 445<dl class="py attribute">446<dt class="sig sig-object py" id="ast.AST._field_types">447<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>448<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 dictionary449mapping 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>450<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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>451<span class="go">{&#39;name&#39;: &lt;class &#39;str&#39;&gt;, &#39;bound&#39;: ast.expr | None, &#39;default_value&#39;: ast.expr | None}</span>452</pre></div>453</div>454<div class="versionadded">455<p><span class="versionmodified added">Added in version 3.13.</span></p>456</div>457</dd></dl>458 459<dl class="py attribute">460<dt class="sig sig-object py" id="ast.AST.lineno">461<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>462<dt class="sig sig-object py" id="ast.AST.col_offset">463<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>464<dt class="sig sig-object py" id="ast.AST.end_lineno">465<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>466<dt class="sig sig-object py" id="ast.AST.end_col_offset">467<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>468<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 have469<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>, and470<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>471are the first and last line numbers of source text span (1-indexed so the472first 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>473are the corresponding UTF-8 byte offsets of the first and last tokens that474generated the node. The UTF-8 offset is recorded because the parser uses475UTF-8 internally.</p>476<p>Note that the end positions are not required by the compiler and are477therefore optional. The end offset is <em>after</em> the last symbol, for example478one can get the source segment of a one-line expression node using479<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>480</dd></dl>481 482<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>483<ul class="simple">484<li><p>If there are positional arguments, there must be as many as there are items485in <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>486<li><p>If there are keyword arguments, they will set the attributes of the same487names to the given values.</p></li>488</ul>489<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 could490use</p>491<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>492                   <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>493</pre></div>494</div>495<p>If a field that is optional in the grammar is omitted from the constructor,496it defaults to <code class="docutils literal notranslate"><span class="pre">None</span></code>. If a list field is omitted, it defaults to the empty497list. 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 to498<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 raised499and the AST node will not have this field. In Python 3.15, this condition will500raise an error.</p>501</dd></dl>502 503<div class="versionchanged">504<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>505</div>506<div class="versionchanged">507<p><span class="versionmodified changed">Changed in version 3.9: </span>Simple indices are represented by their value, extended slices are508represented as tuples.</p>509</div>510<div class="versionchanged">511<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 includes512the values of the node fields.</p>513</div>514<div class="deprecated-removed">515<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>,516<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> and517<code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Ellipsis</span></code>, which were deprecated in Python 3.8. These classes518were removed in Python 3.14, and their functionality has been replaced with519<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>520</div>521<div class="deprecated">522<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 still523available, but they will be removed in future Python releases.524In the meantime, instantiating them will return an instance of525a different class.</p>526</div>527<div class="deprecated-removed">528<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 missing529required fields. Similarly, AST node constructors allowed arbitrary keyword530arguments that were set as attributes of the AST node, even if they did not531match any of the fields of the AST node. This behavior is deprecated and will532be removed in Python 3.15.</p>533</div>534<div class="admonition note">535<p class="admonition-title">Note</p>536<p>The descriptions of the specific node classes displayed here537were initially adapted from the fantastic <a class="reference external" href="https://greentreesnakes.readthedocs.io/en/latest/">Green Tree538Snakes</a> project and539all its contributors.</p>540</div>541<section id="root-nodes">542<span id="ast-root-nodes"></span><h3>Root nodes<a class="headerlink" href="#root-nodes" title="Link to this heading">¶</a></h3>543<dl class="py class">544<dt class="sig sig-object py" id="ast.Module">545<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>546<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>.547Node 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">&quot;exec&quot;</span></code> <em>mode</em>.</p>548<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>549<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;550see <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>551<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;x = 1&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>552<span class="go">Module(</span>553<span class="go">    body=[</span>554<span class="go">        Assign(</span>555<span class="go">            targets=[</span>556<span class="go">                Name(id=&#39;x&#39;, ctx=Store())],</span>557<span class="go">            value=Constant(value=1))])</span>558</pre></div>559</div>560</dd></dl>561 562<dl class="py class">563<dt class="sig sig-object py" id="ast.Expression">564<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>565<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>.566Node 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">&quot;eval&quot;</span></code>.</p>567<p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a single node,568one of the <a class="reference internal" href="#ast-expressions"><span class="std std-ref">expression types</span></a>.</p>569<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;123&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>570<span class="go">Expression(</span>571<span class="go">    body=Constant(value=123))</span>572</pre></div>573</div>574</dd></dl>575 576<dl class="py class">577<dt class="sig sig-object py" id="ast.Interactive">578<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>579<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>.580Node 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">&quot;single&quot;</span></code>.</p>581<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>582<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;x = 1; y = 2&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;single&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>583<span class="go">Interactive(</span>584<span class="go">    body=[</span>585<span class="go">        Assign(</span>586<span class="go">            targets=[</span>587<span class="go">                Name(id=&#39;x&#39;, ctx=Store())],</span>588<span class="go">            value=Constant(value=1)),</span>589<span class="go">        Assign(</span>590<span class="go">            targets=[</span>591<span class="go">                Name(id=&#39;y&#39;, ctx=Store())],</span>592<span class="go">            value=Constant(value=2))])</span>593</pre></div>594</div>595</dd></dl>596 597<dl class="py class">598<dt class="sig sig-object py" id="ast.FunctionType">599<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>600<dd><p>A representation of an old-style type comments for functions,601as 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.602Node 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">&quot;func_type&quot;</span></code>.</p>603<p>Such type comments would look like this:</p>604<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>605    <span class="c1"># type: (int, int) -&gt; int</span>606    <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span>607</pre></div>608</div>609<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>610<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>611<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;(int, str) -&gt; List[int]&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;func_type&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>612<span class="go">FunctionType(</span>613<span class="go">    argtypes=[</span>614<span class="go">        Name(id=&#39;int&#39;),</span>615<span class="go">        Name(id=&#39;str&#39;)],</span>616<span class="go">    returns=Subscript(</span>617<span class="go">        value=Name(id=&#39;List&#39;),</span>618<span class="go">        slice=Name(id=&#39;int&#39;)))</span>619</pre></div>620</div>621<div class="versionadded">622<p><span class="versionmodified added">Added in version 3.8.</span></p>623</div>624</dd></dl>625 626</section>627<section id="literals">628<h3>Literals<a class="headerlink" href="#literals" title="Link to this heading">¶</a></h3>629<dl class="py class">630<dt class="sig sig-object py" id="ast.Constant">631<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>632<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 the633Python 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>,634<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>,635and 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>636<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;123&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>637<span class="go">Expression(</span>638<span class="go">    body=Constant(value=123))</span>639</pre></div>640</div>641</dd></dl>642 643<dl class="py class">644<dt class="sig sig-object py" id="ast.FormattedValue">645<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>646<dd><p>Node representing a single formatting field in an f-string. If the string647contains a single formatting field and nothing else the node can be648isolated 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>649<ul class="simple">650<li><p><code class="docutils literal notranslate"><span class="pre">value</span></code> is any expression node (such as a literal, a variable, or a651function call).</p></li>652<li><p><code class="docutils literal notranslate"><span class="pre">conversion</span></code> is an integer:</p>653<ul>654<li><p>-1: no formatting</p></li>655<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>656<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>657<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>658</ul>659</li>660<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 formatting661of the value, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if no format was specified. Both662<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>663</ul>664</dd></dl>665 666<dl class="py class">667<dt class="sig sig-object py" id="ast.JoinedStr">668<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>669<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>670nodes.</p>671<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;f&quot;sin(</span><span class="si">{a}</span><span class="s1">) is {sin(a):.3}&quot;&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>672<span class="go">Expression(</span>673<span class="go">    body=JoinedStr(</span>674<span class="go">        values=[</span>675<span class="go">            Constant(value=&#39;sin(&#39;),</span>676<span class="go">            FormattedValue(</span>677<span class="go">                value=Name(id=&#39;a&#39;),</span>678<span class="go">                conversion=-1),</span>679<span class="go">            Constant(value=&#39;) is &#39;),</span>680<span class="go">            FormattedValue(</span>681<span class="go">                value=Call(</span>682<span class="go">                    func=Name(id=&#39;sin&#39;),</span>683<span class="go">                    args=[</span>684<span class="go">                        Name(id=&#39;a&#39;)]),</span>685<span class="go">                conversion=-1,</span>686<span class="go">                format_spec=JoinedStr(</span>687<span class="go">                    values=[</span>688<span class="go">                        Constant(value=&#39;.3&#39;)]))]))</span>689</pre></div>690</div>691</dd></dl>692 693<dl class="py class">694<dt class="sig sig-object py" id="ast.TemplateStr">695<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>696<dd><div class="versionadded">697<p><span class="versionmodified added">Added in version 3.14.</span></p>698</div>699<p>Node representing a template string literal, comprising a series of700<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.701These nodes may be any order, and do not need to be interleaved.</p>702<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;t&quot;</span><span class="si">{name}</span><span class="s1"> finished {place:ordinal}&quot;&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">)</span>703<span class="gp">&gt;&gt;&gt; </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>704<span class="go">Expression(</span>705<span class="go">    body=TemplateStr(</span>706<span class="go">        values=[</span>707<span class="go">            Interpolation(</span>708<span class="go">                value=Name(id=&#39;name&#39;),</span>709<span class="go">                str=&#39;name&#39;,</span>710<span class="go">                conversion=-1),</span>711<span class="go">            Constant(value=&#39; finished &#39;),</span>712<span class="go">            Interpolation(</span>713<span class="go">                value=Name(id=&#39;place&#39;),</span>714<span class="go">                str=&#39;place&#39;,</span>715<span class="go">                conversion=-1,</span>716<span class="go">                format_spec=JoinedStr(</span>717<span class="go">                    values=[</span>718<span class="go">                        Constant(value=&#39;ordinal&#39;)]))]))</span>719</pre></div>720</div>721</dd></dl>722 723<dl class="py class">724<dt class="sig sig-object py" id="ast.Interpolation">725<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>726<dd><div class="versionadded">727<p><span class="versionmodified added">Added in version 3.14.</span></p>728</div>729<p>Node representing a single interpolation field in a template string literal.</p>730<ul>731<li><p><code class="docutils literal notranslate"><span class="pre">value</span></code> is any expression node (such as a literal, a variable, or a732function call).733This has the same meaning as <code class="docutils literal notranslate"><span class="pre">FormattedValue.value</span></code>.</p></li>734<li><p><code class="docutils literal notranslate"><span class="pre">str</span></code> is a constant containing the text of the interpolation expression.</p>735<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 code736when 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 the737generated code is identical to the original and is intended for code738generation.</p>739</li>740<li><p><code class="docutils literal notranslate"><span class="pre">conversion</span></code> is an integer:</p>741<ul class="simple">742<li><p>-1: no conversion</p></li>743<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>744<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>745<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>746</ul>747<p>This has the same meaning as <code class="docutils literal notranslate"><span class="pre">FormattedValue.conversion</span></code>.</p>748</li>749<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 formatting750of the value, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if no format was specified. Both751<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.752This has the same meaning as <code class="docutils literal notranslate"><span class="pre">FormattedValue.format_spec</span></code>.</p></li>753</ul>754</dd></dl>755 756<dl class="py class">757<dt class="sig sig-object py" id="ast.List">758<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>759<dt class="sig sig-object py" id="ast.Tuple">760<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>761<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.762<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.763<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>764<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;[1, 2, 3]&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>765<span class="go">Expression(</span>766<span class="go">    body=List(</span>767<span class="go">        elts=[</span>768<span class="go">            Constant(value=1),</span>769<span class="go">            Constant(value=2),</span>770<span class="go">            Constant(value=3)]))</span>771<span class="gp">&gt;&gt;&gt; </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">&#39;(1, 2, 3)&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>772<span class="go">Expression(</span>773<span class="go">    body=Tuple(</span>774<span class="go">        elts=[</span>775<span class="go">            Constant(value=1),</span>776<span class="go">            Constant(value=2),</span>777<span class="go">            Constant(value=3)]))</span>778</pre></div>779</div>780</dd></dl>781 782<dl class="py class">783<dt class="sig sig-object py" id="ast.Set">784<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>785<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>786<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;{1, 2, 3}&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>787<span class="go">Expression(</span>788<span class="go">    body=Set(</span>789<span class="go">        elts=[</span>790<span class="go">            Constant(value=1),</span>791<span class="go">            Constant(value=2),</span>792<span class="go">            Constant(value=3)]))</span>793</pre></div>794</div>795</dd></dl>796 797<dl class="py class">798<dt class="sig sig-object py" id="ast.Dict">799<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>800<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 the801keys and the values respectively, in matching order (what would be returned802when 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>803<p>When doing dictionary unpacking using dictionary literals the expression to be804expanded 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 corresponding805position in <code class="docutils literal notranslate"><span class="pre">keys</span></code>.</p>806<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;{&quot;a&quot;:1, **d}&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>807<span class="go">Expression(</span>808<span class="go">    body=Dict(</span>809<span class="go">        keys=[</span>810<span class="go">            Constant(value=&#39;a&#39;),</span>811<span class="go">            None],</span>812<span class="go">        values=[</span>813<span class="go">            Constant(value=1),</span>814<span class="go">            Name(id=&#39;d&#39;)]))</span>815</pre></div>816</div>817</dd></dl>818 819</section>820<section id="variables">821<h3>Variables<a class="headerlink" href="#variables" title="Link to this heading">¶</a></h3>822<dl class="py class">823<dt class="sig sig-object py" id="ast.Name">824<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>825<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 of826the following types.</p>827</dd></dl>828 829<dl class="py class">830<dt class="sig sig-object py" id="ast.Load">831<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>832<dt class="sig sig-object py" id="ast.Store">833<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>834<dt class="sig sig-object py" id="ast.Del">835<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>836<dd><p>Variable references can be used to load the value of a variable, to assign837a new value to it, or to delete it. Variable references are given a context838to distinguish these cases.</p>839<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;a&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>840<span class="go">Module(</span>841<span class="go">    body=[</span>842<span class="go">        Expr(</span>843<span class="go">            value=Name(id=&#39;a&#39;))])</span>844 845<span class="gp">&gt;&gt;&gt; </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">&#39;a = 1&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>846<span class="go">Module(</span>847<span class="go">    body=[</span>848<span class="go">        Assign(</span>849<span class="go">            targets=[</span>850<span class="go">                Name(id=&#39;a&#39;, ctx=Store())],</span>851<span class="go">            value=Constant(value=1))])</span>852 853<span class="gp">&gt;&gt;&gt; </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">&#39;del a&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>854<span class="go">Module(</span>855<span class="go">    body=[</span>856<span class="go">        Delete(</span>857<span class="go">            targets=[</span>858<span class="go">                Name(id=&#39;a&#39;, ctx=Del())])])</span>859</pre></div>860</div>861</dd></dl>862 863<dl class="py class">864<dt class="sig sig-object py" id="ast.Starred">865<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>866<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 a867<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>868node with <code class="docutils literal notranslate"><span class="pre">*args</span></code>.</p>869<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;a, *b = it&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>870<span class="go">Module(</span>871<span class="go">    body=[</span>872<span class="go">        Assign(</span>873<span class="go">            targets=[</span>874<span class="go">                Tuple(</span>875<span class="go">                    elts=[</span>876<span class="go">                        Name(id=&#39;a&#39;, ctx=Store()),</span>877<span class="go">                        Starred(</span>878<span class="go">                            value=Name(id=&#39;b&#39;, ctx=Store()),</span>879<span class="go">                            ctx=Store())],</span>880<span class="go">                    ctx=Store())],</span>881<span class="go">            value=Name(id=&#39;it&#39;))])</span>882</pre></div>883</div>884</dd></dl>885 886</section>887<section id="expressions">888<span id="ast-expressions"></span><h3>Expressions<a class="headerlink" href="#expressions" title="Link to this heading">¶</a></h3>889<dl class="py class">890<dt class="sig sig-object py" id="ast.Expr">891<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>892<dd><p>When an expression, such as a function call, appears as a statement by itself893with its return value not used or stored, it is wrapped in this container.894<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>, a895<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>896<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;-a&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>897<span class="go">Module(</span>898<span class="go">    body=[</span>899<span class="go">        Expr(</span>900<span class="go">            value=UnaryOp(</span>901<span class="go">                op=USub(),</span>902<span class="go">                operand=Name(id=&#39;a&#39;)))])</span>903</pre></div>904</div>905</dd></dl>906 907<dl class="py class">908<dt class="sig sig-object py" id="ast.UnaryOp">909<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>910<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 expression911node.</p>912</dd></dl>913 914<dl class="py class">915<dt class="sig sig-object py" id="ast.UAdd">916<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>917<dt class="sig sig-object py" id="ast.USub">918<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>919<dt class="sig sig-object py" id="ast.Not">920<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>921<dt class="sig sig-object py" id="ast.Invert">922<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>923<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>924is the <code class="docutils literal notranslate"><span class="pre">~</span></code> operator.</p>925<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;not x&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>926<span class="go">Expression(</span>927<span class="go">    body=UnaryOp(</span>928<span class="go">        op=Not(),</span>929<span class="go">        operand=Name(id=&#39;x&#39;)))</span>930</pre></div>931</div>932</dd></dl>933 934<dl class="py class">935<dt class="sig sig-object py" id="ast.BinOp">936<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>937<dd><p>A binary operation (like addition or division). <code class="docutils literal notranslate"><span class="pre">op</span></code> is the operator, and938<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>939<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;x + y&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>940<span class="go">Expression(</span>941<span class="go">    body=BinOp(</span>942<span class="go">        left=Name(id=&#39;x&#39;),</span>943<span class="go">        op=Add(),</span>944<span class="go">        right=Name(id=&#39;y&#39;)))</span>945</pre></div>946</div>947</dd></dl>948 949<dl class="py class">950<dt class="sig sig-object py" id="ast.Add">951<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>952<dt class="sig sig-object py" id="ast.Sub">953<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>954<dt class="sig sig-object py" id="ast.Mult">955<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>956<dt class="sig sig-object py" id="ast.Div">957<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>958<dt class="sig sig-object py" id="ast.FloorDiv">959<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>960<dt class="sig sig-object py" id="ast.Mod">961<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>962<dt class="sig sig-object py" id="ast.Pow">963<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>964<dt class="sig sig-object py" id="ast.LShift">965<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>966<dt class="sig sig-object py" id="ast.RShift">967<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>968<dt class="sig sig-object py" id="ast.BitOr">969<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>970<dt class="sig sig-object py" id="ast.BitXor">971<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>972<dt class="sig sig-object py" id="ast.BitAnd">973<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>974<dt class="sig sig-object py" id="ast.MatMult">975<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>976<dd><p>Binary operator tokens.</p>977</dd></dl>978 979<dl class="py class">980<dt class="sig sig-object py" id="ast.BoolOp">981<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>982<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>.983<code class="docutils literal notranslate"><span class="pre">values</span></code> are the values involved. Consecutive operations with the same984operator, 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 several985values.</p>986<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>987<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;x or y&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>988<span class="go">Expression(</span>989<span class="go">    body=BoolOp(</span>990<span class="go">        op=Or(),</span>991<span class="go">        values=[</span>992<span class="go">            Name(id=&#39;x&#39;),</span>993<span class="go">            Name(id=&#39;y&#39;)]))</span>994</pre></div>995</div>996</dd></dl>997 998<dl class="py class">999<dt class="sig sig-object py" id="ast.And">1000<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>1001<dt class="sig sig-object py" id="ast.Or">1002<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>1003<dd><p>Boolean operator tokens.</p>1004</dd></dl>1005 1006<dl class="py class">1007<dt class="sig sig-object py" id="ast.Compare">1008<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>1009<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 the1010comparison, <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 list1011of values after the first element in the comparison.</p>1012<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;1 &lt;= a &lt; 10&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>1013<span class="go">Expression(</span>1014<span class="go">    body=Compare(</span>1015<span class="go">        left=Constant(value=1),</span>1016<span class="go">        ops=[</span>1017<span class="go">            LtE(),</span>1018<span class="go">            Lt()],</span>1019<span class="go">        comparators=[</span>1020<span class="go">            Name(id=&#39;a&#39;),</span>1021<span class="go">            Constant(value=10)]))</span>1022</pre></div>1023</div>1024</dd></dl>1025 1026<dl class="py class">1027<dt class="sig sig-object py" id="ast.Eq">1028<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>1029<dt class="sig sig-object py" id="ast.NotEq">1030<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>1031<dt class="sig sig-object py" id="ast.Lt">1032<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>1033<dt class="sig sig-object py" id="ast.LtE">1034<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>1035<dt class="sig sig-object py" id="ast.Gt">1036<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>1037<dt class="sig sig-object py" id="ast.GtE">1038<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>1039<dt class="sig sig-object py" id="ast.Is">1040<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>1041<dt class="sig sig-object py" id="ast.IsNot">1042<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>1043<dt class="sig sig-object py" id="ast.In">1044<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>1045<dt class="sig sig-object py" id="ast.NotIn">1046<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>1047<dd><p>Comparison operator tokens.</p>1048</dd></dl>1049 1050<dl class="py class">1051<dt class="sig sig-object py" id="ast.Call">1052<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>1053<dd><p>A function call. <code class="docutils literal notranslate"><span class="pre">func</span></code> is the function, which will often be a1054<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>1055<ul class="simple">1056<li><p><code class="docutils literal notranslate"><span class="pre">args</span></code> holds a list of the arguments passed by position.</p></li>1057<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 representing1058arguments passed by keyword.</p></li>1059</ul>1060<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>1061<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;func(a, b=c, *d, **e)&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>1062<span class="go">Expression(</span>1063<span class="go">    body=Call(</span>1064<span class="go">        func=Name(id=&#39;func&#39;),</span>1065<span class="go">        args=[</span>1066<span class="go">            Name(id=&#39;a&#39;),</span>1067<span class="go">            Starred(</span>1068<span class="go">                value=Name(id=&#39;d&#39;))],</span>1069<span class="go">        keywords=[</span>1070<span class="go">            keyword(</span>1071<span class="go">                arg=&#39;b&#39;,</span>1072<span class="go">                value=Name(id=&#39;c&#39;)),</span>1073<span class="go">            keyword(</span>1074<span class="go">                value=Name(id=&#39;e&#39;))]))</span>1075</pre></div>1076</div>1077</dd></dl>1078 1079<dl class="py class">1080<dt class="sig sig-object py" id="ast.keyword">1081<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>1082<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 raw1083string of the parameter name, <code class="docutils literal notranslate"><span class="pre">value</span></code> is a node to pass in.</p>1084</dd></dl>1085 1086<dl class="py class">1087<dt class="sig sig-object py" id="ast.IfExp">1088<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>1089<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, so1090in 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>1091<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;a if b else c&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>1092<span class="go">Expression(</span>1093<span class="go">    body=IfExp(</span>1094<span class="go">        test=Name(id=&#39;b&#39;),</span>1095<span class="go">        body=Name(id=&#39;a&#39;),</span>1096<span class="go">        orelse=Name(id=&#39;c&#39;)))</span>1097</pre></div>1098</div>1099</dd></dl>1100 1101<dl class="py class">1102<dt class="sig sig-object py" id="ast.Attribute">1103<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>1104<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 a1105<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,1106and <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 how1107the attribute is acted on.</p>1108<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;snake.colour&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>1109<span class="go">Expression(</span>1110<span class="go">    body=Attribute(</span>1111<span class="go">        value=Name(id=&#39;snake&#39;),</span>1112<span class="go">        attr=&#39;colour&#39;))</span>1113</pre></div>1114</div>1115</dd></dl>1116 1117<dl class="py class">1118<dt class="sig sig-object py" id="ast.NamedExpr">1119<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>1120<dd><p>A named expression. This AST node is produced by the assignment expressions1121operator (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>1122node in which the first argument can be multiple nodes, in this case both1123<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>1124<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;(x := 4)&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>1125<span class="go">Expression(</span>1126<span class="go">    body=NamedExpr(</span>1127<span class="go">        target=Name(id=&#39;x&#39;, ctx=Store()),</span>1128<span class="go">        value=Constant(value=4)))</span>1129</pre></div>1130</div>1131<div class="versionadded">1132<p><span class="versionmodified added">Added in version 3.8.</span></p>1133</div>1134</dd></dl>1135 1136<section id="subscripting">1137<h4>Subscripting<a class="headerlink" href="#subscripting" title="Link to this heading">¶</a></h4>1138<dl class="py class">1139<dt class="sig sig-object py" id="ast.Subscript">1140<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>1141<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 object1142(usually sequence or mapping). <code class="docutils literal notranslate"><span class="pre">slice</span></code> is an index, slice or key.1143It 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>.1144<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>1145according to the action performed with the subscript.</p>1146<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;l[1:2, 3]&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>1147<span class="go">Expression(</span>1148<span class="go">    body=Subscript(</span>1149<span class="go">        value=Name(id=&#39;l&#39;),</span>1150<span class="go">        slice=Tuple(</span>1151<span class="go">            elts=[</span>1152<span class="go">                Slice(</span>1153<span class="go">                    lower=Constant(value=1),</span>1154<span class="go">                    upper=Constant(value=2)),</span>1155<span class="go">                Constant(value=3)])))</span>1156</pre></div>1157</div>1158</dd></dl>1159 1160<dl class="py class">1161<dt class="sig sig-object py" id="ast.Slice">1162<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>1163<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>).1164Can 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>, either1165directly 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>1166<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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">&#39;l[1:2]&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>1167<span class="go">Expression(</span>1168<span class="go">    body=Subscript(</span>1169<span class="go">        value=Name(id=&#39;l&#39;),</span>1170<span class="go">        slice=Slice(</span>1171<span class="go">            lower=Constant(value=1),</span>1172<span class="go">            upper=Constant(value=2))))</span>1173</pre></div>1174</div>1175</dd></dl>1176 1177</section>1178<section id="comprehensions">1179<h4>Comprehensions<a class="headerlink" href="#comprehensions" title="Link to this heading">¶</a></h4>1180<dl class="py class">1181<dt class="sig sig-object py" id="ast.ListComp">1182<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>1183<dt class="sig sig-object py" id="ast.SetComp">1184<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>1185<dt class="sig sig-object py" id="ast.GeneratorExp">1186<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>1187<dt class="sig sig-object py" id="ast.DictComp">1188<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>1189<dd><p>List and set comprehensions, generator expressions, and dictionary1190comprehensions. <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 node1191representing the part that will be evaluated for each item.</p>1192<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>1193<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </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>1194<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">&#39;[x for x in numbers]&#39;</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;eval&#39;</span><span class="p">),</span>1195<span class="gp">... </span>    <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>1196<span class="gp">... </span><span class="p">))</span>1197<span class="go">Expression(</span>1198<span class="go">    body=ListComp(</span>1199<span class="go">        elt=Name(id=&#39;x&#39;),</span>1200<span class="go">        generators=[</span>

Showing the first 1,200 of 3308 lines. Download the file for the rest.