3136 lines
334 KiB
HTML
3136 lines
334 KiB
HTML
<!DOCTYPE html>
|
||
|
||
<html lang="en" data-content_root="../">
|
||
<head>
|
||
<meta charset="utf-8" />
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
|
||
<meta property="og:title" content="ast — Abstract Syntax Trees" />
|
||
<meta property="og:type" content="website" />
|
||
<meta property="og:url" content="https://docs.python.org/3/library/ast.html" />
|
||
<meta property="og:site_name" content="Python documentation" />
|
||
<meta property="og:description" content="Source code: Lib/ast.py The ast module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this modul..." />
|
||
<meta property="og:image" content="https://docs.python.org/3/_static/og-image.png" />
|
||
<meta property="og:image:alt" content="Python documentation" />
|
||
<meta name="description" content="Source code: Lib/ast.py The ast module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this modul..." />
|
||
<meta property="og:image:width" content="200">
|
||
<meta property="og:image:height" content="200">
|
||
<meta name="theme-color" content="#3776ab">
|
||
|
||
<title>ast — Abstract Syntax Trees — Python 3.13.3 documentation</title><meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||
|
||
<link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=b86133f3" />
|
||
<link rel="stylesheet" type="text/css" href="../_static/pydoctheme.css?v=23252803" />
|
||
<link id="pygments_dark_css" media="(prefers-color-scheme: dark)" rel="stylesheet" type="text/css" href="../_static/pygments_dark.css?v=5349f25f" />
|
||
|
||
<script src="../_static/documentation_options.js?v=5d57ca2d"></script>
|
||
<script src="../_static/doctools.js?v=9bcbadda"></script>
|
||
<script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
|
||
|
||
<script src="../_static/sidebar.js"></script>
|
||
|
||
<link rel="search" type="application/opensearchdescription+xml"
|
||
title="Search within Python 3.13.3 documentation"
|
||
href="../_static/opensearch.xml"/>
|
||
<link rel="author" title="About these documents" href="../about.html" />
|
||
<link rel="index" title="Index" href="../genindex.html" />
|
||
<link rel="search" title="Search" href="../search.html" />
|
||
<link rel="copyright" title="Copyright" href="../copyright.html" />
|
||
<link rel="next" title="symtable — Access to the compiler’s symbol tables" href="symtable.html" />
|
||
<link rel="prev" title="Python Language Services" href="language.html" />
|
||
|
||
<link rel="canonical" href="https://docs.python.org/3/library/ast.html">
|
||
|
||
|
||
|
||
|
||
|
||
<style>
|
||
@media only screen {
|
||
table.full-width-table {
|
||
width: 100%;
|
||
}
|
||
}
|
||
</style>
|
||
<link rel="stylesheet" href="../_static/pydoctheme_dark.css" media="(prefers-color-scheme: dark)" id="pydoctheme_dark_css">
|
||
<link rel="shortcut icon" type="image/png" href="../_static/py.svg" />
|
||
<script type="text/javascript" src="../_static/copybutton.js"></script>
|
||
<script type="text/javascript" src="../_static/menu.js"></script>
|
||
<script type="text/javascript" src="../_static/search-focus.js"></script>
|
||
<script type="text/javascript" src="../_static/themetoggle.js"></script>
|
||
<script type="text/javascript" src="../_static/rtd_switcher.js"></script>
|
||
<meta name="readthedocs-addons-api-version" content="1">
|
||
|
||
</head>
|
||
<body>
|
||
<div class="mobile-nav">
|
||
<input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation"
|
||
aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu" />
|
||
<nav class="nav-content" role="navigation">
|
||
<label for="menuToggler" class="toggler__label">
|
||
<span></span>
|
||
</label>
|
||
<span class="nav-items-wrapper">
|
||
<a href="https://www.python.org/" class="nav-logo">
|
||
<img src="../_static/py.svg" alt="Python logo"/>
|
||
</a>
|
||
<span class="version_switcher_placeholder"></span>
|
||
<form role="search" class="search" action="../search.html" method="get">
|
||
<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" class="search-icon">
|
||
<path fill-rule="nonzero" fill="currentColor" d="M15.5 14h-.79l-.28-.27a6.5 6.5 0 001.48-5.34c-.47-2.78-2.79-5-5.59-5.34a6.505 6.505 0 00-7.27 7.27c.34 2.8 2.56 5.12 5.34 5.59a6.5 6.5 0 005.34-1.48l.27.28v.79l4.25 4.25c.41.41 1.08.41 1.49 0 .41-.41.41-1.08 0-1.49L15.5 14zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path>
|
||
</svg>
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" />
|
||
<input type="submit" value="Go"/>
|
||
</form>
|
||
</span>
|
||
</nav>
|
||
<div class="menu-wrapper">
|
||
<nav class="menu" role="navigation" aria-label="main navigation">
|
||
<div class="language_switcher_placeholder"></div>
|
||
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label>
|
||
<div>
|
||
<h3><a href="../contents.html">Table of Contents</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract Syntax Trees</a><ul>
|
||
<li><a class="reference internal" href="#abstract-grammar">Abstract Grammar</a></li>
|
||
<li><a class="reference internal" href="#node-classes">Node classes</a><ul>
|
||
<li><a class="reference internal" href="#root-nodes">Root nodes</a></li>
|
||
<li><a class="reference internal" href="#literals">Literals</a></li>
|
||
<li><a class="reference internal" href="#variables">Variables</a></li>
|
||
<li><a class="reference internal" href="#expressions">Expressions</a><ul>
|
||
<li><a class="reference internal" href="#subscripting">Subscripting</a></li>
|
||
<li><a class="reference internal" href="#comprehensions">Comprehensions</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#statements">Statements</a><ul>
|
||
<li><a class="reference internal" href="#imports">Imports</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#control-flow">Control flow</a></li>
|
||
<li><a class="reference internal" href="#pattern-matching">Pattern matching</a></li>
|
||
<li><a class="reference internal" href="#type-parameters">Type parameters</a></li>
|
||
<li><a class="reference internal" href="#function-and-class-definitions">Function and class definitions</a></li>
|
||
<li><a class="reference internal" href="#async-and-await">Async and await</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#ast-helpers"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> Helpers</a></li>
|
||
<li><a class="reference internal" href="#compiler-flags">Compiler Flags</a></li>
|
||
<li><a class="reference internal" href="#command-line-usage">Command-Line Usage</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
|
||
</div>
|
||
<div>
|
||
<h4>Previous topic</h4>
|
||
<p class="topless"><a href="language.html"
|
||
title="previous chapter">Python Language Services</a></p>
|
||
</div>
|
||
<div>
|
||
<h4>Next topic</h4>
|
||
<p class="topless"><a href="symtable.html"
|
||
title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">symtable</span></code> — Access to the compiler’s symbol tables</a></p>
|
||
</div>
|
||
<div role="note" aria-label="source link">
|
||
<h3>This Page</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">Report a Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/main/Doc/library/ast.rst"
|
||
rel="nofollow">Show Source
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</nav>
|
||
</div>
|
||
</div>
|
||
|
||
|
||
<div class="related" role="navigation" aria-label="Related">
|
||
<h3>Navigation</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="General Index"
|
||
accesskey="I">index</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python Module Index"
|
||
>modules</a> |</li>
|
||
<li class="right" >
|
||
<a href="symtable.html" title="symtable — Access to the compiler’s symbol tables"
|
||
accesskey="N">next</a> |</li>
|
||
<li class="right" >
|
||
<a href="language.html" title="Python Language Services"
|
||
accesskey="P">previous</a> |</li>
|
||
|
||
<li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li class="switchers">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<div class="version_switcher_placeholder"></div>
|
||
</li>
|
||
<li>
|
||
|
||
</li>
|
||
<li id="cpython-language-and-version">
|
||
<a href="../index.html">3.13.3 Documentation</a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> »</li>
|
||
<li class="nav-item nav-item-2"><a href="language.html" accesskey="U">Python Language Services</a> »</li>
|
||
<li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract Syntax Trees</a></li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />
|
||
<input type="submit" value="Go" />
|
||
</form>
|
||
</div>
|
||
|
|
||
</li>
|
||
<li class="right">
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label> |</li>
|
||
|
||
</ul>
|
||
</div>
|
||
|
||
<div class="document">
|
||
<div class="documentwrapper">
|
||
<div class="bodywrapper">
|
||
<div class="body" role="main">
|
||
|
||
<section id="module-ast">
|
||
<span id="ast-abstract-syntax-trees"></span><h1><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract Syntax Trees<a class="headerlink" href="#module-ast" title="Link to this heading">¶</a></h1>
|
||
<p><strong>Source code:</strong> <a class="extlink-source reference external" href="https://github.com/python/cpython/tree/3.13/Lib/ast.py">Lib/ast.py</a></p>
|
||
<hr class="docutils" />
|
||
<p>The <a class="reference internal" href="#module-ast" title="ast: Abstract Syntax Tree classes and manipulation."><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code></a> module helps Python applications to process trees of the Python
|
||
abstract syntax grammar. The abstract syntax itself might change with each
|
||
Python release; this module helps to find out programmatically what the current
|
||
grammar looks like.</p>
|
||
<p>An abstract syntax tree can be generated by passing <a class="reference internal" href="#ast.PyCF_ONLY_AST" title="ast.PyCF_ONLY_AST"><code class="xref py py-data docutils literal notranslate"><span class="pre">ast.PyCF_ONLY_AST</span></code></a> as
|
||
a flag to the <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a> built-in function, or using the <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">parse()</span></code></a>
|
||
helper provided in this module. The result will be a tree of objects whose
|
||
classes all inherit from <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.AST</span></code></a>. An abstract syntax tree can be
|
||
compiled into a Python code object using the built-in <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> function.</p>
|
||
<section id="abstract-grammar">
|
||
<span id="id1"></span><h2>Abstract Grammar<a class="headerlink" href="#abstract-grammar" title="Link to this heading">¶</a></h2>
|
||
<p>The abstract grammar is currently defined as follows:</p>
|
||
<div class="highlight-asdl notranslate"><div class="highlight"><pre><span></span><span class="c c-Singleline">-- ASDL's 4 builtin types are:</span>
|
||
<span class="c c-Singleline">-- identifier, int, string, constant</span>
|
||
|
||
<span class="k">module</span> <span class="nt">Python</span>
|
||
<span class="p">{</span>
|
||
<span class="n">mod</span> <span class="o">=</span> <span class="nc">Module</span><span class="p">(</span><span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">type_ignore</span><span class="o">* </span><span class="n">type_ignores</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Interactive</span><span class="p">(</span><span class="bp">stmt</span><span class="o">* </span><span class="n">body</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Expression</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">body</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">FunctionType</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">argtypes</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">returns</span><span class="p">)</span>
|
||
|
||
<span class="n">stmt</span> <span class="o">=</span> <span class="nc">FunctionDef</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">arguments</span><span class="o"> </span><span class="n">args</span>,
|
||
<span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">decorator_list</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">returns</span>,
|
||
<span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span>, <span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">AsyncFunctionDef</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">arguments</span><span class="o"> </span><span class="n">args</span>,
|
||
<span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">decorator_list</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">returns</span>,
|
||
<span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span>, <span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span><span class="p">)</span>
|
||
|
||
<span class="o">|</span> <span class="nc">ClassDef</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>,
|
||
<span class="bp">expr</span><span class="o">* </span><span class="n">bases</span>,
|
||
<span class="bp">keyword</span><span class="o">* </span><span class="n">keywords</span>,
|
||
<span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>,
|
||
<span class="bp">expr</span><span class="o">* </span><span class="n">decorator_list</span>,
|
||
<span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Return</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">value</span><span class="p">)</span>
|
||
|
||
<span class="o">|</span> <span class="nc">Delete</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">targets</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Assign</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">targets</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">TypeAlias</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">name</span>, <span class="bp">type_param</span><span class="o">* </span><span class="n">type_params</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">AugAssign</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">operator</span><span class="o"> </span><span class="n">op</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="c c-Singleline">-- 'simple' indicates that we annotate simple name without parens</span>
|
||
<span class="o">|</span> <span class="nc">AnnAssign</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">annotation</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">value</span>, <span class="bp">int</span><span class="o"> </span><span class="n">simple</span><span class="p">)</span>
|
||
|
||
<span class="c c-Singleline">-- use 'orelse' because else is a keyword in target languages</span>
|
||
<span class="o">|</span> <span class="nc">For</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">iter</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">AsyncFor</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">iter</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">While</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">test</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">If</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">test</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">With</span><span class="p">(</span><span class="bp">withitem</span><span class="o">* </span><span class="n">items</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">AsyncWith</span><span class="p">(</span><span class="bp">withitem</span><span class="o">* </span><span class="n">items</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span>
|
||
|
||
<span class="o">|</span> <span class="nc">Match</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">subject</span>, <span class="bp">match_case</span><span class="o">* </span><span class="n">cases</span><span class="p">)</span>
|
||
|
||
<span class="o">|</span> <span class="nc">Raise</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">exc</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">cause</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Try</span><span class="p">(</span><span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">excepthandler</span><span class="o">* </span><span class="n">handlers</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">finalbody</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">TryStar</span><span class="p">(</span><span class="bp">stmt</span><span class="o">* </span><span class="n">body</span>, <span class="bp">excepthandler</span><span class="o">* </span><span class="n">handlers</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">orelse</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">finalbody</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Assert</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">test</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">msg</span><span class="p">)</span>
|
||
|
||
<span class="o">|</span> <span class="nc">Import</span><span class="p">(</span><span class="bp">alias</span><span class="o">* </span><span class="n">names</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">ImportFrom</span><span class="p">(</span><span class="bp">identifier</span><span class="o">? </span><span class="n">module</span>, <span class="bp">alias</span><span class="o">* </span><span class="n">names</span>, <span class="bp">int</span><span class="o">? </span><span class="n">level</span><span class="p">)</span>
|
||
|
||
<span class="o">|</span> <span class="nc">Global</span><span class="p">(</span><span class="bp">identifier</span><span class="o">* </span><span class="n">names</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Nonlocal</span><span class="p">(</span><span class="bp">identifier</span><span class="o">* </span><span class="n">names</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Expr</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Pass</span> <span class="o">|</span> <span class="nc">Break</span> <span class="o">|</span> <span class="nc">Continue</span>
|
||
|
||
<span class="c c-Singleline">-- col_offset is the byte offset in the utf8 string the parser uses</span>
|
||
<span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span>
|
||
|
||
<span class="c c-Singleline">-- BoolOp() can use left & right?</span>
|
||
<span class="n">expr</span> <span class="o">=</span> <span class="nc">BoolOp</span><span class="p">(</span><span class="bp">boolop</span><span class="o"> </span><span class="n">op</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">values</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">NamedExpr</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">BinOp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">left</span>, <span class="bp">operator</span><span class="o"> </span><span class="n">op</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">right</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">UnaryOp</span><span class="p">(</span><span class="bp">unaryop</span><span class="o"> </span><span class="n">op</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">operand</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Lambda</span><span class="p">(</span><span class="bp">arguments</span><span class="o"> </span><span class="n">args</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">body</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">IfExp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">test</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">body</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">orelse</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Dict</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">keys</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">values</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Set</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">elts</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">ListComp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">elt</span>, <span class="bp">comprehension</span><span class="o">* </span><span class="n">generators</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">SetComp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">elt</span>, <span class="bp">comprehension</span><span class="o">* </span><span class="n">generators</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">DictComp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">key</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">comprehension</span><span class="o">* </span><span class="n">generators</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">GeneratorExp</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">elt</span>, <span class="bp">comprehension</span><span class="o">* </span><span class="n">generators</span><span class="p">)</span>
|
||
<span class="c c-Singleline">-- the grammar constrains where yield expressions can occur</span>
|
||
<span class="o">|</span> <span class="nc">Await</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Yield</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">YieldFrom</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="c c-Singleline">-- need sequences for compare to distinguish between</span>
|
||
<span class="c c-Singleline">-- x < 4 < 3 and (x < 4) < 3</span>
|
||
<span class="o">|</span> <span class="nc">Compare</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">left</span>, <span class="bp">cmpop</span><span class="o">* </span><span class="n">ops</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">comparators</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Call</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">func</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">args</span>, <span class="bp">keyword</span><span class="o">* </span><span class="n">keywords</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">FormattedValue</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">int</span><span class="o"> </span><span class="n">conversion</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">format_spec</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">JoinedStr</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">values</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Constant</span><span class="p">(</span><span class="bp">constant</span><span class="o"> </span><span class="n">value</span>, <span class="bp">string</span><span class="o">? </span><span class="n">kind</span><span class="p">)</span>
|
||
|
||
<span class="c c-Singleline">-- the following expression can appear in assignment context</span>
|
||
<span class="o">|</span> <span class="nc">Attribute</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">identifier</span><span class="o"> </span><span class="n">attr</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Subscript</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">slice</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Starred</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Name</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">id</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">List</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">elts</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">Tuple</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">elts</span>, <span class="bp">expr_context</span><span class="o"> </span><span class="n">ctx</span><span class="p">)</span>
|
||
|
||
<span class="c c-Singleline">-- can appear only in Subscript</span>
|
||
<span class="o">|</span> <span class="nc">Slice</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">lower</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">upper</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">step</span><span class="p">)</span>
|
||
|
||
<span class="c c-Singleline">-- col_offset is the byte offset in the utf8 string the parser uses</span>
|
||
<span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span>
|
||
|
||
<span class="n">expr_context</span> <span class="o">=</span> <span class="nc">Load</span> <span class="o">|</span> <span class="nc">Store</span> <span class="o">|</span> <span class="nc">Del</span>
|
||
|
||
<span class="n">boolop</span> <span class="o">=</span> <span class="nc">And</span> <span class="o">|</span> <span class="nc">Or</span>
|
||
|
||
<span class="n">operator</span> <span class="o">=</span> <span class="nc">Add</span> <span class="o">|</span> <span class="nc">Sub</span> <span class="o">|</span> <span class="nc">Mult</span> <span class="o">|</span> <span class="nc">MatMult</span> <span class="o">|</span> <span class="nc">Div</span> <span class="o">|</span> <span class="nc">Mod</span> <span class="o">|</span> <span class="nc">Pow</span> <span class="o">|</span> <span class="nc">LShift</span>
|
||
<span class="o">|</span> <span class="nc">RShift</span> <span class="o">|</span> <span class="nc">BitOr</span> <span class="o">|</span> <span class="nc">BitXor</span> <span class="o">|</span> <span class="nc">BitAnd</span> <span class="o">|</span> <span class="nc">FloorDiv</span>
|
||
|
||
<span class="n">unaryop</span> <span class="o">=</span> <span class="nc">Invert</span> <span class="o">|</span> <span class="nc">Not</span> <span class="o">|</span> <span class="nc">UAdd</span> <span class="o">|</span> <span class="nc">USub</span>
|
||
|
||
<span class="n">cmpop</span> <span class="o">=</span> <span class="nc">Eq</span> <span class="o">|</span> <span class="nc">NotEq</span> <span class="o">|</span> <span class="nc">Lt</span> <span class="o">|</span> <span class="nc">LtE</span> <span class="o">|</span> <span class="nc">Gt</span> <span class="o">|</span> <span class="nc">GtE</span> <span class="o">|</span> <span class="nc">Is</span> <span class="o">|</span> <span class="nc">IsNot</span> <span class="o">|</span> <span class="nc">In</span> <span class="o">|</span> <span class="nc">NotIn</span>
|
||
|
||
<span class="n">comprehension</span> <span class="o">=</span> <span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">target</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">iter</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">ifs</span>, <span class="bp">int</span><span class="o"> </span><span class="n">is_async</span><span class="p">)</span>
|
||
|
||
<span class="n">excepthandler</span> <span class="o">=</span> <span class="nc">ExceptHandler</span><span class="p">(</span><span class="bp">expr</span><span class="o">? </span><span class="n">type</span>, <span class="bp">identifier</span><span class="o">? </span><span class="n">name</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span><span class="p">)</span>
|
||
<span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span>
|
||
|
||
<span class="n">arguments</span> <span class="o">=</span> <span class="p">(</span><span class="bp">arg</span><span class="o">* </span><span class="n">posonlyargs</span>, <span class="bp">arg</span><span class="o">* </span><span class="n">args</span>, <span class="bp">arg</span><span class="o">? </span><span class="n">vararg</span>, <span class="bp">arg</span><span class="o">* </span><span class="n">kwonlyargs</span>,
|
||
<span class="bp">expr</span><span class="o">* </span><span class="n">kw_defaults</span>, <span class="bp">arg</span><span class="o">? </span><span class="n">kwarg</span>, <span class="bp">expr</span><span class="o">* </span><span class="n">defaults</span><span class="p">)</span>
|
||
|
||
<span class="n">arg</span> <span class="o">=</span> <span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">arg</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">annotation</span>, <span class="bp">string</span><span class="o">? </span><span class="n">type_comment</span><span class="p">)</span>
|
||
<span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span>
|
||
|
||
<span class="c c-Singleline">-- keyword arguments supplied to call (NULL identifier for **kwargs)</span>
|
||
<span class="n">keyword</span> <span class="o">=</span> <span class="p">(</span><span class="bp">identifier</span><span class="o">? </span><span class="n">arg</span>, <span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span>
|
||
|
||
<span class="c c-Singleline">-- import name with optional 'as' alias.</span>
|
||
<span class="n">alias</span> <span class="o">=</span> <span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">identifier</span><span class="o">? </span><span class="n">asname</span><span class="p">)</span>
|
||
<span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o">? </span><span class="n">end_col_offset</span><span class="p">)</span>
|
||
|
||
<span class="n">withitem</span> <span class="o">=</span> <span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">context_expr</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">optional_vars</span><span class="p">)</span>
|
||
|
||
<span class="n">match_case</span> <span class="o">=</span> <span class="p">(</span><span class="bp">pattern</span><span class="o"> </span><span class="n">pattern</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">guard</span>, <span class="bp">stmt</span><span class="o">* </span><span class="n">body</span><span class="p">)</span>
|
||
|
||
<span class="n">pattern</span> <span class="o">=</span> <span class="nc">MatchValue</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">MatchSingleton</span><span class="p">(</span><span class="bp">constant</span><span class="o"> </span><span class="n">value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">MatchSequence</span><span class="p">(</span><span class="bp">pattern</span><span class="o">* </span><span class="n">patterns</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">MatchMapping</span><span class="p">(</span><span class="bp">expr</span><span class="o">* </span><span class="n">keys</span>, <span class="bp">pattern</span><span class="o">* </span><span class="n">patterns</span>, <span class="bp">identifier</span><span class="o">? </span><span class="n">rest</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">MatchClass</span><span class="p">(</span><span class="bp">expr</span><span class="o"> </span><span class="n">cls</span>, <span class="bp">pattern</span><span class="o">* </span><span class="n">patterns</span>, <span class="bp">identifier</span><span class="o">* </span><span class="n">kwd_attrs</span>, <span class="bp">pattern</span><span class="o">* </span><span class="n">kwd_patterns</span><span class="p">)</span>
|
||
|
||
<span class="o">|</span> <span class="nc">MatchStar</span><span class="p">(</span><span class="bp">identifier</span><span class="o">? </span><span class="n">name</span><span class="p">)</span>
|
||
<span class="c c-Singleline">-- The optional "rest" MatchMapping parameter handles capturing extra mapping keys</span>
|
||
|
||
<span class="o">|</span> <span class="nc">MatchAs</span><span class="p">(</span><span class="bp">pattern</span><span class="o">? </span><span class="n">pattern</span>, <span class="bp">identifier</span><span class="o">? </span><span class="n">name</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">MatchOr</span><span class="p">(</span><span class="bp">pattern</span><span class="o">* </span><span class="n">patterns</span><span class="p">)</span>
|
||
|
||
<span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o"> </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">end_col_offset</span><span class="p">)</span>
|
||
|
||
<span class="n">type_ignore</span> <span class="o">=</span> <span class="nc">TypeIgnore</span><span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">string</span><span class="o"> </span><span class="n">tag</span><span class="p">)</span>
|
||
|
||
<span class="n">type_param</span> <span class="o">=</span> <span class="nc">TypeVar</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">bound</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">default_value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">ParamSpec</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">default_value</span><span class="p">)</span>
|
||
<span class="o">|</span> <span class="nc">TypeVarTuple</span><span class="p">(</span><span class="bp">identifier</span><span class="o"> </span><span class="n">name</span>, <span class="bp">expr</span><span class="o">? </span><span class="n">default_value</span><span class="p">)</span>
|
||
<span class="nb">attributes</span> <span class="p">(</span><span class="bp">int</span><span class="o"> </span><span class="n">lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">col_offset</span>, <span class="bp">int</span><span class="o"> </span><span class="n">end_lineno</span>, <span class="bp">int</span><span class="o"> </span><span class="n">end_col_offset</span><span class="p">)</span>
|
||
<span class="p">}</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="node-classes">
|
||
<h2>Node classes<a class="headerlink" href="#node-classes" title="Link to this heading">¶</a></h2>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.AST">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AST</span></span><a class="headerlink" href="#ast.AST" title="Link to this definition">¶</a></dt>
|
||
<dd><p>This is the base of all AST node classes. The actual node classes are
|
||
derived from the <code class="file docutils literal notranslate"><span class="pre">Parser/Python.asdl</span></code> file, which is reproduced
|
||
<a class="reference internal" href="#abstract-grammar"><span class="std std-ref">above</span></a>. They are defined in the <code class="xref py py-mod docutils literal notranslate"><span class="pre">_ast</span></code> C
|
||
module and re-exported in <a class="reference internal" href="#module-ast" title="ast: Abstract Syntax Tree classes and manipulation."><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code></a>.</p>
|
||
<p>There is one class defined for each left-hand side symbol in the abstract
|
||
grammar (for example, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.stmt</span></code> or <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr</span></code>). In addition,
|
||
there is one class defined for each constructor on the right-hand side; these
|
||
classes inherit from the classes for the left-hand side trees. For example,
|
||
<a class="reference internal" href="#ast.BinOp" title="ast.BinOp"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.BinOp</span></code></a> inherits from <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr</span></code>. For production rules
|
||
with alternatives (aka “sums”), the left-hand side class is abstract: only
|
||
instances of specific constructor nodes are ever created.</p>
|
||
<dl class="py attribute" id="index-1">
|
||
<span id="index-0"></span><dt class="sig sig-object py" id="ast.AST._fields">
|
||
<span class="sig-name descname"><span class="pre">_fields</span></span><a class="headerlink" href="#ast.AST._fields" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Each concrete class has an attribute <code class="xref py py-attr docutils literal notranslate"><span class="pre">_fields</span></code> which gives the names
|
||
of all child nodes.</p>
|
||
<p>Each instance of a concrete class has one attribute for each child node,
|
||
of the type as defined in the grammar. For example, <a class="reference internal" href="#ast.BinOp" title="ast.BinOp"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.BinOp</span></code></a>
|
||
instances have an attribute <code class="xref py py-attr docutils literal notranslate"><span class="pre">left</span></code> of type <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr</span></code>.</p>
|
||
<p>If these attributes are marked as optional in the grammar (using a
|
||
question mark), the value might be <code class="docutils literal notranslate"><span class="pre">None</span></code>. If the attributes can have
|
||
zero-or-more values (marked with an asterisk), the values are represented
|
||
as Python lists. All possible attributes must be present and have valid
|
||
values when compiling an AST with <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py attribute">
|
||
<dt class="sig sig-object py" id="ast.AST._field_types">
|
||
<span class="sig-name descname"><span class="pre">_field_types</span></span><a class="headerlink" href="#ast.AST._field_types" title="Link to this definition">¶</a></dt>
|
||
<dd><p>The <code class="xref py py-attr docutils literal notranslate"><span class="pre">_field_types</span></code> attribute on each concrete class is a dictionary
|
||
mapping field names (as also listed in <a class="reference internal" href="#ast.AST._fields" title="ast.AST._fields"><code class="xref py py-attr docutils literal notranslate"><span class="pre">_fields</span></code></a>) to their types.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">ast</span><span class="o">.</span><span class="n">TypeVar</span><span class="o">.</span><span class="n">_field_types</span>
|
||
<span class="go">{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr | None}</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.13.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py attribute">
|
||
<dt class="sig sig-object py" id="ast.AST.lineno">
|
||
<span class="sig-name descname"><span class="pre">lineno</span></span><a class="headerlink" href="#ast.AST.lineno" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.AST.col_offset">
|
||
<span class="sig-name descname"><span class="pre">col_offset</span></span><a class="headerlink" href="#ast.AST.col_offset" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.AST.end_lineno">
|
||
<span class="sig-name descname"><span class="pre">end_lineno</span></span><a class="headerlink" href="#ast.AST.end_lineno" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.AST.end_col_offset">
|
||
<span class="sig-name descname"><span class="pre">end_col_offset</span></span><a class="headerlink" href="#ast.AST.end_col_offset" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Instances of <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr</span></code> and <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.stmt</span></code> subclasses have
|
||
<a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a>, <a class="reference internal" href="#ast.AST.col_offset" title="ast.AST.col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code></a>, <a class="reference internal" href="#ast.AST.end_lineno" title="ast.AST.end_lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_lineno</span></code></a>, and
|
||
<a class="reference internal" href="#ast.AST.end_col_offset" title="ast.AST.end_col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_col_offset</span></code></a> attributes. The <a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a> and <a class="reference internal" href="#ast.AST.end_lineno" title="ast.AST.end_lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_lineno</span></code></a>
|
||
are the first and last line numbers of source text span (1-indexed so the
|
||
first line is line 1) and the <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> and <a class="reference internal" href="#ast.AST.end_col_offset" title="ast.AST.end_col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_col_offset</span></code></a>
|
||
are the corresponding UTF-8 byte offsets of the first and last tokens that
|
||
generated the node. The UTF-8 offset is recorded because the parser uses
|
||
UTF-8 internally.</p>
|
||
<p>Note that the end positions are not required by the compiler and are
|
||
therefore optional. The end offset is <em>after</em> the last symbol, for example
|
||
one can get the source segment of a one-line expression node using
|
||
<code class="docutils literal notranslate"><span class="pre">source_line[node.col_offset</span> <span class="pre">:</span> <span class="pre">node.end_col_offset]</span></code>.</p>
|
||
</dd></dl>
|
||
|
||
<p>The constructor of a class <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.T</span></code> parses its arguments as follows:</p>
|
||
<ul class="simple">
|
||
<li><p>If there are positional arguments, there must be as many as there are items
|
||
in <code class="xref py py-attr docutils literal notranslate"><span class="pre">T._fields</span></code>; they will be assigned as attributes of these names.</p></li>
|
||
<li><p>If there are keyword arguments, they will set the attributes of the same
|
||
names to the given values.</p></li>
|
||
</ul>
|
||
<p>For example, to create and populate an <a class="reference internal" href="#ast.UnaryOp" title="ast.UnaryOp"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.UnaryOp</span></code></a> node, you could
|
||
use</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">node</span> <span class="o">=</span> <span class="n">ast</span><span class="o">.</span><span class="n">UnaryOp</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">USub</span><span class="p">(),</span> <span class="n">ast</span><span class="o">.</span><span class="n">Constant</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="n">lineno</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">col_offset</span><span class="o">=</span><span class="mi">0</span><span class="p">),</span>
|
||
<span class="n">lineno</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">col_offset</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>If a field that is optional in the grammar is omitted from the constructor,
|
||
it defaults to <code class="docutils literal notranslate"><span class="pre">None</span></code>. If a list field is omitted, it defaults to the empty
|
||
list. If a field of type <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr_context</span></code> is omitted, it defaults to
|
||
<a class="reference internal" href="#ast.Load" title="ast.Load"><code class="xref py py-class docutils literal notranslate"><span class="pre">Load()</span></code></a>. If any other field is omitted, a <a class="reference internal" href="exceptions.html#DeprecationWarning" title="DeprecationWarning"><code class="xref py py-exc docutils literal notranslate"><span class="pre">DeprecationWarning</span></code></a> is raised
|
||
and the AST node will not have this field. In Python 3.15, this condition will
|
||
raise an error.</p>
|
||
</dd></dl>
|
||
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.8: </span>Class <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Constant</span></code></a> is now used for all constants.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.9: </span>Simple indices are represented by their value, extended slices are
|
||
represented as tuples.</p>
|
||
</div>
|
||
<div class="deprecated">
|
||
<p><span class="versionmodified deprecated">Deprecated since version 3.8: </span>Old classes <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Num</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Str</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Bytes</span></code>,
|
||
<code class="xref py py-class docutils literal notranslate"><span class="pre">ast.NameConstant</span></code> and <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Ellipsis</span></code> are still available,
|
||
but they will be removed in future Python releases. In the meantime,
|
||
instantiating them will return an instance of a different class.</p>
|
||
</div>
|
||
<div class="deprecated">
|
||
<p><span class="versionmodified deprecated">Deprecated since version 3.9: </span>Old classes <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Index</span></code> and <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.ExtSlice</span></code> are still
|
||
available, but they will be removed in future Python releases.
|
||
In the meantime, instantiating them will return an instance of
|
||
a different class.</p>
|
||
</div>
|
||
<div class="deprecated-removed">
|
||
<p><span class="versionmodified deprecated">Deprecated since version 3.13, will be removed in version 3.15: </span>Previous versions of Python allowed the creation of AST nodes that were missing
|
||
required fields. Similarly, AST node constructors allowed arbitrary keyword
|
||
arguments that were set as attributes of the AST node, even if they did not
|
||
match any of the fields of the AST node. This behavior is deprecated and will
|
||
be removed in Python 3.15.</p>
|
||
</div>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>The descriptions of the specific node classes displayed here
|
||
were initially adapted from the fantastic <a class="reference external" href="https://greentreesnakes.readthedocs.io/en/latest/">Green Tree
|
||
Snakes</a> project and
|
||
all its contributors.</p>
|
||
</div>
|
||
<section id="root-nodes">
|
||
<span id="ast-root-nodes"></span><h3>Root nodes<a class="headerlink" href="#root-nodes" title="Link to this heading">¶</a></h3>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Module">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Module</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_ignores</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Module" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A Python module, as with <a class="reference internal" href="../reference/toplevel_components.html#file-input"><span class="std std-ref">file input</span></a>.
|
||
Node type generated by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> in the default <code class="docutils literal notranslate"><span class="pre">"exec"</span></code> <em>mode</em>.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> of the module’s <a class="reference internal" href="#ast-statements"><span class="std std-ref">Statements</span></a>.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">type_ignores</span></code> is a <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> of the module’s type ignore comments;
|
||
see <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> for more details.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x = 1'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Assign(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Name(id='x', ctx=Store())],</span>
|
||
<span class="go"> value=Constant(value=1))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Expression">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Expression</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Expression" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A single Python <a class="reference internal" href="../reference/toplevel_components.html#expression-input"><span class="std std-ref">expression input</span></a>.
|
||
Node type generated by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> when <em>mode</em> is <code class="docutils literal notranslate"><span class="pre">"eval"</span></code>.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a single node,
|
||
one of the <a class="reference internal" href="#ast-expressions"><span class="std std-ref">expression types</span></a>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'123'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Constant(value=123))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Interactive">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Interactive</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Interactive" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A single <a class="reference internal" href="../reference/toplevel_components.html#interactive"><span class="std std-ref">interactive input</span></a>, like in <a class="reference internal" href="../tutorial/appendix.html#tut-interac"><span class="std std-ref">Interactive Mode</span></a>.
|
||
Node type generated by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> when <em>mode</em> is <code class="docutils literal notranslate"><span class="pre">"single"</span></code>.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> of <a class="reference internal" href="#ast-statements"><span class="std std-ref">statement nodes</span></a>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x = 1; y = 2'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'single'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Interactive(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Assign(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Name(id='x', ctx=Store())],</span>
|
||
<span class="go"> value=Constant(value=1)),</span>
|
||
<span class="go"> Assign(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Name(id='y', ctx=Store())],</span>
|
||
<span class="go"> value=Constant(value=2))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.FunctionType">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">FunctionType</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">argtypes</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">returns</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.FunctionType" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A representation of an old-style type comments for functions,
|
||
as Python versions prior to 3.5 didn’t support <span class="target" id="index-2"></span><a class="pep reference external" href="https://peps.python.org/pep-0484/"><strong>PEP 484</strong></a> annotations.
|
||
Node type generated by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> when <em>mode</em> is <code class="docutils literal notranslate"><span class="pre">"func_type"</span></code>.</p>
|
||
<p>Such type comments would look like this:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">sum_two_number</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
|
||
<span class="c1"># type: (int, int) -> int</span>
|
||
<span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span>
|
||
</pre></div>
|
||
</div>
|
||
<p><code class="docutils literal notranslate"><span class="pre">argtypes</span></code> is a <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> of <a class="reference internal" href="#ast-expressions"><span class="std std-ref">expression nodes</span></a>.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">returns</span></code> is a single <a class="reference internal" href="#ast-expressions"><span class="std std-ref">expression node</span></a>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(int, str) -> List[int]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'func_type'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">FunctionType(</span>
|
||
<span class="go"> argtypes=[</span>
|
||
<span class="go"> Name(id='int', ctx=Load()),</span>
|
||
<span class="go"> Name(id='str', ctx=Load())],</span>
|
||
<span class="go"> returns=Subscript(</span>
|
||
<span class="go"> value=Name(id='List', ctx=Load()),</span>
|
||
<span class="go"> slice=Name(id='int', ctx=Load()),</span>
|
||
<span class="go"> ctx=Load()))</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.8.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="literals">
|
||
<h3>Literals<a class="headerlink" href="#literals" title="Link to this heading">¶</a></h3>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Constant">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Constant</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Constant" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A constant value. The <code class="docutils literal notranslate"><span class="pre">value</span></code> attribute of the <code class="docutils literal notranslate"><span class="pre">Constant</span></code> literal contains the
|
||
Python object it represents. The values represented can be simple types
|
||
such as a number, string or <code class="docutils literal notranslate"><span class="pre">None</span></code>, but also immutable container types
|
||
(tuples and frozensets) if all of their elements are constant.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'123'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Constant(value=123))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.FormattedValue">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">FormattedValue</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">conversion</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">format_spec</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.FormattedValue" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Node representing a single formatting field in an f-string. If the string
|
||
contains a single formatting field and nothing else the node can be
|
||
isolated otherwise it appears in <a class="reference internal" href="#ast.JoinedStr" title="ast.JoinedStr"><code class="xref py py-class docutils literal notranslate"><span class="pre">JoinedStr</span></code></a>.</p>
|
||
<ul class="simple">
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">value</span></code> is any expression node (such as a literal, a variable, or a
|
||
function call).</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">conversion</span></code> is an integer:</p>
|
||
<ul>
|
||
<li><p>-1: no formatting</p></li>
|
||
<li><p>115: <code class="docutils literal notranslate"><span class="pre">!s</span></code> string formatting</p></li>
|
||
<li><p>114: <code class="docutils literal notranslate"><span class="pre">!r</span></code> repr formatting</p></li>
|
||
<li><p>97: <code class="docutils literal notranslate"><span class="pre">!a</span></code> ascii formatting</p></li>
|
||
</ul>
|
||
</li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">format_spec</span></code> is a <a class="reference internal" href="#ast.JoinedStr" title="ast.JoinedStr"><code class="xref py py-class docutils literal notranslate"><span class="pre">JoinedStr</span></code></a> node representing the formatting
|
||
of the value, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if no format was specified. Both
|
||
<code class="docutils literal notranslate"><span class="pre">conversion</span></code> and <code class="docutils literal notranslate"><span class="pre">format_spec</span></code> can be set at the same time.</p></li>
|
||
</ul>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.JoinedStr">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">JoinedStr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">values</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.JoinedStr" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An f-string, comprising a series of <a class="reference internal" href="#ast.FormattedValue" title="ast.FormattedValue"><code class="xref py py-class docutils literal notranslate"><span class="pre">FormattedValue</span></code></a> and <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a>
|
||
nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'f"sin(</span><span class="si">{a}</span><span class="s1">) is {sin(a):.3}"'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=JoinedStr(</span>
|
||
<span class="go"> values=[</span>
|
||
<span class="go"> Constant(value='sin('),</span>
|
||
<span class="go"> FormattedValue(</span>
|
||
<span class="go"> value=Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> conversion=-1),</span>
|
||
<span class="go"> Constant(value=') is '),</span>
|
||
<span class="go"> FormattedValue(</span>
|
||
<span class="go"> value=Call(</span>
|
||
<span class="go"> func=Name(id='sin', ctx=Load()),</span>
|
||
<span class="go"> args=[</span>
|
||
<span class="go"> Name(id='a', ctx=Load())]),</span>
|
||
<span class="go"> conversion=-1,</span>
|
||
<span class="go"> format_spec=JoinedStr(</span>
|
||
<span class="go"> values=[</span>
|
||
<span class="go"> Constant(value='.3')]))]))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.List">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">List</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elts</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.List" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Tuple">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Tuple</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elts</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Tuple" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A list or tuple. <code class="docutils literal notranslate"><span class="pre">elts</span></code> holds a list of nodes representing the elements.
|
||
<code class="docutils literal notranslate"><span class="pre">ctx</span></code> is <a class="reference internal" href="#ast.Store" title="ast.Store"><code class="xref py py-class docutils literal notranslate"><span class="pre">Store</span></code></a> if the container is an assignment target (i.e.
|
||
<code class="docutils literal notranslate"><span class="pre">(x,y)=something</span></code>), and <a class="reference internal" href="#ast.Load" title="ast.Load"><code class="xref py py-class docutils literal notranslate"><span class="pre">Load</span></code></a> otherwise.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'[1, 2, 3]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=List(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Constant(value=1),</span>
|
||
<span class="go"> Constant(value=2),</span>
|
||
<span class="go"> Constant(value=3)],</span>
|
||
<span class="go"> ctx=Load()))</span>
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(1, 2, 3)'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Tuple(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Constant(value=1),</span>
|
||
<span class="go"> Constant(value=2),</span>
|
||
<span class="go"> Constant(value=3)],</span>
|
||
<span class="go"> ctx=Load()))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Set">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Set</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elts</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Set" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A set. <code class="docutils literal notranslate"><span class="pre">elts</span></code> holds a list of nodes representing the set’s elements.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'{1, 2, 3}'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Set(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Constant(value=1),</span>
|
||
<span class="go"> Constant(value=2),</span>
|
||
<span class="go"> Constant(value=3)]))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Dict">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Dict</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">keys</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">values</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Dict" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A dictionary. <code class="docutils literal notranslate"><span class="pre">keys</span></code> and <code class="docutils literal notranslate"><span class="pre">values</span></code> hold lists of nodes representing the
|
||
keys and the values respectively, in matching order (what would be returned
|
||
when calling <code class="code docutils literal notranslate"><span class="pre">dictionary.keys()</span></code> and <code class="code docutils literal notranslate"><span class="pre">dictionary.values()</span></code>).</p>
|
||
<p>When doing dictionary unpacking using dictionary literals the expression to be
|
||
expanded goes in the <code class="docutils literal notranslate"><span class="pre">values</span></code> list, with a <code class="docutils literal notranslate"><span class="pre">None</span></code> at the corresponding
|
||
position in <code class="docutils literal notranslate"><span class="pre">keys</span></code>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'{"a":1, **d}'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Dict(</span>
|
||
<span class="go"> keys=[</span>
|
||
<span class="go"> Constant(value='a'),</span>
|
||
<span class="go"> None],</span>
|
||
<span class="go"> values=[</span>
|
||
<span class="go"> Constant(value=1),</span>
|
||
<span class="go"> Name(id='d', ctx=Load())]))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="variables">
|
||
<h3>Variables<a class="headerlink" href="#variables" title="Link to this heading">¶</a></h3>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Name">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Name</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">id</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Name" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A variable name. <code class="docutils literal notranslate"><span class="pre">id</span></code> holds the name as a string, and <code class="docutils literal notranslate"><span class="pre">ctx</span></code> is one of
|
||
the following types.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Load">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Load</span></span><a class="headerlink" href="#ast.Load" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Store">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Store</span></span><a class="headerlink" href="#ast.Store" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Del">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Del</span></span><a class="headerlink" href="#ast.Del" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Variable references can be used to load the value of a variable, to assign
|
||
a new value to it, or to delete it. Variable references are given a context
|
||
to distinguish these cases.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Name(id='a', ctx=Load()))])</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a = 1'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Assign(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Name(id='a', ctx=Store())],</span>
|
||
<span class="go"> value=Constant(value=1))])</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'del a'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Delete(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Name(id='a', ctx=Del())])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Starred">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Starred</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Starred" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">*var</span></code> variable reference. <code class="docutils literal notranslate"><span class="pre">value</span></code> holds the variable, typically a
|
||
<a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node. This type must be used when building a <a class="reference internal" href="#ast.Call" title="ast.Call"><code class="xref py py-class docutils literal notranslate"><span class="pre">Call</span></code></a>
|
||
node with <code class="docutils literal notranslate"><span class="pre">*args</span></code>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a, *b = it'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Assign(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Tuple(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Name(id='a', ctx=Store()),</span>
|
||
<span class="go"> Starred(</span>
|
||
<span class="go"> value=Name(id='b', ctx=Store()),</span>
|
||
<span class="go"> ctx=Store())],</span>
|
||
<span class="go"> ctx=Store())],</span>
|
||
<span class="go"> value=Name(id='it', ctx=Load()))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="expressions">
|
||
<span id="ast-expressions"></span><h3>Expressions<a class="headerlink" href="#expressions" title="Link to this heading">¶</a></h3>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Expr">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Expr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Expr" title="Link to this definition">¶</a></dt>
|
||
<dd><p>When an expression, such as a function call, appears as a statement by itself
|
||
with its return value not used or stored, it is wrapped in this container.
|
||
<code class="docutils literal notranslate"><span class="pre">value</span></code> holds one of the other nodes in this section, a <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a>, a
|
||
<a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, a <a class="reference internal" href="#ast.Lambda" title="ast.Lambda"><code class="xref py py-class docutils literal notranslate"><span class="pre">Lambda</span></code></a>, a <a class="reference internal" href="#ast.Yield" title="ast.Yield"><code class="xref py py-class docutils literal notranslate"><span class="pre">Yield</span></code></a> or <a class="reference internal" href="#ast.YieldFrom" title="ast.YieldFrom"><code class="xref py py-class docutils literal notranslate"><span class="pre">YieldFrom</span></code></a> node.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'-a'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=UnaryOp(</span>
|
||
<span class="go"> op=USub(),</span>
|
||
<span class="go"> operand=Name(id='a', ctx=Load())))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.UnaryOp">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">UnaryOp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">operand</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.UnaryOp" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A unary operation. <code class="docutils literal notranslate"><span class="pre">op</span></code> is the operator, and <code class="docutils literal notranslate"><span class="pre">operand</span></code> any expression
|
||
node.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.UAdd">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">UAdd</span></span><a class="headerlink" href="#ast.UAdd" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.USub">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">USub</span></span><a class="headerlink" href="#ast.USub" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Not">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Not</span></span><a class="headerlink" href="#ast.Not" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Invert">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Invert</span></span><a class="headerlink" href="#ast.Invert" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Unary operator tokens. <a class="reference internal" href="#ast.Not" title="ast.Not"><code class="xref py py-class docutils literal notranslate"><span class="pre">Not</span></code></a> is the <code class="docutils literal notranslate"><span class="pre">not</span></code> keyword, <a class="reference internal" href="#ast.Invert" title="ast.Invert"><code class="xref py py-class docutils literal notranslate"><span class="pre">Invert</span></code></a>
|
||
is the <code class="docutils literal notranslate"><span class="pre">~</span></code> operator.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'not x'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=UnaryOp(</span>
|
||
<span class="go"> op=Not(),</span>
|
||
<span class="go"> operand=Name(id='x', ctx=Load())))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.BinOp">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BinOp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">left</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">right</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.BinOp" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A binary operation (like addition or division). <code class="docutils literal notranslate"><span class="pre">op</span></code> is the operator, and
|
||
<code class="docutils literal notranslate"><span class="pre">left</span></code> and <code class="docutils literal notranslate"><span class="pre">right</span></code> are any expression nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x + y'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=BinOp(</span>
|
||
<span class="go"> left=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> op=Add(),</span>
|
||
<span class="go"> right=Name(id='y', ctx=Load())))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Add">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Add</span></span><a class="headerlink" href="#ast.Add" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Sub">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Sub</span></span><a class="headerlink" href="#ast.Sub" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Mult">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Mult</span></span><a class="headerlink" href="#ast.Mult" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Div">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Div</span></span><a class="headerlink" href="#ast.Div" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.FloorDiv">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">FloorDiv</span></span><a class="headerlink" href="#ast.FloorDiv" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Mod">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Mod</span></span><a class="headerlink" href="#ast.Mod" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Pow">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Pow</span></span><a class="headerlink" href="#ast.Pow" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.LShift">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">LShift</span></span><a class="headerlink" href="#ast.LShift" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.RShift">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">RShift</span></span><a class="headerlink" href="#ast.RShift" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.BitOr">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BitOr</span></span><a class="headerlink" href="#ast.BitOr" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.BitXor">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BitXor</span></span><a class="headerlink" href="#ast.BitXor" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.BitAnd">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BitAnd</span></span><a class="headerlink" href="#ast.BitAnd" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.MatMult">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatMult</span></span><a class="headerlink" href="#ast.MatMult" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Binary operator tokens.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.BoolOp">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">BoolOp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">values</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.BoolOp" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A boolean operation, ‘or’ or ‘and’. <code class="docutils literal notranslate"><span class="pre">op</span></code> is <a class="reference internal" href="#ast.Or" title="ast.Or"><code class="xref py py-class docutils literal notranslate"><span class="pre">Or</span></code></a> or <a class="reference internal" href="#ast.And" title="ast.And"><code class="xref py py-class docutils literal notranslate"><span class="pre">And</span></code></a>.
|
||
<code class="docutils literal notranslate"><span class="pre">values</span></code> are the values involved. Consecutive operations with the same
|
||
operator, such as <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">or</span> <span class="pre">b</span> <span class="pre">or</span> <span class="pre">c</span></code>, are collapsed into one node with several
|
||
values.</p>
|
||
<p>This doesn’t include <code class="docutils literal notranslate"><span class="pre">not</span></code>, which is a <a class="reference internal" href="#ast.UnaryOp" title="ast.UnaryOp"><code class="xref py py-class docutils literal notranslate"><span class="pre">UnaryOp</span></code></a>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x or y'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=BoolOp(</span>
|
||
<span class="go"> op=Or(),</span>
|
||
<span class="go"> values=[</span>
|
||
<span class="go"> Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> Name(id='y', ctx=Load())]))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.And">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">And</span></span><a class="headerlink" href="#ast.And" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Or">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Or</span></span><a class="headerlink" href="#ast.Or" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Boolean operator tokens.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Compare">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Compare</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">left</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ops</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">comparators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Compare" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A comparison of two or more values. <code class="docutils literal notranslate"><span class="pre">left</span></code> is the first value in the
|
||
comparison, <code class="docutils literal notranslate"><span class="pre">ops</span></code> the list of operators, and <code class="docutils literal notranslate"><span class="pre">comparators</span></code> the list
|
||
of values after the first element in the comparison.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'1 <= a < 10'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Compare(</span>
|
||
<span class="go"> left=Constant(value=1),</span>
|
||
<span class="go"> ops=[</span>
|
||
<span class="go"> LtE(),</span>
|
||
<span class="go"> Lt()],</span>
|
||
<span class="go"> comparators=[</span>
|
||
<span class="go"> Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> Constant(value=10)]))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Eq">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Eq</span></span><a class="headerlink" href="#ast.Eq" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.NotEq">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NotEq</span></span><a class="headerlink" href="#ast.NotEq" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Lt">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Lt</span></span><a class="headerlink" href="#ast.Lt" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.LtE">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">LtE</span></span><a class="headerlink" href="#ast.LtE" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Gt">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Gt</span></span><a class="headerlink" href="#ast.Gt" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.GtE">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">GtE</span></span><a class="headerlink" href="#ast.GtE" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Is">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Is</span></span><a class="headerlink" href="#ast.Is" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.IsNot">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">IsNot</span></span><a class="headerlink" href="#ast.IsNot" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.In">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">In</span></span><a class="headerlink" href="#ast.In" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.NotIn">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NotIn</span></span><a class="headerlink" href="#ast.NotIn" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Comparison operator tokens.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Call">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Call</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">func</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keywords</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Call" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A function call. <code class="docutils literal notranslate"><span class="pre">func</span></code> is the function, which will often be a
|
||
<a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> or <a class="reference internal" href="#ast.Attribute" title="ast.Attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">Attribute</span></code></a> object. Of the arguments:</p>
|
||
<ul class="simple">
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">args</span></code> holds a list of the arguments passed by position.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">keywords</span></code> holds a list of <a class="reference internal" href="#ast.keyword" title="ast.keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">keyword</span></code></a> objects representing
|
||
arguments passed by keyword.</p></li>
|
||
</ul>
|
||
<p>The <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">keywords</span></code> arguments are optional and default to empty lists.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'func(a, b=c, *d, **e)'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Call(</span>
|
||
<span class="go"> func=Name(id='func', ctx=Load()),</span>
|
||
<span class="go"> args=[</span>
|
||
<span class="go"> Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> Starred(</span>
|
||
<span class="go"> value=Name(id='d', ctx=Load()),</span>
|
||
<span class="go"> ctx=Load())],</span>
|
||
<span class="go"> keywords=[</span>
|
||
<span class="go"> keyword(</span>
|
||
<span class="go"> arg='b',</span>
|
||
<span class="go"> value=Name(id='c', ctx=Load())),</span>
|
||
<span class="go"> keyword(</span>
|
||
<span class="go"> value=Name(id='e', ctx=Load()))]))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.keyword">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">keyword</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">arg</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.keyword" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A keyword argument to a function call or class definition. <code class="docutils literal notranslate"><span class="pre">arg</span></code> is a raw
|
||
string of the parameter name, <code class="docutils literal notranslate"><span class="pre">value</span></code> is a node to pass in.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.IfExp">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">IfExp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">test</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.IfExp" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An expression such as <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">if</span> <span class="pre">b</span> <span class="pre">else</span> <span class="pre">c</span></code>. Each field holds a single node, so
|
||
in the following example, all three are <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a if b else c'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=IfExp(</span>
|
||
<span class="go"> test=Name(id='b', ctx=Load()),</span>
|
||
<span class="go"> body=Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> orelse=Name(id='c', ctx=Load())))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Attribute">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Attribute</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">attr</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Attribute" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Attribute access, e.g. <code class="docutils literal notranslate"><span class="pre">d.keys</span></code>. <code class="docutils literal notranslate"><span class="pre">value</span></code> is a node, typically a
|
||
<a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>. <code class="docutils literal notranslate"><span class="pre">attr</span></code> is a bare string giving the name of the attribute,
|
||
and <code class="docutils literal notranslate"><span class="pre">ctx</span></code> is <a class="reference internal" href="#ast.Load" title="ast.Load"><code class="xref py py-class docutils literal notranslate"><span class="pre">Load</span></code></a>, <a class="reference internal" href="#ast.Store" title="ast.Store"><code class="xref py py-class docutils literal notranslate"><span class="pre">Store</span></code></a> or <a class="reference internal" href="#ast.Del" title="ast.Del"><code class="xref py py-class docutils literal notranslate"><span class="pre">Del</span></code></a> according to how
|
||
the attribute is acted on.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'snake.colour'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Attribute(</span>
|
||
<span class="go"> value=Name(id='snake', ctx=Load()),</span>
|
||
<span class="go"> attr='colour',</span>
|
||
<span class="go"> ctx=Load()))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.NamedExpr">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NamedExpr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.NamedExpr" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A named expression. This AST node is produced by the assignment expressions
|
||
operator (also known as the walrus operator). As opposed to the <a class="reference internal" href="#ast.Assign" title="ast.Assign"><code class="xref py py-class docutils literal notranslate"><span class="pre">Assign</span></code></a>
|
||
node in which the first argument can be multiple nodes, in this case both
|
||
<code class="docutils literal notranslate"><span class="pre">target</span></code> and <code class="docutils literal notranslate"><span class="pre">value</span></code> must be single nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(x := 4)'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=NamedExpr(</span>
|
||
<span class="go"> target=Name(id='x', ctx=Store()),</span>
|
||
<span class="go"> value=Constant(value=4)))</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.8.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<section id="subscripting">
|
||
<h4>Subscripting<a class="headerlink" href="#subscripting" title="Link to this heading">¶</a></h4>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Subscript">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Subscript</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">slice</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ctx</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Subscript" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A subscript, such as <code class="docutils literal notranslate"><span class="pre">l[1]</span></code>. <code class="docutils literal notranslate"><span class="pre">value</span></code> is the subscripted object
|
||
(usually sequence or mapping). <code class="docutils literal notranslate"><span class="pre">slice</span></code> is an index, slice or key.
|
||
It can be a <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> and contain a <a class="reference internal" href="#ast.Slice" title="ast.Slice"><code class="xref py py-class docutils literal notranslate"><span class="pre">Slice</span></code></a>.
|
||
<code class="docutils literal notranslate"><span class="pre">ctx</span></code> is <a class="reference internal" href="#ast.Load" title="ast.Load"><code class="xref py py-class docutils literal notranslate"><span class="pre">Load</span></code></a>, <a class="reference internal" href="#ast.Store" title="ast.Store"><code class="xref py py-class docutils literal notranslate"><span class="pre">Store</span></code></a> or <a class="reference internal" href="#ast.Del" title="ast.Del"><code class="xref py py-class docutils literal notranslate"><span class="pre">Del</span></code></a>
|
||
according to the action performed with the subscript.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'l[1:2, 3]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Subscript(</span>
|
||
<span class="go"> value=Name(id='l', ctx=Load()),</span>
|
||
<span class="go"> slice=Tuple(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Slice(</span>
|
||
<span class="go"> lower=Constant(value=1),</span>
|
||
<span class="go"> upper=Constant(value=2)),</span>
|
||
<span class="go"> Constant(value=3)],</span>
|
||
<span class="go"> ctx=Load()),</span>
|
||
<span class="go"> ctx=Load()))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Slice">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Slice</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">lower</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">upper</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">step</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Slice" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Regular slicing (on the form <code class="docutils literal notranslate"><span class="pre">lower:upper</span></code> or <code class="docutils literal notranslate"><span class="pre">lower:upper:step</span></code>).
|
||
Can occur only inside the <em>slice</em> field of <a class="reference internal" href="#ast.Subscript" title="ast.Subscript"><code class="xref py py-class docutils literal notranslate"><span class="pre">Subscript</span></code></a>, either
|
||
directly or as an element of <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'l[1:2]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=Subscript(</span>
|
||
<span class="go"> value=Name(id='l', ctx=Load()),</span>
|
||
<span class="go"> slice=Slice(</span>
|
||
<span class="go"> lower=Constant(value=1),</span>
|
||
<span class="go"> upper=Constant(value=2)),</span>
|
||
<span class="go"> ctx=Load()))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="comprehensions">
|
||
<h4>Comprehensions<a class="headerlink" href="#comprehensions" title="Link to this heading">¶</a></h4>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.ListComp">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ListComp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elt</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">generators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ListComp" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.SetComp">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">SetComp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elt</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">generators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.SetComp" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.GeneratorExp">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">GeneratorExp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">elt</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">generators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.GeneratorExp" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.DictComp">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">DictComp</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">key</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">generators</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.DictComp" title="Link to this definition">¶</a></dt>
|
||
<dd><p>List and set comprehensions, generator expressions, and dictionary
|
||
comprehensions. <code class="docutils literal notranslate"><span class="pre">elt</span></code> (or <code class="docutils literal notranslate"><span class="pre">key</span></code> and <code class="docutils literal notranslate"><span class="pre">value</span></code>) is a single node
|
||
representing the part that will be evaluated for each item.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">generators</span></code> is a list of <a class="reference internal" href="#ast.comprehension" title="ast.comprehension"><code class="xref py py-class docutils literal notranslate"><span class="pre">comprehension</span></code></a> nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span>
|
||
<span class="gp">... </span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'[x for x in numbers]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span>
|
||
<span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>
|
||
<span class="gp">... </span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=ListComp(</span>
|
||
<span class="go"> elt=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> generators=[</span>
|
||
<span class="go"> comprehension(</span>
|
||
<span class="go"> target=Name(id='x', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='numbers', ctx=Load()),</span>
|
||
<span class="go"> is_async=0)]))</span>
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span>
|
||
<span class="gp">... </span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'{x: x**2 for x in numbers}'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span>
|
||
<span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>
|
||
<span class="gp">... </span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=DictComp(</span>
|
||
<span class="go"> key=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> value=BinOp(</span>
|
||
<span class="go"> left=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> op=Pow(),</span>
|
||
<span class="go"> right=Constant(value=2)),</span>
|
||
<span class="go"> generators=[</span>
|
||
<span class="go"> comprehension(</span>
|
||
<span class="go"> target=Name(id='x', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='numbers', ctx=Load()),</span>
|
||
<span class="go"> is_async=0)]))</span>
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span>
|
||
<span class="gp">... </span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'{x for x in numbers}'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span>
|
||
<span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>
|
||
<span class="gp">... </span><span class="p">))</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=SetComp(</span>
|
||
<span class="go"> elt=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> generators=[</span>
|
||
<span class="go"> comprehension(</span>
|
||
<span class="go"> target=Name(id='x', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='numbers', ctx=Load()),</span>
|
||
<span class="go"> is_async=0)]))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.comprehension">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">comprehension</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">iter</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">ifs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">is_async</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.comprehension" title="Link to this definition">¶</a></dt>
|
||
<dd><p>One <code class="docutils literal notranslate"><span class="pre">for</span></code> clause in a comprehension. <code class="docutils literal notranslate"><span class="pre">target</span></code> is the reference to use for
|
||
each element - typically a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> or <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> node. <code class="docutils literal notranslate"><span class="pre">iter</span></code>
|
||
is the object to iterate over. <code class="docutils literal notranslate"><span class="pre">ifs</span></code> is a list of test expressions: each
|
||
<code class="docutils literal notranslate"><span class="pre">for</span></code> clause can have multiple <code class="docutils literal notranslate"><span class="pre">ifs</span></code>.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">is_async</span></code> indicates a comprehension is asynchronous (using an
|
||
<code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">for</span></code> instead of <code class="docutils literal notranslate"><span class="pre">for</span></code>). The value is an integer (0 or 1).</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'[ord(c) for line in file for c in line]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span>
|
||
<span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Multiple comprehensions in one.</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=ListComp(</span>
|
||
<span class="go"> elt=Call(</span>
|
||
<span class="go"> func=Name(id='ord', ctx=Load()),</span>
|
||
<span class="go"> args=[</span>
|
||
<span class="go"> Name(id='c', ctx=Load())]),</span>
|
||
<span class="go"> generators=[</span>
|
||
<span class="go"> comprehension(</span>
|
||
<span class="go"> target=Name(id='line', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='file', ctx=Load()),</span>
|
||
<span class="go"> is_async=0),</span>
|
||
<span class="go"> comprehension(</span>
|
||
<span class="go"> target=Name(id='c', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='line', ctx=Load()),</span>
|
||
<span class="go"> is_async=0)]))</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(n**2 for n in it if n>5 if n<10)'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span>
|
||
<span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># generator comprehension</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=GeneratorExp(</span>
|
||
<span class="go"> elt=BinOp(</span>
|
||
<span class="go"> left=Name(id='n', ctx=Load()),</span>
|
||
<span class="go"> op=Pow(),</span>
|
||
<span class="go"> right=Constant(value=2)),</span>
|
||
<span class="go"> generators=[</span>
|
||
<span class="go"> comprehension(</span>
|
||
<span class="go"> target=Name(id='n', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='it', ctx=Load()),</span>
|
||
<span class="go"> ifs=[</span>
|
||
<span class="go"> Compare(</span>
|
||
<span class="go"> left=Name(id='n', ctx=Load()),</span>
|
||
<span class="go"> ops=[</span>
|
||
<span class="go"> Gt()],</span>
|
||
<span class="go"> comparators=[</span>
|
||
<span class="go"> Constant(value=5)]),</span>
|
||
<span class="go"> Compare(</span>
|
||
<span class="go"> left=Name(id='n', ctx=Load()),</span>
|
||
<span class="go"> ops=[</span>
|
||
<span class="go"> Lt()],</span>
|
||
<span class="go"> comparators=[</span>
|
||
<span class="go"> Constant(value=10)])],</span>
|
||
<span class="go"> is_async=0)]))</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'[i async for i in soc]'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">),</span>
|
||
<span class="gp">... </span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Async comprehension</span>
|
||
<span class="go">Expression(</span>
|
||
<span class="go"> body=ListComp(</span>
|
||
<span class="go"> elt=Name(id='i', ctx=Load()),</span>
|
||
<span class="go"> generators=[</span>
|
||
<span class="go"> comprehension(</span>
|
||
<span class="go"> target=Name(id='i', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='soc', ctx=Load()),</span>
|
||
<span class="go"> is_async=1)]))</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
</section>
|
||
<section id="statements">
|
||
<span id="ast-statements"></span><h3>Statements<a class="headerlink" href="#statements" title="Link to this heading">¶</a></h3>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Assign">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Assign</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">targets</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Assign" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An assignment. <code class="docutils literal notranslate"><span class="pre">targets</span></code> is a list of nodes, and <code class="docutils literal notranslate"><span class="pre">value</span></code> is a single node.</p>
|
||
<p>Multiple nodes in <code class="docutils literal notranslate"><span class="pre">targets</span></code> represents assigning the same value to each.
|
||
Unpacking is represented by putting a <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> or <a class="reference internal" href="#ast.List" title="ast.List"><code class="xref py py-class docutils literal notranslate"><span class="pre">List</span></code></a>
|
||
within <code class="docutils literal notranslate"><span class="pre">targets</span></code>.</p>
|
||
<dl class="py attribute">
|
||
<dt class="sig sig-object py" id="ast.Assign.type_comment">
|
||
<span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.Assign.type_comment" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment.</p>
|
||
</dd></dl>
|
||
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a = b = 1'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Multiple assignment</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Assign(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Name(id='a', ctx=Store()),</span>
|
||
<span class="go"> Name(id='b', ctx=Store())],</span>
|
||
<span class="go"> value=Constant(value=1))])</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a,b = c'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Unpacking</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Assign(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Tuple(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Name(id='a', ctx=Store()),</span>
|
||
<span class="go"> Name(id='b', ctx=Store())],</span>
|
||
<span class="go"> ctx=Store())],</span>
|
||
<span class="go"> value=Name(id='c', ctx=Load()))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.AnnAssign">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AnnAssign</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">annotation</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">simple</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AnnAssign" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An assignment with a type annotation. <code class="docutils literal notranslate"><span class="pre">target</span></code> is a single node and can
|
||
be a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, an <a class="reference internal" href="#ast.Attribute" title="ast.Attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">Attribute</span></code></a> or a <a class="reference internal" href="#ast.Subscript" title="ast.Subscript"><code class="xref py py-class docutils literal notranslate"><span class="pre">Subscript</span></code></a>.
|
||
<code class="docutils literal notranslate"><span class="pre">annotation</span></code> is the annotation, such as a <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a> or <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. <code class="docutils literal notranslate"><span class="pre">value</span></code> is a single optional node.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">simple</span></code> is always either 0 (indicating a “complex” target) or 1
|
||
(indicating a “simple” target). A “simple” target consists solely of a
|
||
<a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node that does not appear between parentheses; all other
|
||
targets are considered complex. Only simple targets appear in
|
||
the <code class="xref py py-attr docutils literal notranslate"><span class="pre">__annotations__</span></code> dictionary of modules and classes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'c: int'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> AnnAssign(</span>
|
||
<span class="go"> target=Name(id='c', ctx=Store()),</span>
|
||
<span class="go"> annotation=Name(id='int', ctx=Load()),</span>
|
||
<span class="go"> simple=1)])</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'(a): int = 1'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Annotation with parenthesis</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> AnnAssign(</span>
|
||
<span class="go"> target=Name(id='a', ctx=Store()),</span>
|
||
<span class="go"> annotation=Name(id='int', ctx=Load()),</span>
|
||
<span class="go"> value=Constant(value=1),</span>
|
||
<span class="go"> simple=0)])</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a.b: int'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Attribute annotation</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> AnnAssign(</span>
|
||
<span class="go"> target=Attribute(</span>
|
||
<span class="go"> value=Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> attr='b',</span>
|
||
<span class="go"> ctx=Store()),</span>
|
||
<span class="go"> annotation=Name(id='int', ctx=Load()),</span>
|
||
<span class="go"> simple=0)])</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'a[1]: int'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span> <span class="c1"># Subscript annotation</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> AnnAssign(</span>
|
||
<span class="go"> target=Subscript(</span>
|
||
<span class="go"> value=Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> slice=Constant(value=1),</span>
|
||
<span class="go"> ctx=Store()),</span>
|
||
<span class="go"> annotation=Name(id='int', ctx=Load()),</span>
|
||
<span class="go"> simple=0)])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.AugAssign">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AugAssign</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AugAssign" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Augmented assignment, such as <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">+=</span> <span class="pre">1</span></code>. In the following example,
|
||
<code class="docutils literal notranslate"><span class="pre">target</span></code> is a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node for <code class="docutils literal notranslate"><span class="pre">x</span></code> (with the <a class="reference internal" href="#ast.Store" title="ast.Store"><code class="xref py py-class docutils literal notranslate"><span class="pre">Store</span></code></a>
|
||
context), <code class="docutils literal notranslate"><span class="pre">op</span></code> is <a class="reference internal" href="#ast.Add" title="ast.Add"><code class="xref py py-class docutils literal notranslate"><span class="pre">Add</span></code></a>, and <code class="docutils literal notranslate"><span class="pre">value</span></code> is a <a class="reference internal" href="#ast.Constant" title="ast.Constant"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constant</span></code></a> with
|
||
value for 1.</p>
|
||
<p>The <code class="docutils literal notranslate"><span class="pre">target</span></code> attribute cannot be of class <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> or <a class="reference internal" href="#ast.List" title="ast.List"><code class="xref py py-class docutils literal notranslate"><span class="pre">List</span></code></a>,
|
||
unlike the targets of <a class="reference internal" href="#ast.Assign" title="ast.Assign"><code class="xref py py-class docutils literal notranslate"><span class="pre">Assign</span></code></a>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'x += 2'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> AugAssign(</span>
|
||
<span class="go"> target=Name(id='x', ctx=Store()),</span>
|
||
<span class="go"> op=Add(),</span>
|
||
<span class="go"> value=Constant(value=2))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Raise">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Raise</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">exc</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">cause</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Raise" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">raise</span></code> statement. <code class="docutils literal notranslate"><span class="pre">exc</span></code> is the exception object to be raised, normally a
|
||
<a class="reference internal" href="#ast.Call" title="ast.Call"><code class="xref py py-class docutils literal notranslate"><span class="pre">Call</span></code></a> or <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, or <code class="docutils literal notranslate"><span class="pre">None</span></code> for a standalone <code class="docutils literal notranslate"><span class="pre">raise</span></code>.
|
||
<code class="docutils literal notranslate"><span class="pre">cause</span></code> is the optional part for <code class="docutils literal notranslate"><span class="pre">y</span></code> in <code class="docutils literal notranslate"><span class="pre">raise</span> <span class="pre">x</span> <span class="pre">from</span> <span class="pre">y</span></code>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'raise x from y'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Raise(</span>
|
||
<span class="go"> exc=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cause=Name(id='y', ctx=Load()))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Assert">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Assert</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">test</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">msg</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Assert" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An assertion. <code class="docutils literal notranslate"><span class="pre">test</span></code> holds the condition, such as a <a class="reference internal" href="#ast.Compare" title="ast.Compare"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compare</span></code></a> node.
|
||
<code class="docutils literal notranslate"><span class="pre">msg</span></code> holds the failure message.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'assert x,y'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Assert(</span>
|
||
<span class="go"> test=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> msg=Name(id='y', ctx=Load()))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Delete">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Delete</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">targets</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Delete" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Represents a <code class="docutils literal notranslate"><span class="pre">del</span></code> statement. <code class="docutils literal notranslate"><span class="pre">targets</span></code> is a list of nodes, such as
|
||
<a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, <a class="reference internal" href="#ast.Attribute" title="ast.Attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">Attribute</span></code></a> or <a class="reference internal" href="#ast.Subscript" title="ast.Subscript"><code class="xref py py-class docutils literal notranslate"><span class="pre">Subscript</span></code></a> nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'del x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Delete(</span>
|
||
<span class="go"> targets=[</span>
|
||
<span class="go"> Name(id='x', ctx=Del()),</span>
|
||
<span class="go"> Name(id='y', ctx=Del()),</span>
|
||
<span class="go"> Name(id='z', ctx=Del())])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Pass">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Pass</span></span><a class="headerlink" href="#ast.Pass" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">pass</span></code> statement.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'pass'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Pass()])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.TypeAlias">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TypeAlias</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_params</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TypeAlias" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="typing.html#type-aliases"><span class="std std-ref">type alias</span></a> created through the <a class="reference internal" href="../reference/simple_stmts.html#type"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">type</span></code></a>
|
||
statement. <code class="docutils literal notranslate"><span class="pre">name</span></code> is the name of the alias, <code class="docutils literal notranslate"><span class="pre">type_params</span></code> is a list of
|
||
<a class="reference internal" href="#ast-type-params"><span class="std std-ref">type parameters</span></a>, and <code class="docutils literal notranslate"><span class="pre">value</span></code> is the value of the
|
||
type alias.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'type Alias = int'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> TypeAlias(</span>
|
||
<span class="go"> name=Name(id='Alias', ctx=Store()),</span>
|
||
<span class="go"> value=Name(id='int', ctx=Load()))])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.12.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<p>Other statements which are only applicable inside functions or loops are
|
||
described in other sections.</p>
|
||
<section id="imports">
|
||
<h4>Imports<a class="headerlink" href="#imports" title="Link to this heading">¶</a></h4>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Import">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Import</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">names</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Import" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An import statement. <code class="docutils literal notranslate"><span class="pre">names</span></code> is a list of <a class="reference internal" href="#ast.alias" title="ast.alias"><code class="xref py py-class docutils literal notranslate"><span class="pre">alias</span></code></a> nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'import x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Import(</span>
|
||
<span class="go"> names=[</span>
|
||
<span class="go"> alias(name='x'),</span>
|
||
<span class="go"> alias(name='y'),</span>
|
||
<span class="go"> alias(name='z')])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.ImportFrom">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ImportFrom</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">module</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">names</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">level</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ImportFrom" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Represents <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">x</span> <span class="pre">import</span> <span class="pre">y</span></code>. <code class="docutils literal notranslate"><span class="pre">module</span></code> is a raw string of the ‘from’ name,
|
||
without any leading dots, or <code class="docutils literal notranslate"><span class="pre">None</span></code> for statements such as <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">.</span> <span class="pre">import</span> <span class="pre">foo</span></code>.
|
||
<code class="docutils literal notranslate"><span class="pre">level</span></code> is an integer holding the level of the relative import (0 means
|
||
absolute import).</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'from y import x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> ImportFrom(</span>
|
||
<span class="go"> module='y',</span>
|
||
<span class="go"> names=[</span>
|
||
<span class="go"> alias(name='x'),</span>
|
||
<span class="go"> alias(name='y'),</span>
|
||
<span class="go"> alias(name='z')],</span>
|
||
<span class="go"> level=0)])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.alias">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">alias</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">asname</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.alias" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Both parameters are raw strings of the names. <code class="docutils literal notranslate"><span class="pre">asname</span></code> can be <code class="docutils literal notranslate"><span class="pre">None</span></code> if
|
||
the regular name is to be used.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'from ..foo.bar import a as b, c'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> ImportFrom(</span>
|
||
<span class="go"> module='foo.bar',</span>
|
||
<span class="go"> names=[</span>
|
||
<span class="go"> alias(name='a', asname='b'),</span>
|
||
<span class="go"> alias(name='c')],</span>
|
||
<span class="go"> level=2)])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
</section>
|
||
<section id="control-flow">
|
||
<h3>Control flow<a class="headerlink" href="#control-flow" title="Link to this heading">¶</a></h3>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>Optional clauses such as <code class="docutils literal notranslate"><span class="pre">else</span></code> are stored as an empty list if they’re
|
||
not present.</p>
|
||
</div>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.If">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">If</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">test</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.If" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An <code class="docutils literal notranslate"><span class="pre">if</span></code> statement. <code class="docutils literal notranslate"><span class="pre">test</span></code> holds a single node, such as a <a class="reference internal" href="#ast.Compare" title="ast.Compare"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compare</span></code></a>
|
||
node. <code class="docutils literal notranslate"><span class="pre">body</span></code> and <code class="docutils literal notranslate"><span class="pre">orelse</span></code> each hold a list of nodes.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">elif</span></code> clauses don’t have a special representation in the AST, but rather
|
||
appear as extra <a class="reference internal" href="#ast.If" title="ast.If"><code class="xref py py-class docutils literal notranslate"><span class="pre">If</span></code></a> nodes within the <code class="docutils literal notranslate"><span class="pre">orelse</span></code> section of the
|
||
previous one.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">if x:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">elif y:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">else:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> If(</span>
|
||
<span class="go"> test=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))],</span>
|
||
<span class="go"> orelse=[</span>
|
||
<span class="go"> If(</span>
|
||
<span class="go"> test=Name(id='y', ctx=Load()),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))],</span>
|
||
<span class="go"> orelse=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.For">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">For</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">iter</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.For" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">for</span></code> loop. <code class="docutils literal notranslate"><span class="pre">target</span></code> holds the variable(s) the loop assigns to, as a
|
||
single <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>, <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a>, <a class="reference internal" href="#ast.List" title="ast.List"><code class="xref py py-class docutils literal notranslate"><span class="pre">List</span></code></a>, <a class="reference internal" href="#ast.Attribute" title="ast.Attribute"><code class="xref py py-class docutils literal notranslate"><span class="pre">Attribute</span></code></a> or
|
||
<a class="reference internal" href="#ast.Subscript" title="ast.Subscript"><code class="xref py py-class docutils literal notranslate"><span class="pre">Subscript</span></code></a> node. <code class="docutils literal notranslate"><span class="pre">iter</span></code> holds the item to be looped over, again
|
||
as a single node. <code class="docutils literal notranslate"><span class="pre">body</span></code> and <code class="docutils literal notranslate"><span class="pre">orelse</span></code> contain lists of nodes to execute.
|
||
Those in <code class="docutils literal notranslate"><span class="pre">orelse</span></code> are executed if the loop finishes normally, rather than
|
||
via a <code class="docutils literal notranslate"><span class="pre">break</span></code> statement.</p>
|
||
<dl class="py attribute">
|
||
<dt class="sig sig-object py" id="ast.For.type_comment">
|
||
<span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.For.type_comment" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment.</p>
|
||
</dd></dl>
|
||
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">for x in y:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">else:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> For(</span>
|
||
<span class="go"> target=Name(id='x', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='y', ctx=Load()),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))],</span>
|
||
<span class="go"> orelse=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.While">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">While</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">test</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.While" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">while</span></code> loop. <code class="docutils literal notranslate"><span class="pre">test</span></code> holds the condition, such as a <a class="reference internal" href="#ast.Compare" title="ast.Compare"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compare</span></code></a>
|
||
node.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="go">>> print(ast.dump(ast.parse("""</span>
|
||
<span class="go">... while x:</span>
|
||
<span class="go">... ...</span>
|
||
<span class="go">... else:</span>
|
||
<span class="go">... ...</span>
|
||
<span class="go">... """), indent=4))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> While(</span>
|
||
<span class="go"> test=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))],</span>
|
||
<span class="go"> orelse=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Break">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Break</span></span><a class="headerlink" href="#ast.Break" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Continue">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Continue</span></span><a class="headerlink" href="#ast.Continue" title="Link to this definition">¶</a></dt>
|
||
<dd><p>The <code class="docutils literal notranslate"><span class="pre">break</span></code> and <code class="docutils literal notranslate"><span class="pre">continue</span></code> statements.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span>
|
||
<span class="gp">... </span><span class="s2">for a in b:</span>
|
||
<span class="gp">... </span><span class="s2"> if a > 5:</span>
|
||
<span class="gp">... </span><span class="s2"> break</span>
|
||
<span class="gp">... </span><span class="s2"> else:</span>
|
||
<span class="gp">... </span><span class="s2"> continue</span>
|
||
<span class="gp">...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> For(</span>
|
||
<span class="go"> target=Name(id='a', ctx=Store()),</span>
|
||
<span class="go"> iter=Name(id='b', ctx=Load()),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> If(</span>
|
||
<span class="go"> test=Compare(</span>
|
||
<span class="go"> left=Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> ops=[</span>
|
||
<span class="go"> Gt()],</span>
|
||
<span class="go"> comparators=[</span>
|
||
<span class="go"> Constant(value=5)]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Break()],</span>
|
||
<span class="go"> orelse=[</span>
|
||
<span class="go"> Continue()])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Try">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Try</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">handlers</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">finalbody</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Try" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">try</span></code> blocks. All attributes are list of nodes to execute, except for
|
||
<code class="docutils literal notranslate"><span class="pre">handlers</span></code>, which is a list of <a class="reference internal" href="#ast.ExceptHandler" title="ast.ExceptHandler"><code class="xref py py-class docutils literal notranslate"><span class="pre">ExceptHandler</span></code></a> nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">try:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">except Exception:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">except OtherException as e:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">else:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">finally:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Try(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))],</span>
|
||
<span class="go"> handlers=[</span>
|
||
<span class="go"> ExceptHandler(</span>
|
||
<span class="go"> type=Name(id='Exception', ctx=Load()),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))]),</span>
|
||
<span class="go"> ExceptHandler(</span>
|
||
<span class="go"> type=Name(id='OtherException', ctx=Load()),</span>
|
||
<span class="go"> name='e',</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])],</span>
|
||
<span class="go"> orelse=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))],</span>
|
||
<span class="go"> finalbody=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.TryStar">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TryStar</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">handlers</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">finalbody</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TryStar" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">try</span></code> blocks which are followed by <code class="docutils literal notranslate"><span class="pre">except*</span></code> clauses. The attributes are the
|
||
same as for <a class="reference internal" href="#ast.Try" title="ast.Try"><code class="xref py py-class docutils literal notranslate"><span class="pre">Try</span></code></a> but the <a class="reference internal" href="#ast.ExceptHandler" title="ast.ExceptHandler"><code class="xref py py-class docutils literal notranslate"><span class="pre">ExceptHandler</span></code></a> nodes in <code class="docutils literal notranslate"><span class="pre">handlers</span></code>
|
||
are interpreted as <code class="docutils literal notranslate"><span class="pre">except*</span></code> blocks rather then <code class="docutils literal notranslate"><span class="pre">except</span></code>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">try:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">except* Exception:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> TryStar(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))],</span>
|
||
<span class="go"> handlers=[</span>
|
||
<span class="go"> ExceptHandler(</span>
|
||
<span class="go"> type=Name(id='Exception', ctx=Load()),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.11.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.ExceptHandler">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ExceptHandler</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">type</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ExceptHandler" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A single <code class="docutils literal notranslate"><span class="pre">except</span></code> clause. <code class="docutils literal notranslate"><span class="pre">type</span></code> is the exception type it will match,
|
||
typically a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node (or <code class="docutils literal notranslate"><span class="pre">None</span></code> for a catch-all <code class="docutils literal notranslate"><span class="pre">except:</span></code> clause).
|
||
<code class="docutils literal notranslate"><span class="pre">name</span></code> is a raw string for the name to hold the exception, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if
|
||
the clause doesn’t have <code class="docutils literal notranslate"><span class="pre">as</span> <span class="pre">foo</span></code>. <code class="docutils literal notranslate"><span class="pre">body</span></code> is a list of nodes.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span>
|
||
<span class="gp">... </span><span class="s2">try:</span>
|
||
<span class="gp">... </span><span class="s2"> a + 1</span>
|
||
<span class="gp">... </span><span class="s2">except TypeError:</span>
|
||
<span class="gp">... </span><span class="s2"> pass</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Try(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=BinOp(</span>
|
||
<span class="go"> left=Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> op=Add(),</span>
|
||
<span class="go"> right=Constant(value=1)))],</span>
|
||
<span class="go"> handlers=[</span>
|
||
<span class="go"> ExceptHandler(</span>
|
||
<span class="go"> type=Name(id='TypeError', ctx=Load()),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Pass()])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.With">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">With</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">items</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.With" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">with</span></code> block. <code class="docutils literal notranslate"><span class="pre">items</span></code> is a list of <a class="reference internal" href="#ast.withitem" title="ast.withitem"><code class="xref py py-class docutils literal notranslate"><span class="pre">withitem</span></code></a> nodes representing
|
||
the context managers, and <code class="docutils literal notranslate"><span class="pre">body</span></code> is the indented block inside the context.</p>
|
||
<dl class="py attribute">
|
||
<dt class="sig sig-object py" id="ast.With.type_comment">
|
||
<span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.With.type_comment" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment.</p>
|
||
</dd></dl>
|
||
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.withitem">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">withitem</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">context_expr</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">optional_vars</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.withitem" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A single context manager in a <code class="docutils literal notranslate"><span class="pre">with</span></code> block. <code class="docutils literal notranslate"><span class="pre">context_expr</span></code> is the context
|
||
manager, often a <a class="reference internal" href="#ast.Call" title="ast.Call"><code class="xref py py-class docutils literal notranslate"><span class="pre">Call</span></code></a> node. <code class="docutils literal notranslate"><span class="pre">optional_vars</span></code> is a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a>,
|
||
<a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a> or <a class="reference internal" href="#ast.List" title="ast.List"><code class="xref py py-class docutils literal notranslate"><span class="pre">List</span></code></a> for the <code class="docutils literal notranslate"><span class="pre">as</span> <span class="pre">foo</span></code> part, or <code class="docutils literal notranslate"><span class="pre">None</span></code> if that
|
||
isn’t used.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span>
|
||
<span class="gp">... </span><span class="s2">with a as b, c as d:</span>
|
||
<span class="gp">... </span><span class="s2"> something(b, d)</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> With(</span>
|
||
<span class="go"> items=[</span>
|
||
<span class="go"> withitem(</span>
|
||
<span class="go"> context_expr=Name(id='a', ctx=Load()),</span>
|
||
<span class="go"> optional_vars=Name(id='b', ctx=Store())),</span>
|
||
<span class="go"> withitem(</span>
|
||
<span class="go"> context_expr=Name(id='c', ctx=Load()),</span>
|
||
<span class="go"> optional_vars=Name(id='d', ctx=Store()))],</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Call(</span>
|
||
<span class="go"> func=Name(id='something', ctx=Load()),</span>
|
||
<span class="go"> args=[</span>
|
||
<span class="go"> Name(id='b', ctx=Load()),</span>
|
||
<span class="go"> Name(id='d', ctx=Load())]))])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="pattern-matching">
|
||
<h3>Pattern matching<a class="headerlink" href="#pattern-matching" title="Link to this heading">¶</a></h3>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Match">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Match</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subject</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">cases</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Match" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">match</span></code> statement. <code class="docutils literal notranslate"><span class="pre">subject</span></code> holds the subject of the match (the object
|
||
that is being matched against the cases) and <code class="docutils literal notranslate"><span class="pre">cases</span></code> contains an iterable of
|
||
<a class="reference internal" href="#ast.match_case" title="ast.match_case"><code class="xref py py-class docutils literal notranslate"><span class="pre">match_case</span></code></a> nodes with the different cases.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.match_case">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">match_case</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">pattern</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">guard</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.match_case" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A single case pattern in a <code class="docutils literal notranslate"><span class="pre">match</span></code> statement. <code class="docutils literal notranslate"><span class="pre">pattern</span></code> contains the
|
||
match pattern that the subject will be matched against. Note that the
|
||
<a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">AST</span></code></a> nodes produced for patterns differ from those produced for
|
||
expressions, even when they share the same syntax.</p>
|
||
<p>The <code class="docutils literal notranslate"><span class="pre">guard</span></code> attribute contains an expression that will be evaluated if
|
||
the pattern matches the subject.</p>
|
||
<p><code class="docutils literal notranslate"><span class="pre">body</span></code> contains a list of nodes to execute if the pattern matches and
|
||
the result of evaluating the guard expression is true.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case [x] if x>0:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2"> case tuple():</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchSequence(</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchAs(name='x')]),</span>
|
||
<span class="go"> guard=Compare(</span>
|
||
<span class="go"> left=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> ops=[</span>
|
||
<span class="go"> Gt()],</span>
|
||
<span class="go"> comparators=[</span>
|
||
<span class="go"> Constant(value=0)]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))]),</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchClass(</span>
|
||
<span class="go"> cls=Name(id='tuple', ctx=Load())),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.MatchValue">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchValue</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchValue" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A match literal or value pattern that compares by equality. <code class="docutils literal notranslate"><span class="pre">value</span></code> is
|
||
an expression node. Permitted value nodes are restricted as described in
|
||
the match statement documentation. This pattern succeeds if the match
|
||
subject is equal to the evaluated value.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case "Relevant":</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchValue(</span>
|
||
<span class="go"> value=Constant(value='Relevant')),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.MatchSingleton">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchSingleton</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchSingleton" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A match literal pattern that compares by identity. <code class="docutils literal notranslate"><span class="pre">value</span></code> is the
|
||
singleton to be compared against: <code class="docutils literal notranslate"><span class="pre">None</span></code>, <code class="docutils literal notranslate"><span class="pre">True</span></code>, or <code class="docutils literal notranslate"><span class="pre">False</span></code>. This
|
||
pattern succeeds if the match subject is the given constant.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case None:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchSingleton(value=None),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.MatchSequence">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchSequence</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">patterns</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchSequence" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A match sequence pattern. <code class="docutils literal notranslate"><span class="pre">patterns</span></code> contains the patterns to be matched
|
||
against the subject elements if the subject is a sequence. Matches a variable
|
||
length sequence if one of the subpatterns is a <code class="docutils literal notranslate"><span class="pre">MatchStar</span></code> node, otherwise
|
||
matches a fixed length sequence.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case [1, 2]:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchSequence(</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=1)),</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=2))]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.MatchStar">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchStar</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchStar" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Matches the rest of the sequence in a variable length match sequence pattern.
|
||
If <code class="docutils literal notranslate"><span class="pre">name</span></code> is not <code class="docutils literal notranslate"><span class="pre">None</span></code>, a list containing the remaining sequence
|
||
elements is bound to that name if the overall sequence pattern is successful.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case [1, 2, *rest]:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2"> case [*_]:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchSequence(</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=1)),</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=2)),</span>
|
||
<span class="go"> MatchStar(name='rest')]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))]),</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchSequence(</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchStar()]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.MatchMapping">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchMapping</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">keys</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">patterns</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">rest</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchMapping" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A match mapping pattern. <code class="docutils literal notranslate"><span class="pre">keys</span></code> is a sequence of expression nodes.
|
||
<code class="docutils literal notranslate"><span class="pre">patterns</span></code> is a corresponding sequence of pattern nodes. <code class="docutils literal notranslate"><span class="pre">rest</span></code> is an
|
||
optional name that can be specified to capture the remaining mapping elements.
|
||
Permitted key expressions are restricted as described in the match statement
|
||
documentation.</p>
|
||
<p>This pattern succeeds if the subject is a mapping, all evaluated key
|
||
expressions are present in the mapping, and the value corresponding to each
|
||
key matches the corresponding subpattern. If <code class="docutils literal notranslate"><span class="pre">rest</span></code> is not <code class="docutils literal notranslate"><span class="pre">None</span></code>, a dict
|
||
containing the remaining mapping elements is bound to that name if the overall
|
||
mapping pattern is successful.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case {1: _, 2: _}:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2"> case {**rest}:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchMapping(</span>
|
||
<span class="go"> keys=[</span>
|
||
<span class="go"> Constant(value=1),</span>
|
||
<span class="go"> Constant(value=2)],</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchAs(),</span>
|
||
<span class="go"> MatchAs()]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))]),</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchMapping(rest='rest'),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.MatchClass">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchClass</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">cls</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">patterns</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwd_attrs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwd_patterns</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchClass" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A match class pattern. <code class="docutils literal notranslate"><span class="pre">cls</span></code> is an expression giving the nominal class to
|
||
be matched. <code class="docutils literal notranslate"><span class="pre">patterns</span></code> is a sequence of pattern nodes to be matched against
|
||
the class defined sequence of pattern matching attributes. <code class="docutils literal notranslate"><span class="pre">kwd_attrs</span></code> is a
|
||
sequence of additional attributes to be matched (specified as keyword arguments
|
||
in the class pattern), <code class="docutils literal notranslate"><span class="pre">kwd_patterns</span></code> are the corresponding patterns
|
||
(specified as keyword values in the class pattern).</p>
|
||
<p>This pattern succeeds if the subject is an instance of the nominated class,
|
||
all positional patterns match the corresponding class-defined attributes, and
|
||
any specified keyword attributes match their corresponding pattern.</p>
|
||
<p>Note: classes may define a property that returns self in order to match a
|
||
pattern node against the instance being matched. Several builtin types are
|
||
also matched that way, as described in the match statement documentation.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case Point2D(0, 0):</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2"> case Point3D(x=0, y=0, z=0):</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchClass(</span>
|
||
<span class="go"> cls=Name(id='Point2D', ctx=Load()),</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=0)),</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=0))]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))]),</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchClass(</span>
|
||
<span class="go"> cls=Name(id='Point3D', ctx=Load()),</span>
|
||
<span class="go"> kwd_attrs=[</span>
|
||
<span class="go"> 'x',</span>
|
||
<span class="go"> 'y',</span>
|
||
<span class="go"> 'z'],</span>
|
||
<span class="go"> kwd_patterns=[</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=0)),</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=0)),</span>
|
||
<span class="go"> MatchValue(</span>
|
||
<span class="go"> value=Constant(value=0))]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.MatchAs">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchAs</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">pattern</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchAs" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A match “as-pattern”, capture pattern or wildcard pattern. <code class="docutils literal notranslate"><span class="pre">pattern</span></code>
|
||
contains the match pattern that the subject will be matched against.
|
||
If the pattern is <code class="docutils literal notranslate"><span class="pre">None</span></code>, the node represents a capture pattern (i.e a
|
||
bare name) and will always succeed.</p>
|
||
<p>The <code class="docutils literal notranslate"><span class="pre">name</span></code> attribute contains the name that will be bound if the pattern
|
||
is successful. If <code class="docutils literal notranslate"><span class="pre">name</span></code> is <code class="docutils literal notranslate"><span class="pre">None</span></code>, <code class="docutils literal notranslate"><span class="pre">pattern</span></code> must also be <code class="docutils literal notranslate"><span class="pre">None</span></code>
|
||
and the node represents the wildcard pattern.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case [x] as y:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2"> case _:</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchAs(</span>
|
||
<span class="go"> pattern=MatchSequence(</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchAs(name='x')]),</span>
|
||
<span class="go"> name='y'),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))]),</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchAs(),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.MatchOr">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">MatchOr</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">patterns</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.MatchOr" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A match “or-pattern”. An or-pattern matches each of its subpatterns in turn
|
||
to the subject, until one succeeds. The or-pattern is then deemed to
|
||
succeed. If none of the subpatterns succeed the or-pattern fails. The
|
||
<code class="docutils literal notranslate"><span class="pre">patterns</span></code> attribute contains a list of match pattern nodes that will be
|
||
matched against the subject.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span>
|
||
<span class="gp">... </span><span class="s2">match x:</span>
|
||
<span class="gp">... </span><span class="s2"> case [x] | (y):</span>
|
||
<span class="gp">... </span><span class="s2"> ...</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Match(</span>
|
||
<span class="go"> subject=Name(id='x', ctx=Load()),</span>
|
||
<span class="go"> cases=[</span>
|
||
<span class="go"> match_case(</span>
|
||
<span class="go"> pattern=MatchOr(</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchSequence(</span>
|
||
<span class="go"> patterns=[</span>
|
||
<span class="go"> MatchAs(name='x')]),</span>
|
||
<span class="go"> MatchAs(name='y')]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Constant(value=Ellipsis))])])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.10.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="type-parameters">
|
||
<span id="ast-type-params"></span><h3>Type parameters<a class="headerlink" href="#type-parameters" title="Link to this heading">¶</a></h3>
|
||
<p><a class="reference internal" href="../reference/compound_stmts.html#type-params"><span class="std std-ref">Type parameters</span></a> can exist on classes, functions, and type
|
||
aliases.</p>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.TypeVar">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TypeVar</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">bound</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">default_value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TypeVar" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="typing.html#typing.TypeVar" title="typing.TypeVar"><code class="xref py py-class docutils literal notranslate"><span class="pre">typing.TypeVar</span></code></a>. <code class="docutils literal notranslate"><span class="pre">name</span></code> is the name of the type variable.
|
||
<code class="docutils literal notranslate"><span class="pre">bound</span></code> is the bound or constraints, if any. If <code class="docutils literal notranslate"><span class="pre">bound</span></code> is a <a class="reference internal" href="#ast.Tuple" title="ast.Tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tuple</span></code></a>,
|
||
it represents constraints; otherwise it represents the bound. <code class="docutils literal notranslate"><span class="pre">default_value</span></code>
|
||
is the default value; if the <code class="xref py py-class docutils literal notranslate"><span class="pre">TypeVar</span></code> has no default, this
|
||
attribute will be set to <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"type Alias[T: int = bool] = list[T]"</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> TypeAlias(</span>
|
||
<span class="go"> name=Name(id='Alias', ctx=Store()),</span>
|
||
<span class="go"> type_params=[</span>
|
||
<span class="go"> TypeVar(</span>
|
||
<span class="go"> name='T',</span>
|
||
<span class="go"> bound=Name(id='int', ctx=Load()),</span>
|
||
<span class="go"> default_value=Name(id='bool', ctx=Load()))],</span>
|
||
<span class="go"> value=Subscript(</span>
|
||
<span class="go"> value=Name(id='list', ctx=Load()),</span>
|
||
<span class="go"> slice=Name(id='T', ctx=Load()),</span>
|
||
<span class="go"> ctx=Load()))])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.12.</span></p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.13: </span>Added the <em>default_value</em> parameter.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.ParamSpec">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ParamSpec</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">default_value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ParamSpec" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="typing.html#typing.ParamSpec" title="typing.ParamSpec"><code class="xref py py-class docutils literal notranslate"><span class="pre">typing.ParamSpec</span></code></a>. <code class="docutils literal notranslate"><span class="pre">name</span></code> is the name of the parameter specification.
|
||
<code class="docutils literal notranslate"><span class="pre">default_value</span></code> is the default value; if the <code class="xref py py-class docutils literal notranslate"><span class="pre">ParamSpec</span></code> has no default,
|
||
this attribute will be set to <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"type Alias[**P = [int, str]] = Callable[P, int]"</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> TypeAlias(</span>
|
||
<span class="go"> name=Name(id='Alias', ctx=Store()),</span>
|
||
<span class="go"> type_params=[</span>
|
||
<span class="go"> ParamSpec(</span>
|
||
<span class="go"> name='P',</span>
|
||
<span class="go"> default_value=List(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Name(id='int', ctx=Load()),</span>
|
||
<span class="go"> Name(id='str', ctx=Load())],</span>
|
||
<span class="go"> ctx=Load()))],</span>
|
||
<span class="go"> value=Subscript(</span>
|
||
<span class="go"> value=Name(id='Callable', ctx=Load()),</span>
|
||
<span class="go"> slice=Tuple(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Name(id='P', ctx=Load()),</span>
|
||
<span class="go"> Name(id='int', ctx=Load())],</span>
|
||
<span class="go"> ctx=Load()),</span>
|
||
<span class="go"> ctx=Load()))])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.12.</span></p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.13: </span>Added the <em>default_value</em> parameter.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.TypeVarTuple">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">TypeVarTuple</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">default_value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.TypeVarTuple" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="typing.html#typing.TypeVarTuple" title="typing.TypeVarTuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">typing.TypeVarTuple</span></code></a>. <code class="docutils literal notranslate"><span class="pre">name</span></code> is the name of the type variable tuple.
|
||
<code class="docutils literal notranslate"><span class="pre">default_value</span></code> is the default value; if the <code class="xref py py-class docutils literal notranslate"><span class="pre">TypeVarTuple</span></code> has no
|
||
default, this attribute will be set to <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"type Alias[*Ts = ()] = tuple[*Ts]"</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> TypeAlias(</span>
|
||
<span class="go"> name=Name(id='Alias', ctx=Store()),</span>
|
||
<span class="go"> type_params=[</span>
|
||
<span class="go"> TypeVarTuple(</span>
|
||
<span class="go"> name='Ts',</span>
|
||
<span class="go"> default_value=Tuple(ctx=Load()))],</span>
|
||
<span class="go"> value=Subscript(</span>
|
||
<span class="go"> value=Name(id='tuple', ctx=Load()),</span>
|
||
<span class="go"> slice=Tuple(</span>
|
||
<span class="go"> elts=[</span>
|
||
<span class="go"> Starred(</span>
|
||
<span class="go"> value=Name(id='Ts', ctx=Load()),</span>
|
||
<span class="go"> ctx=Load())],</span>
|
||
<span class="go"> ctx=Load()),</span>
|
||
<span class="go"> ctx=Load()))])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.12.</span></p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.13: </span>Added the <em>default_value</em> parameter.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="function-and-class-definitions">
|
||
<h3>Function and class definitions<a class="headerlink" href="#function-and-class-definitions" title="Link to this heading">¶</a></h3>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.FunctionDef">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">FunctionDef</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">decorator_list</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">returns</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_params</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.FunctionDef" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A function definition.</p>
|
||
<ul class="simple">
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">name</span></code> is a raw string of the function name.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">args</span></code> is an <a class="reference internal" href="#ast.arguments" title="ast.arguments"><code class="xref py py-class docutils literal notranslate"><span class="pre">arguments</span></code></a> node.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">body</span></code> is the list of nodes inside the function.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">decorator_list</span></code> is the list of decorators to be applied, stored outermost
|
||
first (i.e. the first in the list will be applied last).</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">returns</span></code> is the return annotation.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">type_params</span></code> is a list of <a class="reference internal" href="#ast-type-params"><span class="std std-ref">type parameters</span></a>.</p></li>
|
||
</ul>
|
||
<dl class="py attribute">
|
||
<dt class="sig sig-object py" id="ast.FunctionDef.type_comment">
|
||
<span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.FunctionDef.type_comment" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment.</p>
|
||
</dd></dl>
|
||
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.12: </span>Added <code class="docutils literal notranslate"><span class="pre">type_params</span></code>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Lambda">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Lambda</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Lambda" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">lambda</span></code> is a minimal function definition that can be used inside an
|
||
expression. Unlike <a class="reference internal" href="#ast.FunctionDef" title="ast.FunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">FunctionDef</span></code></a>, <code class="docutils literal notranslate"><span class="pre">body</span></code> holds a single node.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'lambda x,y: ...'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Lambda(</span>
|
||
<span class="go"> args=arguments(</span>
|
||
<span class="go"> args=[</span>
|
||
<span class="go"> arg(arg='x'),</span>
|
||
<span class="go"> arg(arg='y')]),</span>
|
||
<span class="go"> body=Constant(value=Ellipsis)))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.arguments">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">arguments</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">posonlyargs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">vararg</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwonlyargs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kw_defaults</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwarg</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">defaults</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.arguments" title="Link to this definition">¶</a></dt>
|
||
<dd><p>The arguments for a function.</p>
|
||
<ul class="simple">
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">posonlyargs</span></code>, <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwonlyargs</span></code> are lists of <a class="reference internal" href="#ast.arg" title="ast.arg"><code class="xref py py-class docutils literal notranslate"><span class="pre">arg</span></code></a> nodes.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">vararg</span></code> and <code class="docutils literal notranslate"><span class="pre">kwarg</span></code> are single <a class="reference internal" href="#ast.arg" title="ast.arg"><code class="xref py py-class docutils literal notranslate"><span class="pre">arg</span></code></a> nodes, referring to the
|
||
<code class="docutils literal notranslate"><span class="pre">*args,</span> <span class="pre">**kwargs</span></code> parameters.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">kw_defaults</span></code> is a list of default values for keyword-only arguments. If
|
||
one is <code class="docutils literal notranslate"><span class="pre">None</span></code>, the corresponding argument is required.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">defaults</span></code> is a list of default values for arguments that can be passed
|
||
positionally. If there are fewer defaults, they correspond to the last n
|
||
arguments.</p></li>
|
||
</ul>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.arg">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">arg</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">arg</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">annotation</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.arg" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A single argument in a list. <code class="docutils literal notranslate"><span class="pre">arg</span></code> is a raw string of the argument
|
||
name; <code class="docutils literal notranslate"><span class="pre">annotation</span></code> is its annotation, such as a <a class="reference internal" href="#ast.Name" title="ast.Name"><code class="xref py py-class docutils literal notranslate"><span class="pre">Name</span></code></a> node.</p>
|
||
<dl class="py attribute">
|
||
<dt class="sig sig-object py" id="ast.arg.type_comment">
|
||
<span class="sig-name descname"><span class="pre">type_comment</span></span><a class="headerlink" href="#ast.arg.type_comment" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">type_comment</span></code> is an optional string with the type annotation as a comment</p>
|
||
</dd></dl>
|
||
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span>
|
||
<span class="gp">... </span><span class="s2">@decorator1</span>
|
||
<span class="gp">... </span><span class="s2">@decorator2</span>
|
||
<span class="gp">... </span><span class="s2">def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':</span>
|
||
<span class="gp">... </span><span class="s2"> pass</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> FunctionDef(</span>
|
||
<span class="go"> name='f',</span>
|
||
<span class="go"> args=arguments(</span>
|
||
<span class="go"> args=[</span>
|
||
<span class="go"> arg(</span>
|
||
<span class="go"> arg='a',</span>
|
||
<span class="go"> annotation=Constant(value='annotation')),</span>
|
||
<span class="go"> arg(arg='b'),</span>
|
||
<span class="go"> arg(arg='c')],</span>
|
||
<span class="go"> vararg=arg(arg='d'),</span>
|
||
<span class="go"> kwonlyargs=[</span>
|
||
<span class="go"> arg(arg='e'),</span>
|
||
<span class="go"> arg(arg='f')],</span>
|
||
<span class="go"> kw_defaults=[</span>
|
||
<span class="go"> None,</span>
|
||
<span class="go"> Constant(value=3)],</span>
|
||
<span class="go"> kwarg=arg(arg='g'),</span>
|
||
<span class="go"> defaults=[</span>
|
||
<span class="go"> Constant(value=1),</span>
|
||
<span class="go"> Constant(value=2)]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Pass()],</span>
|
||
<span class="go"> decorator_list=[</span>
|
||
<span class="go"> Name(id='decorator1', ctx=Load()),</span>
|
||
<span class="go"> Name(id='decorator2', ctx=Load())],</span>
|
||
<span class="go"> returns=Constant(value='return annotation'))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Return">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Return</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Return" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">return</span></code> statement.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'return 4'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Return(</span>
|
||
<span class="go"> value=Constant(value=4))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Yield">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Yield</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Yield" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.YieldFrom">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">YieldFrom</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.YieldFrom" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <code class="docutils literal notranslate"><span class="pre">yield</span></code> or <code class="docutils literal notranslate"><span class="pre">yield</span> <span class="pre">from</span></code> expression. Because these are expressions, they
|
||
must be wrapped in an <a class="reference internal" href="#ast.Expr" title="ast.Expr"><code class="xref py py-class docutils literal notranslate"><span class="pre">Expr</span></code></a> node if the value sent back is not used.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'yield x'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Yield(</span>
|
||
<span class="go"> value=Name(id='x', ctx=Load())))])</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'yield from x'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=YieldFrom(</span>
|
||
<span class="go"> value=Name(id='x', ctx=Load())))])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Global">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Global</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">names</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Global" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.Nonlocal">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Nonlocal</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">names</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Nonlocal" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">global</span></code> and <code class="docutils literal notranslate"><span class="pre">nonlocal</span></code> statements. <code class="docutils literal notranslate"><span class="pre">names</span></code> is a list of raw strings.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'global x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Global(</span>
|
||
<span class="go"> names=[</span>
|
||
<span class="go"> 'x',</span>
|
||
<span class="go"> 'y',</span>
|
||
<span class="go"> 'z'])])</span>
|
||
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'nonlocal x,y,z'</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Nonlocal(</span>
|
||
<span class="go"> names=[</span>
|
||
<span class="go"> 'x',</span>
|
||
<span class="go"> 'y',</span>
|
||
<span class="go"> 'z'])])</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.ClassDef">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">ClassDef</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">bases</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">keywords</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">decorator_list</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_params</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.ClassDef" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A class definition.</p>
|
||
<ul class="simple">
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">name</span></code> is a raw string for the class name</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">bases</span></code> is a list of nodes for explicitly specified base classes.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">keywords</span></code> is a list of <a class="reference internal" href="#ast.keyword" title="ast.keyword"><code class="xref py py-class docutils literal notranslate"><span class="pre">keyword</span></code></a> nodes, principally for ‘metaclass’.
|
||
Other keywords will be passed to the metaclass, as per <span class="target" id="index-3"></span><a class="pep reference external" href="https://peps.python.org/pep-3115/"><strong>PEP 3115</strong></a>.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">body</span></code> is a list of nodes representing the code within the class
|
||
definition.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">decorator_list</span></code> is a list of nodes, as in <a class="reference internal" href="#ast.FunctionDef" title="ast.FunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">FunctionDef</span></code></a>.</p></li>
|
||
<li><p><code class="docutils literal notranslate"><span class="pre">type_params</span></code> is a list of <a class="reference internal" href="#ast-type-params"><span class="std std-ref">type parameters</span></a>.</p></li>
|
||
</ul>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span>
|
||
<span class="gp">... </span><span class="s2">@decorator1</span>
|
||
<span class="gp">... </span><span class="s2">@decorator2</span>
|
||
<span class="gp">... </span><span class="s2">class Foo(base1, base2, metaclass=meta):</span>
|
||
<span class="gp">... </span><span class="s2"> pass</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> ClassDef(</span>
|
||
<span class="go"> name='Foo',</span>
|
||
<span class="go"> bases=[</span>
|
||
<span class="go"> Name(id='base1', ctx=Load()),</span>
|
||
<span class="go"> Name(id='base2', ctx=Load())],</span>
|
||
<span class="go"> keywords=[</span>
|
||
<span class="go"> keyword(</span>
|
||
<span class="go"> arg='metaclass',</span>
|
||
<span class="go"> value=Name(id='meta', ctx=Load()))],</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Pass()],</span>
|
||
<span class="go"> decorator_list=[</span>
|
||
<span class="go"> Name(id='decorator1', ctx=Load()),</span>
|
||
<span class="go"> Name(id='decorator2', ctx=Load())])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.12: </span>Added <code class="docutils literal notranslate"><span class="pre">type_params</span></code>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="async-and-await">
|
||
<h3>Async and await<a class="headerlink" href="#async-and-await" title="Link to this heading">¶</a></h3>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.AsyncFunctionDef">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AsyncFunctionDef</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">decorator_list</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">returns</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_params</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AsyncFunctionDef" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">def</span></code> function definition. Has the same fields as
|
||
<a class="reference internal" href="#ast.FunctionDef" title="ast.FunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">FunctionDef</span></code></a>.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.12: </span>Added <code class="docutils literal notranslate"><span class="pre">type_params</span></code>.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.Await">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">Await</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.Await" title="Link to this definition">¶</a></dt>
|
||
<dd><p>An <code class="docutils literal notranslate"><span class="pre">await</span></code> expression. <code class="docutils literal notranslate"><span class="pre">value</span></code> is what it waits for.
|
||
Only valid in the body of an <a class="reference internal" href="#ast.AsyncFunctionDef" title="ast.AsyncFunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">AsyncFunctionDef</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span>
|
||
<span class="gp">... </span><span class="s2">async def f():</span>
|
||
<span class="gp">... </span><span class="s2"> await other_func()</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> AsyncFunctionDef(</span>
|
||
<span class="go"> name='f',</span>
|
||
<span class="go"> args=arguments(),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Await(</span>
|
||
<span class="go"> value=Call(</span>
|
||
<span class="go"> func=Name(id='other_func', ctx=Load()))))])])</span>
|
||
</pre></div>
|
||
</div>
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.AsyncFor">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AsyncFor</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">iter</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">orelse</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AsyncFor" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object py" id="ast.AsyncWith">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">AsyncWith</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">items</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">body</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comment</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.AsyncWith" title="Link to this definition">¶</a></dt>
|
||
<dd><p><code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">for</span></code> loops and <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">with</span></code> context managers. They have the same
|
||
fields as <a class="reference internal" href="#ast.For" title="ast.For"><code class="xref py py-class docutils literal notranslate"><span class="pre">For</span></code></a> and <a class="reference internal" href="#ast.With" title="ast.With"><code class="xref py py-class docutils literal notranslate"><span class="pre">With</span></code></a>, respectively. Only valid in the
|
||
body of an <a class="reference internal" href="#ast.AsyncFunctionDef" title="ast.AsyncFunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">AsyncFunctionDef</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>When a string is parsed by <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a>, operator nodes (subclasses
|
||
of <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.operator</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.unaryop</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.cmpop</span></code>,
|
||
<code class="xref py py-class docutils literal notranslate"><span class="pre">ast.boolop</span></code> and <code class="xref py py-class docutils literal notranslate"><span class="pre">ast.expr_context</span></code>) on the returned tree
|
||
will be singletons. Changes to one will be reflected in all other
|
||
occurrences of the same value (e.g. <a class="reference internal" href="#ast.Add" title="ast.Add"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.Add</span></code></a>).</p>
|
||
</div>
|
||
</section>
|
||
</section>
|
||
<section id="ast-helpers">
|
||
<h2><a class="reference internal" href="#module-ast" title="ast: Abstract Syntax Tree classes and manipulation."><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code></a> Helpers<a class="headerlink" href="#ast-helpers" title="Link to this heading">¶</a></h2>
|
||
<p>Apart from the node classes, the <a class="reference internal" href="#module-ast" title="ast: Abstract Syntax Tree classes and manipulation."><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code></a> module defines these utility functions
|
||
and classes for traversing abstract syntax trees:</p>
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.parse">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">parse</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">source</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">filename</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'<unknown>'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">mode</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'exec'</span></span></em>, <em class="sig-param"><span class="keyword-only-separator o"><abbr title="Keyword-only parameters separator (PEP 3102)"><span class="pre">*</span></abbr></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_comments</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">feature_version</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">optimize</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">-1</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.parse" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Parse the source into an AST node. Equivalent to <code class="docutils literal notranslate"><span class="pre">compile(source,</span>
|
||
<span class="pre">filename,</span> <span class="pre">mode,</span> <span class="pre">flags=FLAGS_VALUE,</span> <span class="pre">optimize=optimize)</span></code>,
|
||
where <code class="docutils literal notranslate"><span class="pre">FLAGS_VALUE</span></code> is <code class="docutils literal notranslate"><span class="pre">ast.PyCF_ONLY_AST</span></code> if <code class="docutils literal notranslate"><span class="pre">optimize</span> <span class="pre"><=</span> <span class="pre">0</span></code>
|
||
and <code class="docutils literal notranslate"><span class="pre">ast.PyCF_OPTIMIZED_AST</span></code> otherwise.</p>
|
||
<p>If <code class="docutils literal notranslate"><span class="pre">type_comments=True</span></code> is given, the parser is modified to check
|
||
and return type comments as specified by <span class="target" id="index-4"></span><a class="pep reference external" href="https://peps.python.org/pep-0484/"><strong>PEP 484</strong></a> and <span class="target" id="index-5"></span><a class="pep reference external" href="https://peps.python.org/pep-0526/"><strong>PEP 526</strong></a>.
|
||
This is equivalent to adding <a class="reference internal" href="#ast.PyCF_TYPE_COMMENTS" title="ast.PyCF_TYPE_COMMENTS"><code class="xref py py-data docutils literal notranslate"><span class="pre">ast.PyCF_TYPE_COMMENTS</span></code></a> to the
|
||
flags passed to <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a>. This will report syntax errors
|
||
for misplaced type comments. Without this flag, type comments will
|
||
be ignored, and the <code class="docutils literal notranslate"><span class="pre">type_comment</span></code> field on selected AST nodes
|
||
will always be <code class="docutils literal notranslate"><span class="pre">None</span></code>. In addition, the locations of <code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span>
|
||
<span class="pre">ignore</span></code> comments will be returned as the <code class="docutils literal notranslate"><span class="pre">type_ignores</span></code>
|
||
attribute of <a class="reference internal" href="#ast.Module" title="ast.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">Module</span></code></a> (otherwise it is always an empty list).</p>
|
||
<p>In addition, if <code class="docutils literal notranslate"><span class="pre">mode</span></code> is <code class="docutils literal notranslate"><span class="pre">'func_type'</span></code>, the input syntax is
|
||
modified to correspond to <span class="target" id="index-6"></span><a class="pep reference external" href="https://peps.python.org/pep-0484/"><strong>PEP 484</strong></a> “signature type comments”,
|
||
e.g. <code class="docutils literal notranslate"><span class="pre">(str,</span> <span class="pre">int)</span> <span class="pre">-></span> <span class="pre">List[str]</span></code>.</p>
|
||
<p>Setting <code class="docutils literal notranslate"><span class="pre">feature_version</span></code> to a tuple <code class="docutils literal notranslate"><span class="pre">(major,</span> <span class="pre">minor)</span></code> will result in
|
||
a “best-effort” attempt to parse using that Python version’s grammar.
|
||
For example, setting <code class="docutils literal notranslate"><span class="pre">feature_version=(3,</span> <span class="pre">9)</span></code> will attempt to disallow
|
||
parsing of <a class="reference internal" href="../reference/compound_stmts.html#match"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">match</span></code></a> statements.
|
||
Currently <code class="docutils literal notranslate"><span class="pre">major</span></code> must equal to <code class="docutils literal notranslate"><span class="pre">3</span></code>. The lowest supported version is
|
||
<code class="docutils literal notranslate"><span class="pre">(3,</span> <span class="pre">7)</span></code> (and this may increase in future Python versions);
|
||
the highest is <code class="docutils literal notranslate"><span class="pre">sys.version_info[0:2]</span></code>. “Best-effort” attempt means there
|
||
is no guarantee that the parse (or success of the parse) is the same as
|
||
when run on the Python version corresponding to <code class="docutils literal notranslate"><span class="pre">feature_version</span></code>.</p>
|
||
<p>If source contains a null character (<code class="docutils literal notranslate"><span class="pre">\0</span></code>), <a class="reference internal" href="exceptions.html#ValueError" title="ValueError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code></a> is raised.</p>
|
||
<div class="admonition warning">
|
||
<p class="admonition-title">Warning</p>
|
||
<p>Note that successfully parsing source code into an AST object doesn’t
|
||
guarantee that the source code provided is valid Python code that can
|
||
be executed as the compilation step can raise further <a class="reference internal" href="exceptions.html#SyntaxError" title="SyntaxError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">SyntaxError</span></code></a>
|
||
exceptions. For instance, the source <code class="docutils literal notranslate"><span class="pre">return</span> <span class="pre">42</span></code> generates a valid
|
||
AST node for a return statement, but it cannot be compiled alone (it needs
|
||
to be inside a function node).</p>
|
||
<p>In particular, <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a> won’t do any scoping checks, which the
|
||
compilation step does.</p>
|
||
</div>
|
||
<div class="admonition warning">
|
||
<p class="admonition-title">Warning</p>
|
||
<p>It is possible to crash the Python interpreter with a
|
||
sufficiently large/complex string due to stack depth limitations
|
||
in Python’s AST compiler.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.8: </span>Added <code class="docutils literal notranslate"><span class="pre">type_comments</span></code>, <code class="docutils literal notranslate"><span class="pre">mode='func_type'</span></code> and <code class="docutils literal notranslate"><span class="pre">feature_version</span></code>.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.13: </span>The minimum supported version for <code class="docutils literal notranslate"><span class="pre">feature_version</span></code> is now <code class="docutils literal notranslate"><span class="pre">(3,</span> <span class="pre">7)</span></code>.
|
||
The <code class="docutils literal notranslate"><span class="pre">optimize</span></code> argument was added.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.unparse">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">unparse</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">ast_obj</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.unparse" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Unparse an <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.AST</span></code></a> object and generate a string with code
|
||
that would produce an equivalent <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.AST</span></code></a> object if parsed
|
||
back with <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a>.</p>
|
||
<div class="admonition warning">
|
||
<p class="admonition-title">Warning</p>
|
||
<p>The produced code string will not necessarily be equal to the original
|
||
code that generated the <a class="reference internal" href="#ast.AST" title="ast.AST"><code class="xref py py-class docutils literal notranslate"><span class="pre">ast.AST</span></code></a> object (without any compiler
|
||
optimizations, such as constant tuples/frozensets).</p>
|
||
</div>
|
||
<div class="admonition warning">
|
||
<p class="admonition-title">Warning</p>
|
||
<p>Trying to unparse a highly complex expression would result with
|
||
<a class="reference internal" href="exceptions.html#RecursionError" title="RecursionError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">RecursionError</span></code></a>.</p>
|
||
</div>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.9.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.literal_eval">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">literal_eval</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node_or_string</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.literal_eval" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Evaluate an expression node or a string containing only a Python literal or
|
||
container display. The string or node provided may only consist of the
|
||
following Python literal structures: strings, bytes, numbers, tuples, lists,
|
||
dicts, sets, booleans, <code class="docutils literal notranslate"><span class="pre">None</span></code> and <code class="docutils literal notranslate"><span class="pre">Ellipsis</span></code>.</p>
|
||
<p>This can be used for evaluating strings containing Python values without the
|
||
need to parse the values oneself. It is not capable of evaluating
|
||
arbitrarily complex expressions, for example involving operators or
|
||
indexing.</p>
|
||
<p>This function had been documented as “safe” in the past without defining
|
||
what that meant. That was misleading. This is specifically designed not to
|
||
execute Python code, unlike the more general <a class="reference internal" href="functions.html#eval" title="eval"><code class="xref py py-func docutils literal notranslate"><span class="pre">eval()</span></code></a>. There is no
|
||
namespace, no name lookups, or ability to call out. But it is not free from
|
||
attack: A relatively small input can lead to memory exhaustion or to C stack
|
||
exhaustion, crashing the process. There is also the possibility for
|
||
excessive CPU consumption denial of service on some inputs. Calling it on
|
||
untrusted data is thus not recommended.</p>
|
||
<div class="admonition warning">
|
||
<p class="admonition-title">Warning</p>
|
||
<p>It is possible to crash the Python interpreter due to stack depth
|
||
limitations in Python’s AST compiler.</p>
|
||
<p>It can raise <a class="reference internal" href="exceptions.html#ValueError" title="ValueError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code></a>, <a class="reference internal" href="exceptions.html#TypeError" title="TypeError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">TypeError</span></code></a>, <a class="reference internal" href="exceptions.html#SyntaxError" title="SyntaxError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">SyntaxError</span></code></a>,
|
||
<a class="reference internal" href="exceptions.html#MemoryError" title="MemoryError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">MemoryError</span></code></a> and <a class="reference internal" href="exceptions.html#RecursionError" title="RecursionError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">RecursionError</span></code></a> depending on the malformed
|
||
input.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.2: </span>Now allows bytes and set literals.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.9: </span>Now supports creating empty sets with <code class="docutils literal notranslate"><span class="pre">'set()'</span></code>.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.10: </span>For string inputs, leading spaces and tabs are now stripped.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.get_docstring">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">get_docstring</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">clean</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.get_docstring" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return the docstring of the given <em>node</em> (which must be a
|
||
<a class="reference internal" href="#ast.FunctionDef" title="ast.FunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">FunctionDef</span></code></a>, <a class="reference internal" href="#ast.AsyncFunctionDef" title="ast.AsyncFunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">AsyncFunctionDef</span></code></a>, <a class="reference internal" href="#ast.ClassDef" title="ast.ClassDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClassDef</span></code></a>,
|
||
or <a class="reference internal" href="#ast.Module" title="ast.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">Module</span></code></a> node), or <code class="docutils literal notranslate"><span class="pre">None</span></code> if it has no docstring.
|
||
If <em>clean</em> is true, clean up the docstring’s indentation with
|
||
<a class="reference internal" href="inspect.html#inspect.cleandoc" title="inspect.cleandoc"><code class="xref py py-func docutils literal notranslate"><span class="pre">inspect.cleandoc()</span></code></a>.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.5: </span><a class="reference internal" href="#ast.AsyncFunctionDef" title="ast.AsyncFunctionDef"><code class="xref py py-class docutils literal notranslate"><span class="pre">AsyncFunctionDef</span></code></a> is now supported.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.get_source_segment">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">get_source_segment</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">source</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="keyword-only-separator o"><abbr title="Keyword-only parameters separator (PEP 3102)"><span class="pre">*</span></abbr></span></em>, <em class="sig-param"><span class="n"><span class="pre">padded</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.get_source_segment" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Get source code segment of the <em>source</em> that generated <em>node</em>.
|
||
If some location information (<a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a>, <a class="reference internal" href="#ast.AST.end_lineno" title="ast.AST.end_lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_lineno</span></code></a>,
|
||
<a class="reference internal" href="#ast.AST.col_offset" title="ast.AST.col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code></a>, or <a class="reference internal" href="#ast.AST.end_col_offset" title="ast.AST.end_col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_col_offset</span></code></a>) is missing, return <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p>
|
||
<p>If <em>padded</em> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the first line of a multi-line statement will
|
||
be padded with spaces to match its original position.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.8.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.fix_missing_locations">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">fix_missing_locations</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.fix_missing_locations" title="Link to this definition">¶</a></dt>
|
||
<dd><p>When you compile a node tree with <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a>, the compiler expects
|
||
<a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a> and <a class="reference internal" href="#ast.AST.col_offset" title="ast.AST.col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code></a> attributes for every node that supports
|
||
them. This is rather tedious to fill in for generated nodes, so this helper
|
||
adds these attributes recursively where not already set, by setting them to
|
||
the values of the parent node. It works recursively starting at <em>node</em>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.increment_lineno">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">increment_lineno</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">1</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.increment_lineno" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Increment the line number and end line number of each node in the tree
|
||
starting at <em>node</em> by <em>n</em>. This is useful to “move code” to a different
|
||
location in a file.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.copy_location">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">copy_location</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">new_node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">old_node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.copy_location" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Copy source location (<a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a>, <a class="reference internal" href="#ast.AST.col_offset" title="ast.AST.col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">col_offset</span></code></a>, <a class="reference internal" href="#ast.AST.end_lineno" title="ast.AST.end_lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_lineno</span></code></a>,
|
||
and <a class="reference internal" href="#ast.AST.end_col_offset" title="ast.AST.end_col_offset"><code class="xref py py-attr docutils literal notranslate"><span class="pre">end_col_offset</span></code></a>) from <em>old_node</em> to <em>new_node</em> if possible,
|
||
and return <em>new_node</em>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.iter_fields">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">iter_fields</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.iter_fields" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Yield a tuple of <code class="docutils literal notranslate"><span class="pre">(fieldname,</span> <span class="pre">value)</span></code> for each field in <code class="docutils literal notranslate"><span class="pre">node._fields</span></code>
|
||
that is present on <em>node</em>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.iter_child_nodes">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">iter_child_nodes</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.iter_child_nodes" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Yield all direct child nodes of <em>node</em>, that is, all fields that are nodes
|
||
and all items of fields that are lists of nodes.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.walk">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">walk</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.walk" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Recursively yield all descendant nodes in the tree starting at <em>node</em>
|
||
(including <em>node</em> itself), in no specified order. This is useful if you only
|
||
want to modify nodes in place and don’t care about the context.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.NodeVisitor">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NodeVisitor</span></span><a class="headerlink" href="#ast.NodeVisitor" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A node visitor base class that walks the abstract syntax tree and calls a
|
||
visitor function for every node found. This function may return a value
|
||
which is forwarded by the <a class="reference internal" href="#ast.NodeVisitor.visit" title="ast.NodeVisitor.visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">visit()</span></code></a> method.</p>
|
||
<p>This class is meant to be subclassed, with the subclass adding visitor
|
||
methods.</p>
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="ast.NodeVisitor.visit">
|
||
<span class="sig-name descname"><span class="pre">visit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.NodeVisitor.visit" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Visit a node. The default implementation calls the method called
|
||
<code class="samp docutils literal notranslate"><span class="pre">self.visit_</span><em><span class="pre">classname</span></em></code> where <em>classname</em> is the name of the node
|
||
class, or <a class="reference internal" href="#ast.NodeVisitor.generic_visit" title="ast.NodeVisitor.generic_visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">generic_visit()</span></code></a> if that method doesn’t exist.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="ast.NodeVisitor.generic_visit">
|
||
<span class="sig-name descname"><span class="pre">generic_visit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.NodeVisitor.generic_visit" title="Link to this definition">¶</a></dt>
|
||
<dd><p>This visitor calls <a class="reference internal" href="#ast.NodeVisitor.visit" title="ast.NodeVisitor.visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">visit()</span></code></a> on all children of the node.</p>
|
||
<p>Note that child nodes of nodes that have a custom visitor method won’t be
|
||
visited unless the visitor calls <a class="reference internal" href="#ast.NodeVisitor.generic_visit" title="ast.NodeVisitor.generic_visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">generic_visit()</span></code></a> or visits them
|
||
itself.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py method">
|
||
<dt class="sig sig-object py" id="ast.NodeVisitor.visit_Constant">
|
||
<span class="sig-name descname"><span class="pre">visit_Constant</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.NodeVisitor.visit_Constant" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Handles all constant nodes.</p>
|
||
</dd></dl>
|
||
|
||
<p>Don’t use the <a class="reference internal" href="#ast.NodeVisitor" title="ast.NodeVisitor"><code class="xref py py-class docutils literal notranslate"><span class="pre">NodeVisitor</span></code></a> if you want to apply changes to nodes
|
||
during traversal. For this a special visitor exists
|
||
(<a class="reference internal" href="#ast.NodeTransformer" title="ast.NodeTransformer"><code class="xref py py-class docutils literal notranslate"><span class="pre">NodeTransformer</span></code></a>) that allows modifications.</p>
|
||
<div class="deprecated">
|
||
<p><span class="versionmodified deprecated">Deprecated since version 3.8: </span>Methods <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Num()</span></code>, <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Str()</span></code>, <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Bytes()</span></code>,
|
||
<code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_NameConstant()</span></code> and <code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Ellipsis()</span></code> are deprecated
|
||
now and will not be called in future Python versions. Add the
|
||
<a class="reference internal" href="#ast.NodeVisitor.visit_Constant" title="ast.NodeVisitor.visit_Constant"><code class="xref py py-meth docutils literal notranslate"><span class="pre">visit_Constant()</span></code></a> method to handle all constant nodes.</p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py class">
|
||
<dt class="sig sig-object py" id="ast.NodeTransformer">
|
||
<em class="property"><span class="k"><span class="pre">class</span></span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">NodeTransformer</span></span><a class="headerlink" href="#ast.NodeTransformer" title="Link to this definition">¶</a></dt>
|
||
<dd><p>A <a class="reference internal" href="#ast.NodeVisitor" title="ast.NodeVisitor"><code class="xref py py-class docutils literal notranslate"><span class="pre">NodeVisitor</span></code></a> subclass that walks the abstract syntax tree and
|
||
allows modification of nodes.</p>
|
||
<p>The <a class="reference internal" href="#ast.NodeTransformer" title="ast.NodeTransformer"><code class="xref py py-class docutils literal notranslate"><span class="pre">NodeTransformer</span></code></a> will walk the AST and use the return value of
|
||
the visitor methods to replace or remove the old node. If the return value
|
||
of the visitor method is <code class="docutils literal notranslate"><span class="pre">None</span></code>, the node will be removed from its
|
||
location, otherwise it is replaced with the return value. The return value
|
||
may be the original node in which case no replacement takes place.</p>
|
||
<p>Here is an example transformer that rewrites all occurrences of name lookups
|
||
(<code class="docutils literal notranslate"><span class="pre">foo</span></code>) to <code class="docutils literal notranslate"><span class="pre">data['foo']</span></code>:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span><span class="w"> </span><span class="nc">RewriteName</span><span class="p">(</span><span class="n">NodeTransformer</span><span class="p">):</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">visit_Name</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">node</span><span class="p">):</span>
|
||
<span class="k">return</span> <span class="n">Subscript</span><span class="p">(</span>
|
||
<span class="n">value</span><span class="o">=</span><span class="n">Name</span><span class="p">(</span><span class="nb">id</span><span class="o">=</span><span class="s1">'data'</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">Load</span><span class="p">()),</span>
|
||
<span class="nb">slice</span><span class="o">=</span><span class="n">Constant</span><span class="p">(</span><span class="n">value</span><span class="o">=</span><span class="n">node</span><span class="o">.</span><span class="n">id</span><span class="p">),</span>
|
||
<span class="n">ctx</span><span class="o">=</span><span class="n">node</span><span class="o">.</span><span class="n">ctx</span>
|
||
<span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Keep in mind that if the node you’re operating on has child nodes you must
|
||
either transform the child nodes yourself or call the <a class="reference internal" href="#ast.NodeVisitor.generic_visit" title="ast.NodeVisitor.generic_visit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">generic_visit()</span></code></a>
|
||
method for the node first.</p>
|
||
<p>For nodes that were part of a collection of statements (that applies to all
|
||
statement nodes), the visitor may also return a list of nodes rather than
|
||
just a single node.</p>
|
||
<p>If <a class="reference internal" href="#ast.NodeTransformer" title="ast.NodeTransformer"><code class="xref py py-class docutils literal notranslate"><span class="pre">NodeTransformer</span></code></a> introduces new nodes (that weren’t part of
|
||
original tree) without giving them location information (such as
|
||
<a class="reference internal" href="#ast.AST.lineno" title="ast.AST.lineno"><code class="xref py py-attr docutils literal notranslate"><span class="pre">lineno</span></code></a>), <a class="reference internal" href="#ast.fix_missing_locations" title="ast.fix_missing_locations"><code class="xref py py-func docutils literal notranslate"><span class="pre">fix_missing_locations()</span></code></a> should be called with
|
||
the new sub-tree to recalculate the location information:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tree</span> <span class="o">=</span> <span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s1">'foo'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'eval'</span><span class="p">)</span>
|
||
<span class="n">new_tree</span> <span class="o">=</span> <span class="n">fix_missing_locations</span><span class="p">(</span><span class="n">RewriteName</span><span class="p">()</span><span class="o">.</span><span class="n">visit</span><span class="p">(</span><span class="n">tree</span><span class="p">))</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Usually you use the transformer like this:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">node</span> <span class="o">=</span> <span class="n">YourTransformer</span><span class="p">()</span><span class="o">.</span><span class="n">visit</span><span class="p">(</span><span class="n">node</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py function">
|
||
<dt class="sig sig-object py" id="ast.dump">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">dump</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">annotate_fields</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">include_attributes</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="keyword-only-separator o"><abbr title="Keyword-only parameters separator (PEP 3102)"><span class="pre">*</span></abbr></span></em>, <em class="sig-param"><span class="n"><span class="pre">indent</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">show_empty</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#ast.dump" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Return a formatted dump of the tree in <em>node</em>. This is mainly useful for
|
||
debugging purposes. If <em>annotate_fields</em> is true (by default),
|
||
the returned string will show the names and the values for fields.
|
||
If <em>annotate_fields</em> is false, the result string will be more compact by
|
||
omitting unambiguous field names. Attributes such as line
|
||
numbers and column offsets are not dumped by default. If this is wanted,
|
||
<em>include_attributes</em> can be set to true.</p>
|
||
<p>If <em>indent</em> is a non-negative integer or string, then the tree will be
|
||
pretty-printed with that indent level. An indent level
|
||
of 0, negative, or <code class="docutils literal notranslate"><span class="pre">""</span></code> will only insert newlines. <code class="docutils literal notranslate"><span class="pre">None</span></code> (the default)
|
||
selects the single line representation. Using a positive integer indent
|
||
indents that many spaces per level. If <em>indent</em> is a string (such as <code class="docutils literal notranslate"><span class="pre">"\t"</span></code>),
|
||
that string is used to indent each level.</p>
|
||
<p>If <em>show_empty</em> is <code class="docutils literal notranslate"><span class="pre">False</span></code> (the default), empty lists and fields that are <code class="docutils literal notranslate"><span class="pre">None</span></code>
|
||
will be omitted from the output.</p>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.9: </span>Added the <em>indent</em> option.</p>
|
||
</div>
|
||
<div class="versionchanged">
|
||
<p><span class="versionmodified changed">Changed in version 3.13: </span>Added the <em>show_empty</em> option.</p>
|
||
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">ast</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="s2">"""</span><span class="se">\</span>
|
||
<span class="gp">... </span><span class="s2">async def f():</span>
|
||
<span class="gp">... </span><span class="s2"> await other_func()</span>
|
||
<span class="gp">... </span><span class="s2">"""</span><span class="p">),</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> <span class="n">show_empty</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>
|
||
<span class="go">Module(</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> AsyncFunctionDef(</span>
|
||
<span class="go"> name='f',</span>
|
||
<span class="go"> args=arguments(</span>
|
||
<span class="go"> posonlyargs=[],</span>
|
||
<span class="go"> args=[],</span>
|
||
<span class="go"> kwonlyargs=[],</span>
|
||
<span class="go"> kw_defaults=[],</span>
|
||
<span class="go"> defaults=[]),</span>
|
||
<span class="go"> body=[</span>
|
||
<span class="go"> Expr(</span>
|
||
<span class="go"> value=Await(</span>
|
||
<span class="go"> value=Call(</span>
|
||
<span class="go"> func=Name(id='other_func', ctx=Load()),</span>
|
||
<span class="go"> args=[],</span>
|
||
<span class="go"> keywords=[])))],</span>
|
||
<span class="go"> decorator_list=[],</span>
|
||
<span class="go"> type_params=[])],</span>
|
||
<span class="go"> type_ignores=[])</span>
|
||
</pre></div>
|
||
</div>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="compiler-flags">
|
||
<span id="ast-compiler-flags"></span><h2>Compiler Flags<a class="headerlink" href="#compiler-flags" title="Link to this heading">¶</a></h2>
|
||
<p>The following flags may be passed to <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a> in order to change
|
||
effects on the compilation of a program:</p>
|
||
<dl class="py data">
|
||
<dt class="sig sig-object py" id="ast.PyCF_ALLOW_TOP_LEVEL_AWAIT">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">PyCF_ALLOW_TOP_LEVEL_AWAIT</span></span><a class="headerlink" href="#ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Enables support for top-level <code class="docutils literal notranslate"><span class="pre">await</span></code>, <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">for</span></code>, <code class="docutils literal notranslate"><span class="pre">async</span> <span class="pre">with</span></code>
|
||
and async comprehensions.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.8.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py data">
|
||
<dt class="sig sig-object py" id="ast.PyCF_ONLY_AST">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">PyCF_ONLY_AST</span></span><a class="headerlink" href="#ast.PyCF_ONLY_AST" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Generates and returns an abstract syntax tree instead of returning a
|
||
compiled code object.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="py data">
|
||
<dt class="sig sig-object py" id="ast.PyCF_OPTIMIZED_AST">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">PyCF_OPTIMIZED_AST</span></span><a class="headerlink" href="#ast.PyCF_OPTIMIZED_AST" title="Link to this definition">¶</a></dt>
|
||
<dd><p>The returned AST is optimized according to the <em>optimize</em> argument
|
||
in <a class="reference internal" href="functions.html#compile" title="compile"><code class="xref py py-func docutils literal notranslate"><span class="pre">compile()</span></code></a> or <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">ast.parse()</span></code></a>.</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.13.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
<dl class="py data">
|
||
<dt class="sig sig-object py" id="ast.PyCF_TYPE_COMMENTS">
|
||
<span class="sig-prename descclassname"><span class="pre">ast.</span></span><span class="sig-name descname"><span class="pre">PyCF_TYPE_COMMENTS</span></span><a class="headerlink" href="#ast.PyCF_TYPE_COMMENTS" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Enables support for <span class="target" id="index-7"></span><a class="pep reference external" href="https://peps.python.org/pep-0484/"><strong>PEP 484</strong></a> and <span class="target" id="index-8"></span><a class="pep reference external" href="https://peps.python.org/pep-0526/"><strong>PEP 526</strong></a> style type comments
|
||
(<code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span> <span class="pre"><type></span></code>, <code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span> <span class="pre">ignore</span> <span class="pre"><stuff></span></code>).</p>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.8.</span></p>
|
||
</div>
|
||
</dd></dl>
|
||
|
||
</section>
|
||
<section id="command-line-usage">
|
||
<span id="ast-cli"></span><h2>Command-Line Usage<a class="headerlink" href="#command-line-usage" title="Link to this heading">¶</a></h2>
|
||
<div class="versionadded">
|
||
<p><span class="versionmodified added">Added in version 3.9.</span></p>
|
||
</div>
|
||
<p>The <a class="reference internal" href="#module-ast" title="ast: Abstract Syntax Tree classes and manipulation."><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code></a> module can be executed as a script from the command line.
|
||
It is as simple as:</p>
|
||
<div class="highlight-sh notranslate"><div class="highlight"><pre><span></span>python<span class="w"> </span>-m<span class="w"> </span>ast<span class="w"> </span><span class="o">[</span>-m<span class="w"> </span><mode><span class="o">]</span><span class="w"> </span><span class="o">[</span>-a<span class="o">]</span><span class="w"> </span><span class="o">[</span>infile<span class="o">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The following options are accepted:</p>
|
||
<dl class="std option">
|
||
<dt class="sig sig-object std" id="cmdoption-ast-h">
|
||
<span id="cmdoption-ast-help"></span><span class="sig-name descname"><span class="pre">-h</span></span><span class="sig-prename descclassname"></span><span class="sig-prename descclassname"><span class="pre">,</span> </span><span class="sig-name descname"><span class="pre">--help</span></span><span class="sig-prename descclassname"></span><a class="headerlink" href="#cmdoption-ast-h" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Show the help message and exit.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="std option">
|
||
<dt class="sig sig-object std" id="cmdoption-ast-m">
|
||
<span class="sig-name descname"><span class="pre">-m</span></span><span class="sig-prename descclassname"> <span class="pre"><mode></span></span><a class="headerlink" href="#cmdoption-ast-m" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object std" id="cmdoption-ast-mode">
|
||
<span class="sig-name descname"><span class="pre">--mode</span></span><span class="sig-prename descclassname"> <span class="pre"><mode></span></span><a class="headerlink" href="#cmdoption-ast-mode" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Specify what kind of code must be compiled, like the <em>mode</em> argument
|
||
in <a class="reference internal" href="#ast.parse" title="ast.parse"><code class="xref py py-func docutils literal notranslate"><span class="pre">parse()</span></code></a>.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="std option">
|
||
<dt class="sig sig-object std" id="cmdoption-ast-no-type-comments">
|
||
<span class="sig-name descname"><span class="pre">--no-type-comments</span></span><span class="sig-prename descclassname"></span><a class="headerlink" href="#cmdoption-ast-no-type-comments" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Don’t parse type comments.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="std option">
|
||
<dt class="sig sig-object std" id="cmdoption-ast-a">
|
||
<span id="cmdoption-ast-include-attributes"></span><span class="sig-name descname"><span class="pre">-a</span></span><span class="sig-prename descclassname"></span><span class="sig-prename descclassname"><span class="pre">,</span> </span><span class="sig-name descname"><span class="pre">--include-attributes</span></span><span class="sig-prename descclassname"></span><a class="headerlink" href="#cmdoption-ast-a" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Include attributes such as line numbers and column offsets.</p>
|
||
</dd></dl>
|
||
|
||
<dl class="std option">
|
||
<dt class="sig sig-object std" id="cmdoption-ast-i">
|
||
<span class="sig-name descname"><span class="pre">-i</span></span><span class="sig-prename descclassname"> <span class="pre"><indent></span></span><a class="headerlink" href="#cmdoption-ast-i" title="Link to this definition">¶</a></dt>
|
||
<dt class="sig sig-object std" id="cmdoption-ast-indent">
|
||
<span class="sig-name descname"><span class="pre">--indent</span></span><span class="sig-prename descclassname"> <span class="pre"><indent></span></span><a class="headerlink" href="#cmdoption-ast-indent" title="Link to this definition">¶</a></dt>
|
||
<dd><p>Indentation of nodes in AST (number of spaces).</p>
|
||
</dd></dl>
|
||
|
||
<p>If <code class="file docutils literal notranslate"><span class="pre">infile</span></code> is specified its contents are parsed to AST and dumped
|
||
to stdout. Otherwise, the content is read from stdin.</p>
|
||
<div class="admonition seealso">
|
||
<p class="admonition-title">See also</p>
|
||
<p><a class="reference external" href="https://greentreesnakes.readthedocs.io/">Green Tree Snakes</a>, an external
|
||
documentation resource, has good details on working with Python ASTs.</p>
|
||
<p><a class="reference external" href="https://asttokens.readthedocs.io/en/latest/user-guide.html">ASTTokens</a>
|
||
annotates Python ASTs with the positions of tokens and text in the source
|
||
code that generated them. This is helpful for tools that make source code
|
||
transformations.</p>
|
||
<p><a class="reference external" href="https://leo-editor.github.io/leo-editor/appendices.html#leoast-py">leoAst.py</a>
|
||
unifies the
|
||
token-based and parse-tree-based views of python programs by inserting
|
||
two-way links between tokens and ast nodes.</p>
|
||
<p><a class="reference external" href="https://libcst.readthedocs.io/">LibCST</a> parses code as a Concrete Syntax
|
||
Tree that looks like an ast tree and keeps all formatting details. It’s
|
||
useful for building automated refactoring (codemod) applications and
|
||
linters.</p>
|
||
<p><a class="reference external" href="https://parso.readthedocs.io">Parso</a> is a Python parser that supports
|
||
error recovery and round-trip parsing for different Python versions (in
|
||
multiple Python versions). Parso is also able to list multiple syntax errors
|
||
in your Python file.</p>
|
||
</div>
|
||
</section>
|
||
</section>
|
||
|
||
|
||
<div class="clearer"></div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="sphinxsidebar" role="navigation" aria-label="Main">
|
||
<div class="sphinxsidebarwrapper">
|
||
<div>
|
||
<h3><a href="../contents.html">Table of Contents</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract Syntax Trees</a><ul>
|
||
<li><a class="reference internal" href="#abstract-grammar">Abstract Grammar</a></li>
|
||
<li><a class="reference internal" href="#node-classes">Node classes</a><ul>
|
||
<li><a class="reference internal" href="#root-nodes">Root nodes</a></li>
|
||
<li><a class="reference internal" href="#literals">Literals</a></li>
|
||
<li><a class="reference internal" href="#variables">Variables</a></li>
|
||
<li><a class="reference internal" href="#expressions">Expressions</a><ul>
|
||
<li><a class="reference internal" href="#subscripting">Subscripting</a></li>
|
||
<li><a class="reference internal" href="#comprehensions">Comprehensions</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#statements">Statements</a><ul>
|
||
<li><a class="reference internal" href="#imports">Imports</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#control-flow">Control flow</a></li>
|
||
<li><a class="reference internal" href="#pattern-matching">Pattern matching</a></li>
|
||
<li><a class="reference internal" href="#type-parameters">Type parameters</a></li>
|
||
<li><a class="reference internal" href="#function-and-class-definitions">Function and class definitions</a></li>
|
||
<li><a class="reference internal" href="#async-and-await">Async and await</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#ast-helpers"><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> Helpers</a></li>
|
||
<li><a class="reference internal" href="#compiler-flags">Compiler Flags</a></li>
|
||
<li><a class="reference internal" href="#command-line-usage">Command-Line Usage</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
|
||
</div>
|
||
<div>
|
||
<h4>Previous topic</h4>
|
||
<p class="topless"><a href="language.html"
|
||
title="previous chapter">Python Language Services</a></p>
|
||
</div>
|
||
<div>
|
||
<h4>Next topic</h4>
|
||
<p class="topless"><a href="symtable.html"
|
||
title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">symtable</span></code> — Access to the compiler’s symbol tables</a></p>
|
||
</div>
|
||
<div role="note" aria-label="source link">
|
||
<h3>This Page</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">Report a Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/main/Doc/library/ast.rst"
|
||
rel="nofollow">Show Source
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
<div id="sidebarbutton" title="Collapse sidebar">
|
||
<span>«</span>
|
||
</div>
|
||
|
||
</div>
|
||
<div class="clearer"></div>
|
||
</div>
|
||
<div class="related" role="navigation" aria-label="Related">
|
||
<h3>Navigation</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="General Index"
|
||
>index</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python Module Index"
|
||
>modules</a> |</li>
|
||
<li class="right" >
|
||
<a href="symtable.html" title="symtable — Access to the compiler’s symbol tables"
|
||
>next</a> |</li>
|
||
<li class="right" >
|
||
<a href="language.html" title="Python Language Services"
|
||
>previous</a> |</li>
|
||
|
||
<li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li class="switchers">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<div class="version_switcher_placeholder"></div>
|
||
</li>
|
||
<li>
|
||
|
||
</li>
|
||
<li id="cpython-language-and-version">
|
||
<a href="../index.html">3.13.3 Documentation</a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> »</li>
|
||
<li class="nav-item nav-item-2"><a href="language.html" >Python Language Services</a> »</li>
|
||
<li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">ast</span></code> — Abstract Syntax Trees</a></li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />
|
||
<input type="submit" value="Go" />
|
||
</form>
|
||
</div>
|
||
|
|
||
</li>
|
||
<li class="right">
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label> |</li>
|
||
|
||
</ul>
|
||
</div>
|
||
<div class="footer">
|
||
©
|
||
<a href="../copyright.html">
|
||
|
||
Copyright
|
||
|
||
</a>
|
||
2001-2025, Python Software Foundation.
|
||
<br />
|
||
This page is licensed under the Python Software Foundation License Version 2.
|
||
<br />
|
||
Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.
|
||
<br />
|
||
|
||
See <a href="/license.html">History and License</a> for more information.<br />
|
||
|
||
|
||
<br />
|
||
|
||
The Python Software Foundation is a non-profit corporation.
|
||
<a href="https://www.python.org/psf/donations/">Please donate.</a>
|
||
<br />
|
||
<br />
|
||
Last updated on Apr 08, 2025 (14:33 UTC).
|
||
|
||
<a href="/bugs.html">Found a bug</a>?
|
||
|
||
<br />
|
||
|
||
Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 8.2.3.
|
||
</div>
|
||
|
||
</body>
|
||
</html> |