# 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-03-25 14:54+0000\n"

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

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

"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"

"ja/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: ja\n"

"Plural-Forms: nplurals=1; plural=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 "**ソースコード:** :source:`Lib/ast.py`"

#: ../../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 ""

"抽象構文木を作成するには、 :data:`ast.PyCF_ONLY_AST` を組み込み関数 :func:"

"`compile` のフラグとして渡すか、あるいはこのモジュールで提供されているヘル"

"パー関数 :func:`parse` を使います。その結果は、 :class:`ast.AST` を継承したク"

"ラスのオブジェクトのツリーとなります。抽象構文木は組み込み関数 :func:"

"`compile` を使って Python コード・オブジェクトにコンパイルすることができま"

"す。"

#: ../../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

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

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

msgid "Node classes"

msgstr "Node クラス"

#: ../../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 ""

"抽象文法の左辺のシンボル一つずつにそれぞれ一つのクラスがあります (たとえば :"

"class:`ast.stmt` や :class:`ast.expr`)。それに加えて、右辺のコンストラクタ一"

"つずつにそれぞれ一つのクラスがあり、これらのクラスは左辺のツリーのクラスを継"

"承しています。たとえば、 :class:`ast.BinOp` は :class:`ast.expr` から継承して"

"います。代替を伴った生成規則 (production rules with alternatives) (別名 "

"\"sums\") の場合、左辺は抽象クラスとなり、特定のコンストラクタ・ノードのイン"

"スタンスのみが作成されます。"

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

msgid ""

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

"of all child nodes."

msgstr ""

"各具象クラスは属性 :attr:`!_fields` を持っており、すべての子ノードの名前をそ"

"こに保持しています。"

#: ../../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 ""

"具象クラスのインスタンスは、各子ノードに対してそれぞれひとつの属性を持ってい"

"ます。この属性は、文法で定義された型となります。たとえば :class:`ast.BinOp` "

"のインスタンスは :attr:`left` という属性を持っており、その型は :class:`ast."

"expr` です。"

#: ../../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 ""

"これらの属性が、文法上 (クエスチョンマークを用いて) オプションであるとマーク"

"されている場合は、その値が ``None`` となることもあります。属性が0個以上の複数"

"の値をとりうる場合 (アスタリスクでマークされている場合) は、値は Python のリ"

"ストで表されます。全ての属性は AST を :func:`compile` でコンパイルする際には"

"存在しなければならず、そして妥当な値でなければなりません。"

#: ../../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

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

":class:`ast.expr` や :class:`ast.stmt` のサブクラスのインスタンスは :attr:"

"`lineno`, :attr:`col_offset`, :attr:`end_lineno`, および :attr:"

"`end_col_offset` 属性を持ちます。 :attr:`lineno` と :attr:`end_lineno` はソー"

"ステキストの範囲を最初と最後の行番号で表し (1 から数え始めるので、最初の行の"

"行番号は 1 となります)、 :attr:`col_offset` と :attr:`end_col_offset` はノー"

"ドが生成した最初と最後のトークンの UTF-8 バイトオフセットです。 UTF-8 オフ"

"セットはパーサが内部で使用するので記録されます。"

#: ../../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 ""

"コンパイラは終了位置を必要としないことに注意してください。このため終了位置は"

"省略可能です。終了位置を示すオフセットは最後のシンボルの *後の位置* になりま"

"す。例えば一行で書かれた式のソースコードのセグメントは ``source_line[node."

"col_offset : node.end_col_offset]`` により取得できます。"

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

msgid ""

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

msgstr "クラス :class:`ast.T` のコンストラクタは引数を次のように解析します:"

#: ../../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 ""

"位置引数があるとすれば、 :attr:`T._fields` にあるのと同じだけの個数が無ければ"

"なりません。これらの引数はそこにある名前を持った属性として割り当てられます。"

#: ../../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 ""

"たとえば、 :class:`ast.UnaryOp` ノードを生成して属性を埋めるには、次のように"

"することができます ::"

#: ../../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 ":class:`ast.Constant` が全ての定数に使われるようになりました。"

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

msgid ""

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

"represented as tuples."

msgstr ""

"単純なインデックスはその値で表現され、幅を持つスライスはタプルで表現されま"

"す。"

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

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

#: ../../library/ast.rst:147

msgid ""

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

"values of the node fields."

msgstr ""

#: ../../library/ast.rst:152

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

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

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:167

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:174

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/>`__ プロジェクトと"

"そのすべての貢献者の成果物をもとにしています。"

#: ../../library/ast.rst:183

msgid "Root nodes"

msgstr ""

#: ../../library/ast.rst:187

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:190

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

msgstr ""

#: ../../library/ast.rst:192

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:195

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:208

msgid ""

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

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

msgstr ""

#: ../../library/ast.rst:211

msgid ""

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

"expressions>`."

msgstr ""

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

msgid ""

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

"Expression(\n"

" body=Constant(value=123))"

msgstr ""

#: ../../library/ast.rst:223

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:226

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

msgstr ""

#: ../../library/ast.rst:228

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:245

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:249

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

msgstr ""

#: ../../library/ast.rst:251

msgid ""

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

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

" return a + b"

msgstr ""

#: ../../library/ast.rst:255

msgid ""

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

msgstr ""

#: ../../library/ast.rst:257

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

msgstr ""

#: ../../library/ast.rst:259

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:275

msgid "Literals"

msgstr "リテラル"

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

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

#: ../../library/ast.rst:293

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

"このノードは f-string における単一の書式指定置換フィールドを表現します。文字"

"列が単一の置換フィールドしか持たず、他に何も含まない場合は、ノードは単独で存"

"在できます。そうでない場合は :class:`JoinedStr` の一部としてあらわれます。"

#: ../../library/ast.rst:297

msgid ""

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

"function call)."

msgstr ""

"``value`` は式ツリーのノードのいずれか (リテラル、変数、関数呼び出しなど) で"

"す。"

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

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

msgstr "``conversion`` は整数です:"

#: ../../library/ast.rst:301

msgid "-1: no formatting"

msgstr "-1: 書式指定なし"

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

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

msgstr ""

#: ../../library/ast.rst:303

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

msgstr ""

#: ../../library/ast.rst:304

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

msgstr ""

#: ../../library/ast.rst:306

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`` を同時"

"に設定することができます。"

#: ../../library/ast.rst:313

msgid ""

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

"`Constant` nodes."

msgstr ""

":class:`FormattedValue` ノードと :class:`Constant` ノードの集まりからなる f-"

"string です。"

#: ../../library/ast.rst:316

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:342

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

#: ../../library/ast.rst:346

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

#: ../../library/ast.rst:370

msgid ""

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

msgstr ""

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

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

#: ../../library/ast.rst:375

msgid ""

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

msgstr ""

#: ../../library/ast.rst:377

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

#: ../../library/ast.rst:383

msgid "-1: no conversion"

msgstr ""

#: ../../library/ast.rst:384

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

msgstr ""

#: ../../library/ast.rst:385

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

msgstr ""

#: ../../library/ast.rst:386

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

msgstr ""

#: ../../library/ast.rst:388

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

msgstr ""

#: ../../library/ast.rst:389

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

#: ../../library/ast.rst:398

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`` は内包する要素を表現するノードの"

"リストを保持します。 ``ctx`` はコンテナが代入のターゲットである場合 (たとえ"

"ば ``(x,y)=something`` のような場合) は :class:`Store` であり、そうでない場合"

"は :class:`Load` です。"

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

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:424

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

msgstr ""

"集合 (set) をあらわします。 ``elts`` は集合の各要素を表現するノードのリストを"

"保持します。"

#: ../../library/ast.rst:426

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:439

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()` を呼び出したときに返される順序で) 保持します。"

#: ../../library/ast.rst:443

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`` リストに入り、 ``keys`` の対応する位置には ``None`` が入ります。"

#: ../../library/ast.rst:447

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:461

msgid "Variables"

msgstr "変数"

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

msgid ""

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

"the following types."

msgstr ""

"変数名をあらわします。 ``id`` は変数名を文字列で保持し、 ``ctx`` は以下に示す"

"型のいずれかです。"

#: ../../library/ast.rst:473

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

"変数の参照は変数の値をロードするか、新しい値を割り当てるか、または値を削除す"

"るために使うことができます。変数の参照はこれら3つの場合を区別するためのコンテ"

"キストによって与えられます。"

#: ../../library/ast.rst:477

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:503

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` ノード、を保持します。この型は ``*args`` を伴う関数呼び出しノー"

"ド :class:`Call` を構築する際に使用します。 "

#: ../../library/ast.rst:507

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:527

msgid "Expressions"

msgstr "式 (expression)"

#: ../../library/ast.rst:531

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` ノードのいずれ"

"かを保持します。"

#: ../../library/ast.rst:536

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:549

msgid ""

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

"node."

msgstr ""

"単項演算をあらわします。 ``op`` は演算子で、 ``operand`` は任意の式ツリーの"

"ノードです。"

#: ../../library/ast.rst:558

msgid ""

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

"is the ``~`` operator."

msgstr ""

"単項演算の演算子をあらわします。 :class:`Not` は論理否定キーワード ``not`` で"

"あり、 :class:`Invert` はビット反転演算子 ``~`` です。"

#: ../../library/ast.rst:561

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:572

msgid ""

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

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

msgstr ""

"(加算や減算のような) 二項演算をあらわします。 ``op`` は演算子、 ``left`` と "

"``right`` は任意の式ツリーのノードです。"

#: ../../library/ast.rst:575

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:599

msgid "Binary operator tokens."

msgstr "二項演算の演算子をあらわします。"

#: ../../library/ast.rst:604

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`` のよう"

"に同じ演算子を使う連続した演算は、複数の値を持った単一のノードとして表現され"

"ます。"

#: ../../library/ast.rst:609

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

msgstr "``not`` は単項演算 :class:`UnaryOp` のため、ここには含まれません。"

#: ../../library/ast.rst:611

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:625

msgid "Boolean operator tokens."