ast.po

# 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:
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
# arman mohebali <armanmohebali@outlook.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-08 09:24+0330\n"
"PO-Revision-Date: 2026-10-10 20:54+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

msgid ":mod:`!ast` --- Abstract syntax trees"
msgstr ":mod:`!ast` --- درخت‌های سینتکس انتزاعی"

msgid "**Source code:** :source:`Lib/ast.py`"
msgstr "**کد منبع:** :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 "ماژول :mod:`!ast` به برنامه‌های پایتون کمک می‌کند تا درخت‌های دستور زبان سینتکس انتزاعی پایتون را پردازش کنند. خود سینتکس انتزاعی ممکن است با هر انتشار پایتون تغییر کند؛ این ماژول به شما کمک می‌کند تا به‌صورت برنامه‌ای دریابید دستور زبان جاری چگونه است."

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 "می‌توان یک درخت سینتکس انتزاعی را با ارسال :data:`ast.PyCF_ONLY_AST` به‌عنوان پرچم به تابع توکار :func:`compile` یا با استفاده از تابع کمکی :func:`parse` ارائه‌شده در این ماژول، تولید کرد. نتیجه درختی از اشیاء خواهد بود که کلاس‌های آن همگی از :class:`ast.AST` ارث‌بری می‌کنند. می‌توان یک درخت سینتکس انتزاعی را با استفاده از تابع توکار :func:`compile` به یک شیء کد پایتون کامپایل کرد."

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, int? is_lazy)\n"
"          | ImportFrom(identifier? module, alias* names, int? level, int? is_lazy)\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 ""
"-- 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, int? is_lazy)\n"
"          | ImportFrom(identifier? module, alias* names, int? level, int? is_lazy)\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"

msgid "Node classes"
msgstr "کلاس‌های گره"

msgid "This is the abstract 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 "این کلاس، کلاس پایه‌ی انتزاعی همه‌ی کلاس‌های گره AST است. کلاس‌های واقعی گره از پرونده‌ی :file:`Parser/Python.asdl` مشتق می‌شوند که در :ref:`بالا <abstract-grammar>` بازتولید شده است. این کلاس‌ها در ماژول Cِ :mod:`!_ast` تعریف شده‌اند و در :mod:`!ast` بازصدور می‌شوند."

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 "برای هر نماد سمت چپ در دستور زبان انتزاعی، یک کلاس تعریف شده است (برای مثال، :class:`ast.stmt` یا :class:`ast.expr`). علاوه بر این، برای هر سازنده در سمت راست، یک کلاس تعریف شده است؛ این کلاس‌ها از کلاس‌های مربوط به درخت‌های سمت چپ ارث می‌برند. برای مثال، :class:`ast.BinOp` از :class:`ast.expr` ارث می‌برد. برای قواعد تولید دارای جایگزین‌ها (معروف به «مجموع‌ها»)، کلاس سمت چپ انتزاعی است: تنها نمونه‌هایی از گره‌های سازنده‌ی خاص ایجاد می‌شوند."

msgid "Each concrete class has an attribute :attr:`!_fields` which gives the names of all child nodes."
msgstr "هر کلاس عینی یک ویژگی :attr:`!_fields` دارد که نام همه‌ی گره‌های فرزند را می‌دهد."

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 "هر نمونه از یک کلاس مشخص، به ازای هر گره فرزند یک ویژگی دارد که نوع آن در گرامر تعریف شده است. برای مثال، نمونه‌های :class:`ast.BinOp` یک ویژگی :attr:`left` از نوع :class:`ast.expr` دارند."

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 "اگر این ویژگی‌ها در گرامر به‌عنوان اختیاری علامت‌گذاری شده باشند (با استفاده از علامت سؤال)، مقدار ممکن است ``None`` باشد. اگر ویژگی‌ها بتوانند صفر یا بیشتر مقدار داشته باشند (با ستاره علامت‌گذاری شده باشند)، مقادیر به‌صورت فهرست‌های پایتون نمایش داده می‌شوند. هنگام کامپایل یک AST با :func:`compile`، تمام ویژگی‌های ممکن باید موجود باشند و مقادیر معتبر داشته باشند."

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 "ویژگی :attr:`!_field_types` در هر کلاس عینی، یک دیکشنری است که نام فیلدها (که در :attr:`_fields` نیز فهرست شده‌اند) را به نوع آن‌ها نگاشت می‌کند."

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 "نمونه‌های زیرکلاس‌های :class:`ast.expr` و :class:`ast.stmt` دارای ویژگی‌های :attr:`lineno`، :attr:`col_offset`، :attr:`end_lineno` و :attr:`end_col_offset` هستند. :attr:`lineno` و :attr:`end_lineno` شماره‌های خط اول و آخر بازه‌ی متن منبع هستند (با اندیس ۱، بنابراین اولین خط، خط ۱ است) و :attr:`col_offset` و :attr:`end_col_offset` آفست‌های بایتی UTF-8 متناظر با اولین و آخرین توکن‌هایی هستند که گره را تولید کرده‌اند. آفست UTF-8 ثبت می‌شود زیرا پارسر به‌صورت داخلی از UTF-8 استفاده می‌کند."

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 "توجه داشته باشید که موقعیت‌های پایانی مورد نیاز کامپایلر نیستند و بنابراین اختیاری‌اند. آفست پایانی *پس از* آخرین نماد است؛ برای مثال می‌توان بخش منبع یک گره عبارت یک‌خطی را با استفاده از ``source_line[node.col_offset : node.end_col_offset]`` به دست آورد."

msgid "The constructor of a class :class:`ast.T` parses its arguments as follows:"
msgstr "سازنده‌ی کلاس :class:`ast.T` آرگومان‌های خود را به‌صورت زیر تجزیه می‌کند:"

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 "اگر آرگومان‌های جایگاهی وجود داشته باشند، باید به تعداد آیتم‌های :attr:`T._fields` باشند؛ آن‌ها به‌عنوان ویژگی‌هایی با این نام‌ها انتساب داده می‌شوند."

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 "برای مثال، برای ایجاد و پر کردن یک گره :class:`ast.UnaryOp`، می‌توانید از کد زیر استفاده کنید ::"

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

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 "اگر فیلدی که در گرامر اختیاری است، در سازنده آورده نشود، مقدار پیش‌فرض آن ``None`` خواهد بود. اگر یک فیلد فهرستی آورده نشود، مقدار پیش‌فرض آن فهرست خالی است. اگر فیلدی از نوع :class:`!ast.expr_context` آورده نشود، مقدار پیش‌فرض آن :class:`Load() <ast.Load>` خواهد بود. اگر هر فیلد دیگری آورده نشود، یک :exc:`DeprecationWarning` پرتاب می‌شود و گره AST این فیلد را نخواهد داشت. در پایتون 3.15، این وضعیت یک خطا پرتاب خواهد کرد."

msgid "Class :class:`ast.Constant` is now used for all constants."
msgstr "اکنون از کلاس :class:`ast.Constant` برای همه‌ی ثابت‌ها استفاده می‌شود."

msgid "Simple indices are represented by their value, extended slices are represented as tuples."
msgstr "اندیس‌های ساده با مقدارشان نمایش داده می‌شوند، اسلایس‌های گسترده (extended slices) به‌صورت تاپل‌ها نمایش داده می‌شوند."

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 "سازنده‌های گره AST تغییر کردند تا پیش‌فرض‌های معقولی برای فیلدهای از قلم افتاده فراهم کنند: اکنون مقدار پیش‌فرض فیلدهای اختیاری ``None`` است، مقدار پیش‌فرض فیلدهای فهرستی یک فهرست خالی است، و مقدار پیش‌فرض فیلدهایی از نوع :class:`!ast.expr_context` برابر :class:`Load() <ast.Load>` است. پیش از این، ویژگی‌های از قلم افتاده در گره‌های ساخته‌شده وجود نداشتند (دسترسی به آن‌ها باعث پرتاب :exc:`AttributeError` می‌شد)."

msgid "The :meth:`~object.__repr__` output of :class:`~ast.AST` nodes includes the values of the node fields."
msgstr "خروجی :meth:`~object.__repr__` گره‌های :class:`~ast.AST` شامل مقادیر فیلدهای گره است."

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 "نسخه‌های پیشین پایتون، کلاس‌های AST یعنی :class:`!ast.Num`، :class:`!ast.Str`، :class:`!ast.Bytes`، :class:`!ast.NameConstant` و :class:`!ast.Ellipsis` را فراهم می‌کردند که در پایتون 3.8 منسوخ شده بودند. این کلاس‌ها در پایتون 3.14 حذف شدند و کارکرد آن‌ها با :class:`ast.Constant` جایگزین شده است."

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 "کلاس‌های قدیمی :class:`!ast.Index` و :class:`!ast.ExtSlice` هنوز در دسترس هستند، اما در نسخه‌های آینده پایتون حذف خواهند شد. تا آن زمان، نمونه‌سازی از آن‌ها یک نمونه از کلاسی دیگر را برمی‌گرداند."

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. These cases now raise a :exc:`TypeError`."
msgstr "نسخه‌های قبلی پایتون اجازه می‌دادند گره‌های درخت نحوی انتزاعی (AST) که فاقد فیلدهای الزامی بودند، ایجاد شوند. به همین ترتیب، سازنده‌های گره‌های AST به آرگومان کلیدواژه‌ای دلخواهی اجازه می‌دادند که به‌عنوان ویژگی‌های گره AST تنظیم شوند، حتی اگر با هیچ‌یک از فیلدهای گره AST مطابقت نداشتند. این موارد اکنون یک :exc:`TypeError` ایجاد می‌کنند."

msgid "In the :ref:`grammar above <abstract-grammar>`, the AST node classes that correspond to production rules with variants (aka \"sums\") are abstract classes. Previous versions of Python allowed for the creation of direct instances of these abstract node classes. This behavior is deprecated and will be removed in Python 3.20."
msgstr "در :ref:`دستور زبان بالا <abstract-grammar>`، کلاس‌های گره AST که با قواعد تولید دارای نوع (معروف به «sums») مطابقت دارند، کلاس‌های انتزاعی هستند. نسخه‌های قبلی پایتون امکان ایجاد نمونه‌های مستقیم از این کلاس‌های گره انتزاعی را فراهم می‌کردند. این رفتار منسوخ شده است و در پایتون ۳.۲۰ حذف خواهد شد."

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 "توضیحات کلاس‌های گره خاصی که در اینجا نمایش داده شده‌اند، در ابتدا از پروژه‌ی فوق‌العاده‌ی `Green Tree Snakes <https://greentreesnakes.readthedocs.io/en/latest/>`__ و همه‌ی مشارکت‌کنندگان آن اقتباس شده‌اند."

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 "یک ماژول پایتون، مانند :ref:`ورودی پرونده <file-input>`. نوع گره‌ای که توسط :func:`ast.parse` در *حالت* پیش‌فرض ``\"exec\"`` تولید می‌شود."

msgid "``body`` is a :class:`list` of the module's :ref:`ast-statements`."
msgstr "``body`` یک :class:`list` از :ref:`ast-statements` ماژول است."

msgid "``type_ignores`` is a :class:`list` of the module's type ignore comments; see :func:`ast.parse` for more details."
msgstr "``type_ignores`` یک :class:`list` از کامنت‌ها نادیده‌گرفتن نوع ماژول است؛ برای جزئیات بیشتر :func:`ast.parse` را ببینید."

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 "یک :ref:`ورودی عبارت <expression-input>` پایتون. نوع گره‌ای که توسط :func:`ast.parse` هنگامی که *mode* برابر ``\"eval\"`` باشد، تولید می‌شود."

msgid "``body`` is a single node, one of the :ref:`expression types <ast-expressions>`."
msgstr "``body`` یک گره واحد است، یکی از :ref:`انواع عبارت <ast-expressions>`."

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 "یک :ref:`ورودی تعاملی <interactive>` واحد، مانند :ref:`tut-interac`. نوع گره تولیدشده توسط :func:`ast.parse` هنگامی که *mode* برابر ``\"single\"`` است."

msgid "``body`` is a :class:`list` of :ref:`statement nodes <ast-statements>`."
msgstr "``body`` یک :class:`list` از :ref:`گره‌های دستور <ast-statements>` است."

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

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 "بازنمایی‌ای از کامنت‌های نوع به سبک قدیمی برای توابع، زیرا نسخه‌های پایتون پیش از 3.5 از حاشیه‌نویسی‌های :pep:`484` پشتیبانی نمی‌کردند. نوع گره تولیدشده توسط :func:`ast.parse` هنگامی که *mode* برابر ``\"func_type\"`` باشد."

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 ""
"def sum_two_number(a, b):\n"
"    # type: (int, int) -> int\n"
"    return a + b"

msgid "``argtypes`` is a :class:`list` of :ref:`expression nodes <ast-expressions>`."
msgstr "``argtypes`` یک :class:`list` از :ref:`گره‌های عبارت <ast-expressions>` است."

msgid "``returns`` is a single :ref:`expression node <ast-expressions>`."
msgstr "``returns`` یک :ref:`گره عبارت <ast-expressions>` است."

msgid ""
">>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))\n"
"FunctionType(\n"
"    argtypes=[\n"
"        Name(id='int'),\n"
"        Name(id='str')],\n"
"    returns=Subscript(\n"
"        value=Name(id='List'),\n"
"        slice=Name(id='int')))"
msgstr ""
">>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))\n"
"FunctionType(\n"
"    argtypes=[\n"
"        Name(id='int'),\n"
"        Name(id='str')],\n"
"    returns=Subscript(\n"
"        value=Name(id='List'),\n"
"        slice=Name(id='int')))"

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 "یک مقدار ثابت. ویژگی ``value`` در لفظی ``Constant`` شامل شیء پایتونی بازنمایی‌شده توسط آن است. مقادیر بازنمایی‌شده می‌توانند نمونه‌هایی از :class:`str`، :class:`bytes`، :class:`int`، :class:`float`، :class:`complex` و :class:`bool`، و ثابت‌های :data:`None` و :data:`Ellipsis` باشند."

msgid "The ``kind`` attribute is an optional string. For string literals with a ``u`` prefix, ``kind`` is set to ``'u'``. For all other constants, ``kind`` is ``None``."
msgstr "ویژگی ``kind`` یک رشته اختیاری است. برای مقادیر لفظی رشته‌ای با پیشوند ``u``، ``kind`` روی ``'u'`` تنظیم می‌شود. برای همه‌ی ثابت‌های دیگر، ``kind`` برابر ``None`` است."

msgid ""
">>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))\n"
"Expression(\n"
"    body=Constant(value=123))\n"
">>> print(ast.dump(ast.parse(\"u'hello'\", mode='eval'), indent=4))\n"
"Expression(\n"
"    body=Constant(value='hello', kind='u'))"
msgstr ""
">>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))\n"
"Expression(\n"
"    body=Constant(value=123))\n"
">>> print(ast.dump(ast.parse(\"u'hello'\", mode='eval'), indent=4))\n"
"Expression(\n"
"    body=Constant(value='hello', kind='u'))"

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 "گره‌ای که نشان‌دهنده‌ی یک فیلد قالب‌بندی منفرد در یک اف‌استرینگ است. اگر رشته شامل یک فیلد قالب‌بندی منفرد و هیچ چیز دیگری باشد، گره می‌تواند جداگانه باشد؛ در غیر این صورت در :class:`JoinedStr` ظاهر می‌شود."

msgid "``value`` is any expression node (such as a literal, a variable, or a function call)."
msgstr "``value`` هر گره عبارتی است (مانند یک لفظی، یک متغیر، یا یک فراخوانی تابع)."

msgid "``conversion`` is an integer:"
msgstr "``conversion`` یک عدد صحیح است:"

msgid "-1: no formatting"
msgstr "-1: بدون قالب‌بندی"

msgid "97 (``ord('a')``): ``!a`` :func:`ASCII <ascii>` formatting"
msgstr "۹۷ (``ord('a')``): ``!a`` قالب‌بندی :func:`ASCII <ascii>`"

msgid "114 (``ord('r')``): ``!r`` :func:`repr` formatting"
msgstr "۱۱۴ (``ord('r')``): قالب‌بندی ``!r`` با :func:`repr`"

msgid "115 (``ord('s')``): ``!s`` :func:`string <str>` formatting"
msgstr "۱۱۵ (``ord('s')``): ``!s`` قالب‌بندی :func:`string <str>`"

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 "``format_spec`` یک گره :class:`JoinedStr` است که قالب‌بندی مقدار را نشان می‌دهد، یا اگر قالبی مشخص نشده باشد، ``None`` است. هر دو ``conversion`` و ``format_spec`` را می‌توان همزمان تنظیم کرد."

msgid "An f-string, comprising a series of :class:`FormattedValue` and :class:`Constant` nodes."
msgstr "یک اف‌استرینگ، شامل مجموعه‌ای از گره‌های :class:`FormattedValue` و :class:`Constant`."

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'),\n"
"                conversion=-1),\n"
"            Constant(value=') is '),\n"
"            FormattedValue(\n"
"                value=Call(\n"
"                    func=Name(id='sin'),\n"
"                    args=[\n"
"                        Name(id='a')]),\n"
"                conversion=-1,\n"
"                format_spec=JoinedStr(\n"
"                    values=[\n"
"                        Constant(value='.3')]))]))"
msgstr ""
">>> 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'),\n"
"                conversion=-1),\n"
"            Constant(value=') is '),\n"
"            FormattedValue(\n"
"                value=Call(\n"
"                    func=Name(id='sin'),\n"
"                    args=[\n"
"                        Name(id='a')]),\n"
"                conversion=-1,\n"
"                format_spec=JoinedStr(\n"
"                    values=[\n"
"                        Constant(value='.3')]))]))"

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 "گره‌ای که یک لفظی رشته‌ی الگویی (template string literal) را نشان می‌دهد و شامل دنباله‌ای از گره‌های :class:`Interpolation` و :class:`Constant` است. این گره‌ها می‌توانند به هر ترتیبی باشند و نیازی نیست به‌صورت یک‌درمیان باشند."

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'),\n"
"                str='name',\n"
"                conversion=-1),\n"
"            Constant(value=' finished '),\n"
"            Interpolation(\n"
"                value=Name(id='place'),\n"
"                str='place',\n"
"                conversion=-1,\n"
"                format_spec=JoinedStr(\n"
"                    values=[\n"
"                        Constant(value='ordinal')]))]))"
msgstr ""
">>> 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'),\n"
"                str='name',\n"
"                conversion=-1),\n"
"            Constant(value=' finished '),\n"
"            Interpolation(\n"
"                value=Name(id='place'),\n"
"                str='place',\n"
"                conversion=-1,\n"
"                format_spec=JoinedStr(\n"
"                    values=[\n"
"                        Constant(value='ordinal')]))]))"

msgid "Node representing a single interpolation field in a template string literal."
msgstr "گره‌ای که نشان‌دهنده‌ی یک فیلد درون‌یابی (interpolation field) در یک لفظی رشته‌ی الگو  است."

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 "``value`` می‌تواند هر گره‌ی عبارت باشد (مانند یک لفظی، یک متغیر، یا یک فراخوانی تابع). این همان معنای ``FormattedValue.value`` را دارد."

msgid "``str`` is a constant containing the text of the interpolation expression."
msgstr "``str`` یک ثابت است که حاوی متن عبارت درون‌یابی است."

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 "اگر ``str`` روی ``None`` تنظیم شود، هنگام فراخوانی :func:`ast.unparse` از ``value`` برای تولید کد استفاده می‌شود. در این حالت دیگر تضمین نمی‌شود که کد تولیدشده با کد اصلی یکسان باشد و این برای تولید کد در نظر گرفته شده است."

msgid "-1: no conversion"
msgstr "-1: بدون تبدیل"

msgid "97 (``ord('a')``): ``!a`` :func:`ASCII <ascii>` conversion"
msgstr "۹۷ (``ord('a')``): تبدیل ``!a`` به :func:`ASCII <ascii>`"

msgid "114 (``ord('r')``): ``!r`` :func:`repr` conversion"
msgstr "۱۱۴ (``ord('r')``): تبدیل ``!r`` به :func:`repr`"

msgid "115 (``ord('s')``): ``!s`` :func:`string <str>` conversion"
msgstr "۱۱۵ (``ord('s')``): تبدیل :func:`string <str>` با ``!s``"

msgid "This has the same meaning as ``FormattedValue.conversion``."
msgstr "این همان معنای ``FormattedValue.conversion`` را دارد."

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 "``format_spec`` یک گره :class:`JoinedStr` است که قالب‌بندی مقدار را نشان می‌دهد، یا اگر هیچ قالبی مشخص نشده باشد، ``None`` است. می‌توان هر دو ``conversion`` و ``format_spec`` را همزمان تنظیم کرد. این همان معنای ``FormattedValue.format_spec`` را دارد."

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 "یک فهرست یا تاپل. ``elts`` شامل فهرستی از گره‌های نشان‌دهنده عناصر است. اگر ظرف هدف انتساب باشد (یعنی ``(x,y)=something``)، ``ctx`` :class:`Store` است و در غیر این صورت :class:`Load` است."

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"
">>> 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)]))"
msgstr ""
">>> 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"
">>> 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)]))"

msgid "A set. ``elts`` holds a list of nodes representing the set's elements."
msgstr "یک مجموعه. ``elts`` شامل فهرستی از گره‌هایی است که عناصر مجموعه را نشان می‌دهند."

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 "یک دیکشنری. ``keys`` و ``values`` فهرست‌هایی از گره‌ها را نگه می‌دارند که به‌ترتیب نشان‌دهنده‌ی کلیدها و مقدارها هستند و ترتیب آن‌ها با یکدیگر مطابقت دارد (آنچه هنگام فراخوانی :code:`dictionary.keys()` و :code:`dictionary.values()` بازگردانده می‌شود)."

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 "هنگام انجام واگشایی دیکشنری با استفاده از مقادیر لفظی دیکشنری، عبارت مورد واگشایی در فهرست ``values`` قرار می‌گیرد و یک ``None`` در موقعیت متناظر در ``keys`` قرار می‌گیرد."

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')]))"
msgstr ""
">>> 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')]))"

msgid "Variables"
msgstr "متغیرها"

msgid "A variable name. ``id`` holds the name as a string, and ``ctx`` is one of the following types."
msgstr "نام یک متغیر. ``id`` نام را به‌عنوان یک رشته نگه می‌دارد، و ``ctx`` یکی از انواع زیر است."

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'))])\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 ""
">>> print(ast.dump(ast.parse('a'), indent=4))\n"
"Module(\n"
"    body=[\n"
"        Expr(\n"
"            value=Name(id='a'))])\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())])])"

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 "یک ارجاع به متغیر ``*var``. ``value`` متغیر را نگه می‌دارد، که معمولاً یک گره :class:`Name` است. هنگام ساخت یک گره :class:`Call` با ``*args`` باید از این نوع استفاده شود."

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'))])"
msgstr ""
">>> 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'))])"

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 "هنگامی که یک عبارت، مانند فراخوانی تابع، به‌تنهایی به‌عنوان یک دستور ظاهر می‌شود و مقدار بازگشتی آن استفاده یا ذخیره نمی‌شود، در این ظرف قرار می‌گیرد. ``value`` یکی از گره‌های دیگر در این بخش را نگه می‌دارد: یک گره :class:`Constant`، یک گره :class:`Name`، یک گره :class:`Lambda`، یک گره :class:`Yield` یا یک گره :class:`YieldFrom`."

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')))])"
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')))])"

msgid "A unary operation. ``op`` is the operator, and ``operand`` any expression node."
msgstr "یک عملیات یک‌عملوندی. ``op`` عملگر است و ``operand`` هر گره‌ی عبارت است."

msgid "Unary operator tokens. :class:`Not` is the ``not`` keyword, :class:`Invert` is the ``~`` operator."
msgstr "توکن‌های عملگر یک‌عملوندی. :class:`Not` همان کلیدواژه ``not`` است، :class:`Invert` همان عملگر ``~`` است."

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

msgid "A binary operation (like addition or division). ``op`` is the operator, and ``left`` and ``right`` are any expression nodes."
msgstr "یک عملیات دودویی (مانند جمع یا تقسیم). ``op`` عملگر است و ``left`` و ``right`` گره‌های عبارت دلخواه هستند."

msgid ""
">>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))\n"
"Expression(\n"
"    body=BinOp(\n"
"        left=Name(id='x'),\n"
"        op=Add(),\n"
"        right=Name(id='y')))"
msgstr ""
">>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))\n"
"Expression(\n"
"    body=BinOp(\n"
"        left=Name(id='x'),\n"
"        op=Add(),\n"
"        right=Name(id='y')))"

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 "یک عملیات بولی، 'or' یا 'and'. ``op`` :class:`Or` یا :class:`And` است. ``values`` مقادیر درگیر هستند. عملیات‌های متوالی با همان عملگر، مانند ``a or b or c``، در یک گره با چند مقدار ادغام می‌شوند."

msgid "This doesn't include ``not``, which is a :class:`UnaryOp`."
msgstr "این شامل ``not`` نمی‌شود، که یک :class:`UnaryOp` است."

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'),\n"
"            Name(id='y')]))"
msgstr ""
">>> 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'),\n"
"            Name(id='y')]))"

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 "مقایسه‌ی دو یا چند مقدار. ``left`` نخستین مقدار در مقایسه است، ``ops`` فهرست عملگرها است، و ``comparators`` فهرست مقادیر پس از نخستین عنصر در مقایسه است."

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'),\n"
"            Constant(value=10)]))"
msgstr ""
">>> 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'),\n"
"            Constant(value=10)]))"

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 "یک فراخوانی تابع. ``func`` تابع است، که اغلب یک شیء :class:`Name` یا :class:`Attribute` خواهد بود. از میان آرگومان‌ها:"

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