# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-13 15:10+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid ":mod:`!ast` --- Abstract syntax trees"

msgstr ""

msgid "**Source code:** :source:`Lib/ast.py`"

msgstr "**Kod źródłowy:** :source:`Lib/ast.py`"

msgid ""

"The :mod:`!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 module helps to find out programmatically "

"what the current grammar looks like."

msgstr ""

msgid ""

"An abstract syntax tree can be generated by passing :data:`ast."

"PyCF_ONLY_AST` as a flag to the :func:`compile` built-in function, or using "

"the :func:`parse` helper provided in this module. The result will be a tree "

"of objects whose classes all inherit from :class:`ast.AST`. An abstract "

"syntax tree can be compiled into a Python code object using the built-in :"

"func:`compile` function."

msgstr ""

msgid "Abstract grammar"

msgstr ""

msgid "The abstract grammar is currently defined as follows:"

msgstr ""

msgid ""

"-- ASDL's 4 builtin types are:\n"

"-- identifier, int, string, constant\n"

"\n"

"module Python\n"

"{\n"

" mod = Module(stmt* body, type_ignore* type_ignores)\n"

" | Interactive(stmt* body)\n"

" | Expression(expr body)\n"

" | FunctionType(expr* argtypes, expr returns)\n"

"\n"

" stmt = FunctionDef(identifier name, arguments args,\n"

" stmt* body, expr* decorator_list, expr? returns,\n"

" string? type_comment, type_param* type_params)\n"

" | AsyncFunctionDef(identifier name, arguments args,\n"

" stmt* body, expr* decorator_list, expr? "

"returns,\n"

" string? type_comment, type_param* type_params)\n"

"\n"

" | ClassDef(identifier name,\n"

" expr* bases,\n"

" keyword* keywords,\n"

" stmt* body,\n"

" expr* decorator_list,\n"

" type_param* type_params)\n"

" | Return(expr? value)\n"

"\n"

" | Delete(expr* targets)\n"

" | Assign(expr* targets, expr value, string? type_comment)\n"

" | TypeAlias(expr name, type_param* type_params, expr value)\n"

" | AugAssign(expr target, operator op, expr value)\n"

" -- 'simple' indicates that we annotate simple name without parens\n"

" | AnnAssign(expr target, expr annotation, expr? value, int "

"simple)\n"

"\n"

" -- use 'orelse' because else is a keyword in target languages\n"

" | For(expr target, expr iter, stmt* body, stmt* orelse, string? "

"type_comment)\n"

" | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, "

"string? type_comment)\n"

" | While(expr test, stmt* body, stmt* orelse)\n"

" | If(expr test, stmt* body, stmt* orelse)\n"

" | With(withitem* items, stmt* body, string? type_comment)\n"

" | AsyncWith(withitem* items, stmt* body, string? type_comment)\n"

"\n"

" | Match(expr subject, match_case* cases)\n"

"\n"

" | Raise(expr? exc, expr? cause)\n"

" | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* "

"finalbody)\n"

" | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* "

"finalbody)\n"

" | Assert(expr test, expr? msg)\n"

"\n"

" | Import(alias* names)\n"

" | ImportFrom(identifier? module, alias* names, int? level)\n"

"\n"

" | Global(identifier* names)\n"

" | Nonlocal(identifier* names)\n"

" | Expr(expr value)\n"

" | Pass | Break | Continue\n"

"\n"

" -- col_offset is the byte offset in the utf8 string the parser "

"uses\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" -- BoolOp() can use left & right?\n"

" expr = BoolOp(boolop op, expr* values)\n"

" | NamedExpr(expr target, expr value)\n"

" | BinOp(expr left, operator op, expr right)\n"

" | UnaryOp(unaryop op, expr operand)\n"

" | Lambda(arguments args, expr body)\n"

" | IfExp(expr test, expr body, expr orelse)\n"

" | Dict(expr?* keys, expr* values)\n"

" | Set(expr* elts)\n"

" | ListComp(expr elt, comprehension* generators)\n"

" | SetComp(expr elt, comprehension* generators)\n"

" | DictComp(expr key, expr value, comprehension* generators)\n"

" | GeneratorExp(expr elt, comprehension* generators)\n"

" -- the grammar constrains where yield expressions can occur\n"

" | Await(expr value)\n"

" | Yield(expr? value)\n"

" | YieldFrom(expr value)\n"

" -- need sequences for compare to distinguish between\n"

" -- x < 4 < 3 and (x < 4) < 3\n"

" | Compare(expr left, cmpop* ops, expr* comparators)\n"

" | Call(expr func, expr* args, keyword* keywords)\n"

" | FormattedValue(expr value, int conversion, expr? format_spec)\n"

" | Interpolation(expr value, constant str, int conversion, expr? "

"format_spec)\n"

" | JoinedStr(expr* values)\n"

" | TemplateStr(expr* values)\n"

" | Constant(constant value, string? kind)\n"

"\n"

" -- the following expression can appear in assignment context\n"

" | Attribute(expr value, identifier attr, expr_context ctx)\n"

" | Subscript(expr value, expr slice, expr_context ctx)\n"

" | Starred(expr value, expr_context ctx)\n"

" | Name(identifier id, expr_context ctx)\n"

" | List(expr* elts, expr_context ctx)\n"

" | Tuple(expr* elts, expr_context ctx)\n"

"\n"

" -- can appear only in Subscript\n"

" | Slice(expr? lower, expr? upper, expr? step)\n"

"\n"

" -- col_offset is the byte offset in the utf8 string the parser "

"uses\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" expr_context = Load | Store | Del\n"

"\n"

" boolop = And | Or\n"

"\n"

" operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift\n"

" | RShift | BitOr | BitXor | BitAnd | FloorDiv\n"

"\n"

" unaryop = Invert | Not | UAdd | USub\n"

"\n"

" cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn\n"

"\n"

" comprehension = (expr target, expr iter, expr* ifs, int is_async)\n"

"\n"

" excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)\n"

" attributes (int lineno, int col_offset, int? end_lineno, "

"int? end_col_offset)\n"

"\n"

" arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,\n"

" expr?* kw_defaults, arg? kwarg, expr* defaults)\n"

"\n"

" arg = (identifier arg, expr? annotation, string? type_comment)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" -- keyword arguments supplied to call (NULL identifier for **kwargs)\n"

" keyword = (identifier? arg, expr value)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" -- import name with optional 'as' alias.\n"

" alias = (identifier name, identifier? asname)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" withitem = (expr context_expr, expr? optional_vars)\n"

"\n"

" match_case = (pattern pattern, expr? guard, stmt* body)\n"

"\n"

" pattern = MatchValue(expr value)\n"

" | MatchSingleton(constant value)\n"

" | MatchSequence(pattern* patterns)\n"

" | MatchMapping(expr* keys, pattern* patterns, identifier? rest)\n"

" | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, "

"pattern* kwd_patterns)\n"

"\n"

" | MatchStar(identifier? name)\n"

" -- The optional \"rest\" MatchMapping parameter handles "

"capturing extra mapping keys\n"

"\n"

" | MatchAs(pattern? pattern, identifier? name)\n"

" | MatchOr(pattern* patterns)\n"

"\n"

" attributes (int lineno, int col_offset, int end_lineno, int "

"end_col_offset)\n"

"\n"

" type_ignore = TypeIgnore(int lineno, string tag)\n"

"\n"

" type_param = TypeVar(identifier name, expr? bound, expr? default_value)\n"

" | ParamSpec(identifier name, expr? default_value)\n"

" | TypeVarTuple(identifier name, expr? default_value)\n"

" attributes (int lineno, int col_offset, int end_lineno, int "

"end_col_offset)\n"

"}\n"

msgstr ""

msgid "Node classes"

msgstr ""

msgid ""

"This is the base of all AST node classes. The actual node classes are "

"derived from the :file:`Parser/Python.asdl` file, which is reproduced :ref:"

"`above <abstract-grammar>`. They are defined in the :mod:`!_ast` C module "

"and re-exported in :mod:`!ast`."

msgstr ""

msgid ""

"There is one class defined for each left-hand side symbol in the abstract "

"grammar (for example, :class:`ast.stmt` or :class:`ast.expr`). 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, :class:`ast.BinOp` inherits from :class:`ast.expr`. For production "

"rules with alternatives (aka \"sums\"), the left-hand side class is "

"abstract: only instances of specific constructor nodes are ever created."

msgstr ""

msgid ""

"Each concrete class has an attribute :attr:`!_fields` which gives the names "

"of all child nodes."

msgstr ""

msgid ""

"Each instance of a concrete class has one attribute for each child node, of "

"the type as defined in the grammar. For example, :class:`ast.BinOp` "

"instances have an attribute :attr:`left` of type :class:`ast.expr`."

msgstr ""

msgid ""

"If these attributes are marked as optional in the grammar (using a question "

"mark), the value might be ``None``. 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 :func:`compile`."

msgstr ""

msgid ""

"The :attr:`!_field_types` attribute on each concrete class is a dictionary "

"mapping field names (as also listed in :attr:`_fields`) to their types."

msgstr ""

msgid ""

">>> ast.TypeVar._field_types\n"

"{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr "

"| None}"

msgstr ""

">>> ast.TypeVar._field_types\n"

"{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr "

"| None}"

msgid ""

"Instances of :class:`ast.expr` and :class:`ast.stmt` subclasses have :attr:"

"`lineno`, :attr:`col_offset`, :attr:`end_lineno`, and :attr:`end_col_offset` "

"attributes. The :attr:`lineno` and :attr:`end_lineno` are the first and "

"last line numbers of source text span (1-indexed so the first line is line "

"1) and the :attr:`col_offset` and :attr:`end_col_offset` 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."

msgstr ""

msgid ""

"Note that the end positions are not required by the compiler and are "

"therefore optional. The end offset is *after* the last symbol, for example "

"one can get the source segment of a one-line expression node using "

"``source_line[node.col_offset : node.end_col_offset]``."

msgstr ""

msgid ""

"The constructor of a class :class:`ast.T` parses its arguments as follows:"

msgstr ""

msgid ""

"If there are positional arguments, there must be as many as there are items "

"in :attr:`T._fields`; they will be assigned as attributes of these names."

msgstr ""

msgid ""

"If there are keyword arguments, they will set the attributes of the same "

"names to the given values."

msgstr ""

msgid ""

"For example, to create and populate an :class:`ast.UnaryOp` node, you could "

"use ::"

msgstr ""

msgid ""

"node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),\n"

" lineno=0, col_offset=0)"

msgstr ""

msgid ""

"If a field that is optional in the grammar is omitted from the constructor, "

"it defaults to ``None``. If a list field is omitted, it defaults to the "

"empty list. If a field of type :class:`!ast.expr_context` is omitted, it "

"defaults to :class:`Load() <ast.Load>`. If any other field is omitted, a :"

"exc:`DeprecationWarning` is raised and the AST node will not have this "

"field. In Python 3.15, this condition will raise an error."

msgstr ""

msgid "Class :class:`ast.Constant` is now used for all constants."

msgstr ""

msgid ""

"Simple indices are represented by their value, extended slices are "

"represented as tuples."

msgstr ""

msgid ""

"AST node constructors were changed to provide sensible defaults for omitted "

"fields: optional fields now default to ``None``, list fields default to an "

"empty list, and fields of type :class:`!ast.expr_context` default to :class:"

"`Load() <ast.Load>`. Previously, omitted attributes would not exist on "

"constructed nodes (accessing them raised :exc:`AttributeError`)."

msgstr ""

msgid ""

"The :meth:`~object.__repr__` output of :class:`~ast.AST` nodes includes the "

"values of the node fields."

msgstr ""

msgid ""

"Previous versions of Python provided the AST classes :class:`!ast.Num`, :"

"class:`!ast.Str`, :class:`!ast.Bytes`, :class:`!ast.NameConstant` and :class:"

"`!ast.Ellipsis`, which were deprecated in Python 3.8. These classes were "

"removed in Python 3.14, and their functionality has been replaced with :"

"class:`ast.Constant`."

msgstr ""

msgid ""

"Old classes :class:`!ast.Index` and :class:`!ast.ExtSlice` 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."

msgstr ""

msgid ""

"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."

msgstr ""

msgid ""

"The descriptions of the specific node classes displayed here were initially "

"adapted from the fantastic `Green Tree Snakes <https://greentreesnakes."

"readthedocs.io/en/latest/>`__ project and all its contributors."

msgstr ""

msgid "Root nodes"

msgstr ""

msgid ""

"A Python module, as with :ref:`file input <file-input>`. Node type generated "

"by :func:`ast.parse` in the default ``\"exec\"`` *mode*."

msgstr ""

msgid "``body`` is a :class:`list` of the module's :ref:`ast-statements`."

msgstr ""

msgid ""

"``type_ignores`` is a :class:`list` of the module's type ignore comments; "

"see :func:`ast.parse` for more details."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('x = 1'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='x', ctx=Store())],\n"

" value=Constant(value=1))])"

msgstr ""

">>> print(ast.dump(ast.parse('x = 1'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='x', ctx=Store())],\n"

" value=Constant(value=1))])"

msgid ""

"A single Python :ref:`expression input <expression-input>`. Node type "

"generated by :func:`ast.parse` when *mode* is ``\"eval\"``."

msgstr ""

msgid ""

"``body`` is a single node, one of the :ref:`expression types <ast-"

"expressions>`."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Constant(value=123))"

msgstr ""

">>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Constant(value=123))"

msgid ""

"A single :ref:`interactive input <interactive>`, like in :ref:`tut-interac`. "

"Node type generated by :func:`ast.parse` when *mode* is ``\"single\"``."

msgstr ""

msgid "``body`` is a :class:`list` of :ref:`statement nodes <ast-statements>`."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))\n"

"Interactive(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='x', ctx=Store())],\n"

" value=Constant(value=1)),\n"

" Assign(\n"

" targets=[\n"

" Name(id='y', ctx=Store())],\n"

" value=Constant(value=2))])"

msgstr ""

msgid ""

"A representation of an old-style type comments for functions, as Python "

"versions prior to 3.5 didn't support :pep:`484` annotations. Node type "

"generated by :func:`ast.parse` when *mode* is ``\"func_type\"``."

msgstr ""

msgid "Such type comments would look like this::"

msgstr ""

msgid ""

"def sum_two_number(a, b):\n"

" # type: (int, int) -> int\n"

" return a + b"

msgstr ""

msgid ""

"``argtypes`` is a :class:`list` of :ref:`expression nodes <ast-expressions>`."

msgstr ""

msgid "``returns`` is a single :ref:`expression node <ast-expressions>`."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), "

"indent=4))\n"

"FunctionType(\n"

" argtypes=[\n"

" Name(id='int', ctx=Load()),\n"

" Name(id='str', ctx=Load())],\n"

" returns=Subscript(\n"

" value=Name(id='List', ctx=Load()),\n"

" slice=Name(id='int', ctx=Load()),\n"

" ctx=Load()))"

msgstr ""

msgid "Literals"

msgstr ""

msgid ""

"A constant value. The ``value`` attribute of the ``Constant`` literal "

"contains the Python object it represents. The values represented can be "

"instances of :class:`str`, :class:`bytes`, :class:`int`, :class:`float`, :"

"class:`complex`, and :class:`bool`, and the constants :data:`None` and :data:"

"`Ellipsis`."

msgstr ""

msgid ""

"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 :class:`JoinedStr`."

msgstr ""

msgid ""

"``value`` is any expression node (such as a literal, a variable, or a "

"function call)."

msgstr ""

msgid "``conversion`` is an integer:"

msgstr ""

msgid "-1: no formatting"

msgstr ""

msgid "97 (``ord('a')``): ``!a`` :func:`ASCII <ascii>` formatting"

msgstr ""

msgid "114 (``ord('r')``): ``!r`` :func:`repr` formatting"

msgstr ""

msgid "115 (``ord('s')``): ``!s`` :func:`string <str>` formatting"

msgstr ""

msgid ""

"``format_spec`` is a :class:`JoinedStr` node representing the formatting of "

"the value, or ``None`` if no format was specified. Both ``conversion`` and "

"``format_spec`` can be set at the same time."

msgstr ""

msgid ""

"An f-string, comprising a series of :class:`FormattedValue` and :class:"

"`Constant` nodes."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('f\"sin({a}) is {sin(a):.3}\"', mode='eval'), "

"indent=4))\n"

"Expression(\n"

" body=JoinedStr(\n"

" values=[\n"

" Constant(value='sin('),\n"

" FormattedValue(\n"

" value=Name(id='a', ctx=Load()),\n"

" conversion=-1),\n"

" Constant(value=') is '),\n"

" FormattedValue(\n"

" value=Call(\n"

" func=Name(id='sin', ctx=Load()),\n"

" args=[\n"

" Name(id='a', ctx=Load())]),\n"

" conversion=-1,\n"

" format_spec=JoinedStr(\n"

" values=[\n"

" Constant(value='.3')]))]))"

msgstr ""

msgid ""

"Node representing a template string literal, comprising a series of :class:"

"`Interpolation` and :class:`Constant` nodes. These nodes may be any order, "

"and do not need to be interleaved."

msgstr ""

msgid ""

">>> expr = ast.parse('t\"{name} finished {place:ordinal}\"', mode='eval')\n"

">>> print(ast.dump(expr, indent=4))\n"

"Expression(\n"

" body=TemplateStr(\n"

" values=[\n"

" Interpolation(\n"

" value=Name(id='name', ctx=Load()),\n"

" str='name',\n"

" conversion=-1),\n"

" Constant(value=' finished '),\n"

" Interpolation(\n"

" value=Name(id='place', ctx=Load()),\n"

" str='place',\n"

" conversion=-1,\n"

" format_spec=JoinedStr(\n"

" values=[\n"

" Constant(value='ordinal')]))]))"

msgstr ""

msgid ""

"Node representing a single interpolation field in a template string literal."

msgstr ""

msgid ""

"``value`` is any expression node (such as a literal, a variable, or a "

"function call). This has the same meaning as ``FormattedValue.value``."

msgstr ""

msgid ""

"``str`` is a constant containing the text of the interpolation expression."

msgstr ""

msgid ""

"If ``str`` is set to ``None``, then ``value`` is used to generate code when "

"calling :func:`ast.unparse`. This no longer guarantees that the generated "

"code is identical to the original and is intended for code generation."

msgstr ""

msgid "-1: no conversion"

msgstr ""

msgid "97 (``ord('a')``): ``!a`` :func:`ASCII <ascii>` conversion"

msgstr ""

msgid "114 (``ord('r')``): ``!r`` :func:`repr` conversion"

msgstr ""

msgid "115 (``ord('s')``): ``!s`` :func:`string <str>` conversion"

msgstr ""

msgid "This has the same meaning as ``FormattedValue.conversion``."

msgstr ""

msgid ""

"``format_spec`` is a :class:`JoinedStr` node representing the formatting of "

"the value, or ``None`` if no format was specified. Both ``conversion`` and "

"``format_spec`` can be set at the same time. This has the same meaning as "

"``FormattedValue.format_spec``."

msgstr ""

msgid ""

"A list or tuple. ``elts`` holds a list of nodes representing the elements. "

"``ctx`` is :class:`Store` if the container is an assignment target (i.e. "

"``(x,y)=something``), and :class:`Load` otherwise."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))\n"

"Expression(\n"

" body=List(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)],\n"

" ctx=Load()))\n"

">>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Tuple(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)],\n"

" ctx=Load()))"

msgstr ""

msgid "A set. ``elts`` holds a list of nodes representing the set's elements."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Set(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)]))"

msgstr ""

">>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Set(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)]))"

msgid ""

"A dictionary. ``keys`` and ``values`` hold lists of nodes representing the "

"keys and the values respectively, in matching order (what would be returned "

"when calling :code:`dictionary.keys()` and :code:`dictionary.values()`)."

msgstr ""

msgid ""

"When doing dictionary unpacking using dictionary literals the expression to "

"be expanded goes in the ``values`` list, with a ``None`` at the "

"corresponding position in ``keys``."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('{\"a\":1, **d}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Dict(\n"

" keys=[\n"

" Constant(value='a'),\n"

" None],\n"

" values=[\n"

" Constant(value=1),\n"

" Name(id='d', ctx=Load())]))"

msgstr ""

msgid "Variables"

msgstr ""

msgid ""

"A variable name. ``id`` holds the name as a string, and ``ctx`` is one of "

"the following types."

msgstr ""

msgid ""

"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."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Expr(\n"

" value=Name(id='a', ctx=Load()))])\n"

"\n"

">>> print(ast.dump(ast.parse('a = 1'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='a', ctx=Store())],\n"

" value=Constant(value=1))])\n"

"\n"

">>> print(ast.dump(ast.parse('del a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Delete(\n"

" targets=[\n"

" Name(id='a', ctx=Del())])])"

msgstr ""

msgid ""

"A ``*var`` variable reference. ``value`` holds the variable, typically a :"

"class:`Name` node. This type must be used when building a :class:`Call` node "

"with ``*args``."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('a, *b = it'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Tuple(\n"

" elts=[\n"

" Name(id='a', ctx=Store()),\n"

" Starred(\n"

" value=Name(id='b', ctx=Store()),\n"

" ctx=Store())],\n"

" ctx=Store())],\n"

" value=Name(id='it', ctx=Load()))])"

msgstr ""

msgid "Expressions"

msgstr ""

msgid ""

"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. ``value`` holds one of the other nodes in this section, a :class:"

"`Constant`, a :class:`Name`, a :class:`Lambda`, a :class:`Yield` or :class:"

"`YieldFrom` node."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('-a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Expr(\n"

" value=UnaryOp(\n"

" op=USub(),\n"

" operand=Name(id='a', ctx=Load())))])"

msgstr ""

">>> print(ast.dump(ast.parse('-a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Expr(\n"

" value=UnaryOp(\n"

" op=USub(),\n"

" operand=Name(id='a', ctx=Load())))])"

msgid ""

"A unary operation. ``op`` is the operator, and ``operand`` any expression "

"node."

msgstr ""

msgid ""

"Unary operator tokens. :class:`Not` is the ``not`` keyword, :class:`Invert` "

"is the ``~`` operator."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))\n"

"Expression(\n"

" body=UnaryOp(\n"

" op=Not(),\n"

" operand=Name(id='x', ctx=Load())))"

msgstr ""

">>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))\n"

"Expression(\n"

" body=UnaryOp(\n"

" op=Not(),\n"

" operand=Name(id='x', ctx=Load())))"

msgid ""

"A binary operation (like addition or division). ``op`` is the operator, and "

"``left`` and ``right`` are any expression nodes."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BinOp(\n"

" left=Name(id='x', ctx=Load()),\n"

" op=Add(),\n"

" right=Name(id='y', ctx=Load())))"

msgstr ""

">>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BinOp(\n"

" left=Name(id='x', ctx=Load()),\n"

" op=Add(),\n"

" right=Name(id='y', ctx=Load())))"

msgid "Binary operator tokens."

msgstr ""

msgid ""

"A boolean operation, 'or' or 'and'. ``op`` is :class:`Or` or :class:`And`. "

"``values`` are the values involved. Consecutive operations with the same "

"operator, such as ``a or b or c``, are collapsed into one node with several "

"values."

msgstr ""

msgid "This doesn't include ``not``, which is a :class:`UnaryOp`."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BoolOp(\n"

" op=Or(),\n"

" values=[\n"

" Name(id='x', ctx=Load()),\n"

" Name(id='y', ctx=Load())]))"

msgstr ""

msgid "Boolean operator tokens."

msgstr ""

msgid ""

"A comparison of two or more values. ``left`` is the first value in the "

"comparison, ``ops`` the list of operators, and ``comparators`` the list of "

"values after the first element in the comparison."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Compare(\n"

" left=Constant(value=1),\n"

" ops=[\n"

" LtE(),\n"

" Lt()],\n"

" comparators=[\n"

" Name(id='a', ctx=Load()),\n"

" Constant(value=10)]))"

msgstr ""

msgid "Comparison operator tokens."

msgstr ""

msgid ""

"A function call. ``func`` is the function, which will often be a :class:"

"`Name` or :class:`Attribute` object. Of the arguments:"

msgstr ""

msgid "``args`` holds a list of the arguments passed by position."

msgstr ""

msgid ""

"``keywords`` holds a list of :class:`.keyword` objects representing "

"arguments passed by keyword."

msgstr ""

msgid ""

"The ``args`` and ``keywords`` arguments are optional and default to empty "

"lists."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), "

"indent=4))\n"

"Expression(\n"

" body=Call(\n"

" func=Name(id='func', ctx=Load()),\n"

" args=[\n"

" Name(id='a', ctx=Load()),\n"

" Starred(\n"

" value=Name(id='d', ctx=Load()),\n"

" ctx=Load())],\n"

" keywords=[\n"

" keyword(\n"

" arg='b',\n"

" value=Name(id='c', ctx=Load())),\n"

" keyword(\n"

" value=Name(id='e', ctx=Load()))]))"

msgstr ""

msgid ""

"A keyword argument to a function call or class definition. ``arg`` is a raw "

"string of the parameter name, ``value`` is a node to pass in."

msgstr ""

msgid ""

"An expression such as ``a if b else c``. Each field holds a single node, so "

"in the following example, all three are :class:`Name` nodes."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))\n"

"Expression(\n"

" body=IfExp(\n"

" test=Name(id='b', ctx=Load()),\n"

" body=Name(id='a', ctx=Load()),\n"

" orelse=Name(id='c', ctx=Load())))"

msgstr ""

msgid ""

"Attribute access, e.g. ``d.keys``. ``value`` is a node, typically a :class:"

"`Name`. ``attr`` is a bare string giving the name of the attribute, and "

"``ctx`` is :class:`Load`, :class:`Store` or :class:`Del` according to how "

"the attribute is acted on."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Attribute(\n"

" value=Name(id='snake', ctx=Load()),\n"

" attr='colour',\n"

" ctx=Load()))"

msgstr ""

">>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Attribute(\n"

" value=Name(id='snake', ctx=Load()),\n"

" attr='colour',\n"

" ctx=Load()))"

msgid ""

"A named expression. This AST node is produced by the assignment expressions "

"operator (also known as the walrus operator). As opposed to the :class:"

"`Assign` node in which the first argument can be multiple nodes, in this "

"case both ``target`` and ``value`` must be single nodes."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))\n"

"Expression(\n"

" body=NamedExpr(\n"

" target=Name(id='x', ctx=Store()),\n"

" value=Constant(value=4)))"

msgstr ""

">>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))\n"

"Expression(\n"

" body=NamedExpr(\n"

" target=Name(id='x', ctx=Store()),\n"

" value=Constant(value=4)))"

msgid "Subscripting"

msgstr ""

msgid ""

"A subscript, such as ``l[1]``. ``value`` is the subscripted object (usually "

"sequence or mapping). ``slice`` is an index, slice or key. It can be a :"

"class:`Tuple` and contain a :class:`Slice`. ``ctx`` is :class:`Load`, :class:"

"`Store` or :class:`Del` according to the action performed with the subscript."

msgstr ""

msgid ""

">>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Subscript(\n"

" value=Name(id='l', ctx=Load()),\n"

" slice=Tuple(\n"

" elts=[\n"

" Slice(\n"

" lower=Constant(value=1),\n"

" upper=Constant(value=2)),\n"

" Constant(value=3)],\n"

" ctx=Load()),\n"

" ctx=Load()))"

msgstr ""

msgid ""

"Regular slicing (on the form ``lower:upper`` or ``lower:upper:step``). Can "