# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, 2025.

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-03-04 13:08+0200\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language: ro\n"

"Language-Team: ro <LL@li.org>\n"

"Plural-Forms: nplurals=3; plural=(n==1 ? 0 : (n==0 || (n%100 > 0 && n%100"

" < 20)) ? 1 : 2);\n"

"MIME-Version: 1.0\n"

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

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

"Generated-By: Babel 2.17.0\n"

#: ../../library/ast.rst:2

msgid ":mod:`!ast` --- Abstract Syntax Trees"

msgstr ""

#: ../../library/ast.rst:14

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

msgstr ""

#: ../../library/ast.rst:18

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

#: ../../library/ast.rst:23

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

#: ../../library/ast.rst:33

msgid "Abstract Grammar"

msgstr ""

#: ../../library/ast.rst:35

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

msgstr ""

#: ../../library/ast.rst:37

#, python-brace-format

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"

" | JoinedStr(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 ""

#: ../../library/ast.rst:42

msgid "Node classes"

msgstr ""

#: ../../library/ast.rst:46

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

#: ../../library/ast.rst:51

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

#: ../../library/ast.rst:64

msgid ""

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

"names of all child nodes."

msgstr ""

#: ../../library/ast.rst:67

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

#: ../../library/ast.rst:71

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

#: ../../library/ast.rst:79

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

#: ../../library/ast.rst:82

#, python-brace-format

msgid ""

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

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

"ast.expr | None}"

msgstr ""

#: ../../library/ast.rst:94

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

#: ../../library/ast.rst:103

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

#: ../../library/ast.rst:108

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

msgstr ""

#: ../../library/ast.rst:110

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

#: ../../library/ast.rst:112

msgid ""

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

"names to the given values."

msgstr ""

#: ../../library/ast.rst:115

msgid ""

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

"could use ::"

msgstr ""

#: ../../library/ast.rst:118

msgid ""

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

" lineno=0, col_offset=0)"

msgstr ""

#: ../../library/ast.rst:121

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

#: ../../library/ast.rst:130

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

msgstr ""

#: ../../library/ast.rst:134

msgid ""

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

"represented as tuples."

msgstr ""

#: ../../library/ast.rst:139

msgid ""

"Old classes :class:`!ast.Num`, :class:`!ast.Str`, :class:`!ast.Bytes`, "

":class:`!ast.NameConstant` and :class:`!ast.Ellipsis` 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 ""

#: ../../library/ast.rst:146

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

#: ../../library/ast.rst:153

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

#: ../../library/ast.rst:160

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

#: ../../library/ast.rst:169

msgid "Root nodes"

msgstr ""

#: ../../library/ast.rst:173

msgid ""

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

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

msgstr ""

#: ../../library/ast.rst:176

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

msgstr ""

#: ../../library/ast.rst:178

msgid ""

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

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

msgstr ""

#: ../../library/ast.rst:181

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

#: ../../library/ast.rst:194

msgid ""

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

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

msgstr ""

#: ../../library/ast.rst:197

msgid ""

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

"expressions>`."

msgstr ""

#: ../../library/ast.rst:200 ../../library/ast.rst:270

msgid ""

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

"Expression(\n"

" body=Constant(value=123))"

msgstr ""

#: ../../library/ast.rst:209

msgid ""

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

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

"``\"single\"``."

msgstr ""

#: ../../library/ast.rst:212

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

msgstr ""

#: ../../library/ast.rst:214

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

#: ../../library/ast.rst:231

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

#: ../../library/ast.rst:235

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

msgstr ""

#: ../../library/ast.rst:237

msgid ""

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

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

" return a + b"

msgstr ""

#: ../../library/ast.rst:241

msgid ""

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

"expressions>`."

msgstr ""

#: ../../library/ast.rst:243

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

msgstr ""

#: ../../library/ast.rst:245

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

#: ../../library/ast.rst:261

msgid "Literals"

msgstr ""

#: ../../library/ast.rst:265

msgid ""

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

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

"simple types such as a number, string or ``None``, but also immutable "

"container types (tuples and frozensets) if all of their elements are "

"constant."

msgstr ""

#: ../../library/ast.rst:279

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

#: ../../library/ast.rst:283

msgid ""

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

"function call)."

msgstr ""

#: ../../library/ast.rst:285

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

msgstr ""

#: ../../library/ast.rst:287

msgid "-1: no formatting"

msgstr ""

#: ../../library/ast.rst:288

msgid "115: ``!s`` string formatting"

msgstr ""

#: ../../library/ast.rst:289

msgid "114: ``!r`` repr formatting"

msgstr ""

#: ../../library/ast.rst:290

msgid "97: ``!a`` ascii formatting"

msgstr ""

#: ../../library/ast.rst:292

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

#: ../../library/ast.rst:299

msgid ""

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

":class:`Constant` nodes."

msgstr ""

#: ../../library/ast.rst:302

#, python-brace-format

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

#: ../../library/ast.rst:327

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

#: ../../library/ast.rst:331

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

#: ../../library/ast.rst:353

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

msgstr ""

#: ../../library/ast.rst:355

#, python-brace-format

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

#: ../../library/ast.rst:368

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

#: ../../library/ast.rst:372

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

#: ../../library/ast.rst:376

#, python-brace-format

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

#: ../../library/ast.rst:390

msgid "Variables"

msgstr ""

#: ../../library/ast.rst:394

msgid ""

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

" the following types."

msgstr ""

#: ../../library/ast.rst:402

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

#: ../../library/ast.rst:406

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

#: ../../library/ast.rst:432

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

#: ../../library/ast.rst:436

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

#: ../../library/ast.rst:456

msgid "Expressions"

msgstr ""

#: ../../library/ast.rst:460

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

#: ../../library/ast.rst:465

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

#: ../../library/ast.rst:478

msgid ""

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

" node."

msgstr ""

#: ../../library/ast.rst:487

msgid ""

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

":class:`Invert` is the ``~`` operator."

msgstr ""

#: ../../library/ast.rst:490

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

#: ../../library/ast.rst:501

msgid ""

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

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

msgstr ""

#: ../../library/ast.rst:504

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

#: ../../library/ast.rst:528

msgid "Binary operator tokens."

msgstr ""

#: ../../library/ast.rst:533

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

#: ../../library/ast.rst:538

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

msgstr ""

#: ../../library/ast.rst:540

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

#: ../../library/ast.rst:554

msgid "Boolean operator tokens."

msgstr ""

#: ../../library/ast.rst:559

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

#: ../../library/ast.rst:563

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

#: ../../library/ast.rst:588

msgid "Comparison operator tokens."

msgstr ""

#: ../../library/ast.rst:593

msgid ""

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

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

msgstr ""

#: ../../library/ast.rst:596

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

msgstr ""

#: ../../library/ast.rst:597

msgid ""

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

"arguments passed by keyword."

msgstr ""

#: ../../library/ast.rst:600

msgid ""

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

" lists."

msgstr ""

#: ../../library/ast.rst:602

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

#: ../../library/ast.rst:623

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

#: ../../library/ast.rst:629

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

#: ../../library/ast.rst:632

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

#: ../../library/ast.rst:644

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

#: ../../library/ast.rst:649

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

#: ../../library/ast.rst:661

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

#: ../../library/ast.rst:666

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

#: ../../library/ast.rst:677

msgid "Subscripting"

msgstr ""

#: ../../library/ast.rst:681

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

#: ../../library/ast.rst:687

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

#: ../../library/ast.rst:705

msgid ""

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

"Can occur only inside the *slice* field of :class:`Subscript`, either "

"directly or as an element of :class:`Tuple`."

msgstr ""

#: ../../library/ast.rst:709

msgid ""

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

"Expression(\n"

" body=Subscript(\n"

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

" slice=Slice(\n"

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