expressions.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:
# python-doc bot, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-05-29 17:29+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: python-doc bot, 2026\n"
"Language-Team: Indonesian (https://app.transifex.com/python-doc/teams/5390/"
"id/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: id\n"
"Plural-Forms: nplurals=1; plural=0;\n"

msgid "Expressions"
msgstr ""

msgid ""
"This chapter explains the meaning of the elements of expressions in Python."
msgstr ""

msgid ""
"**Syntax Notes:** In this and the following chapters, :ref:`grammar notation "
"<notation>` will be used to describe syntax, not lexical analysis."
msgstr ""

msgid "When (one alternative of) a syntax rule has the form:"
msgstr ""

msgid ""
"and no semantics are given, the semantics of this form of ``name`` are the "
"same as for ``othername``."
msgstr ""

msgid "Arithmetic conversions"
msgstr ""

msgid ""
"When a description of an arithmetic operator below uses the phrase \"the "
"numeric arguments are converted to a common real type\", this means that the "
"operator implementation for built-in numeric types works as described in "
"the :ref:`Numeric Types <stdtypes-mixed-arithmetic>` section of the standard "
"library documentation."
msgstr ""

msgid ""
"Some additional rules apply for certain operators and non-numeric operands "
"(for example, a string as a left argument to the ``%`` operator). Extensions "
"must define their own conversion behavior."
msgstr ""

msgid "Atoms"
msgstr ""

msgid ""
"Atoms are the most basic elements of expressions. The simplest atoms are :"
"ref:`builtin constants <atom-singletons>`, :ref:`names <identifiers>` and :"
"ref:`literals <atom-literals>`. More complex atoms are enclosed in paired "
"delimiters:"
msgstr ""

msgid ""
"``()`` (parentheses): :ref:`groups <parenthesized>`, :ref:`tuple displays "
"<tuple-display>`, :ref:`yield atoms <yieldexpr>`, and :ref:`generator "
"expressions <genexpr>`;"
msgstr ""

msgid "``[]`` (square brackets): :ref:`list displays <lists>`;"
msgstr ""

msgid ""
"``{}`` (curly braces): :ref:`dictionary <dict>` and :ref:`set <set>` "
"displays."
msgstr ""

msgid "Formally, the syntax for atoms is:"
msgstr ""

msgid "Built-in constants"
msgstr ""

msgid ""
"The keywords ``True``, ``False``, and ``None`` name :ref:`built-in constants "
"<built-in-consts>`. The token ``...`` names the :py:data:`Ellipsis` constant."
msgstr ""

msgid "Evaluation of these atoms yields the corresponding value."
msgstr ""

msgid ""
"Several more built-in constants are available as global variables, but only "
"the ones mentioned here are :ref:`keywords <keywords>`. In particular, these "
"names cannot be reassigned or used as attributes:"
msgstr ""

msgid ""
">>> False = 123\n"
"  File \"<input>\", line 1\n"
"   False = 123\n"
"   ^^^^^\n"
"SyntaxError: cannot assign to False"
msgstr ""

msgid "Formally, the syntax for built-in constants is:"
msgstr ""

msgid "Identifiers (Names)"
msgstr ""

msgid ""
"An identifier occurring as an atom is a name.  See section :ref:"
"`identifiers` for lexical definition and section :ref:`naming` for "
"documentation of naming and binding."
msgstr ""

msgid ""
"When the name is bound to an object, evaluation of the atom yields that "
"object. When a name is not bound, an attempt to evaluate it raises a :exc:"
"`NameError` exception."
msgstr ""

msgid "Private name mangling"
msgstr ""

msgid ""
"When an identifier that textually occurs in a class definition begins with "
"two or more underscore characters and does not end in two or more "
"underscores, it is considered a :dfn:`private name` of that class."
msgstr ""

msgid "The :ref:`class specifications <class>`."
msgstr ""

msgid ""
"More precisely, private names are transformed to a longer form before code "
"is generated for them.  If the transformed name is longer than 255 "
"characters, implementation-defined truncation may happen."
msgstr ""

msgid ""
"The transformation is independent of the syntactical context in which the "
"identifier is used but only the following private identifiers are mangled:"
msgstr ""

msgid ""
"Any name used as the name of a variable that is assigned or read or any name "
"of an attribute being accessed."
msgstr ""

msgid ""
"The :attr:`~definition.__name__` attribute of nested functions, classes, and "
"type aliases is however not mangled."
msgstr ""

msgid ""
"The name of imported modules, e.g., ``__spam`` in ``import __spam``. If the "
"module is part of a package (i.e., its name contains a dot), the name is "
"*not* mangled, e.g., the ``__foo`` in ``import __foo.bar`` is not mangled."
msgstr ""

msgid ""
"The name of an imported member, e.g., ``__f`` in ``from spam import __f``."
msgstr ""

msgid "The transformation rule is defined as follows:"
msgstr ""

msgid ""
"The class name, with leading underscores removed and a single leading "
"underscore inserted, is inserted in front of the identifier, e.g., the "
"identifier ``__spam`` occurring in a class named ``Foo``, ``_Foo`` or "
"``__Foo`` is transformed to ``_Foo__spam``."
msgstr ""

msgid ""
"If the class name consists only of underscores, the transformation is the "
"identity, e.g., the identifier ``__spam`` occurring in a class named ``_`` "
"or ``__`` is left as is."
msgstr ""

msgid "Literals"
msgstr ""

msgid ""
"A :dfn:`literal` is a textual representation of a value. Python supports "
"numeric, string and bytes literals. :ref:`Format strings <f-strings>` and :"
"ref:`template strings <t-strings>` are treated as string literals."
msgstr ""

msgid ""
"Numeric literals consist of a single :token:`NUMBER <python-grammar:NUMBER>` "
"token, which names an integer, floating-point number, or an imaginary "
"number. See the :ref:`numbers` section in Lexical analysis documentation for "
"details."
msgstr ""

msgid ""
"String and bytes literals may consist of several tokens. See section :ref:"
"`string-concatenation` for details."
msgstr ""

msgid ""
"Note that negative and complex numbers, like ``-3`` or ``3+4.2j``, are "
"syntactically not literals, but :ref:`unary <unary>` or :ref:`binary "
"<binary>` arithmetic operations involving the ``-`` or ``+`` operator."
msgstr ""

msgid ""
"Evaluation of a literal yields an object of the given type (:class:`int`, :"
"class:`float`, :class:`complex`, :class:`str`, :class:`bytes`, or :class:"
"`~string.templatelib.Template`) with the given value. The value may be "
"approximated in the case of floating-point and imaginary literals."
msgstr ""

msgid "The formal grammar for literals is:"
msgstr ""

msgid "Literals and object identity"
msgstr ""

msgid ""
"All literals correspond to immutable data types, and hence the object's "
"identity is less important than its value.  Multiple evaluations of literals "
"with the same value (either the same occurrence in the program text or a "
"different occurrence) may obtain the same object or a different object with "
"the same value."
msgstr ""

msgid "CPython implementation detail"
msgstr ""

msgid ""
"For example, in CPython, *small* integers with the same value evaluate to "
"the same object::"
msgstr ""

msgid ""
">>> x = 7\n"
">>> y = 7\n"
">>> x is y\n"
"True"
msgstr ""

msgid "However, large integers evaluate to different objects::"
msgstr ""

msgid ""
">>> x = 123456789\n"
">>> y = 123456789\n"
">>> x is y\n"
"False"
msgstr ""

msgid ""
"This behavior may change in future versions of CPython. In particular, the "
"boundary between \"small\" and \"large\" integers has already changed in the "
"past."
msgstr ""

msgid ""
"CPython will emit a :py:exc:`SyntaxWarning` when you compare literals using "
"``is``::"
msgstr ""

msgid ""
">>> x = 7\n"
">>> x is 7\n"
"<input>:1: SyntaxWarning: \"is\" with 'int' literal. Did you mean \"==\"?\n"
"True"
msgstr ""

msgid "See :ref:`faq-identity-with-is` for more information."
msgstr ""

msgid ""
":ref:`Template strings <t-strings>` are immutable but may reference mutable "
"objects as :class:`~string.templatelib.Interpolation` values. For the "
"purposes of this section, two t-strings have the \"same value\" if both "
"their structure and the *identity* of the values match."
msgstr ""

msgid ""
"Currently, each evaluation of a template string results in a different "
"object."
msgstr ""

msgid "String literal concatenation"
msgstr ""

msgid ""
"Multiple adjacent string or bytes literals, possibly using different quoting "
"conventions, are allowed, and their meaning is the same as their "
"concatenation::"
msgstr ""

msgid ""
">>> \"hello\" 'world'\n"
"\"helloworld\""
msgstr ""

msgid ""
"This feature is defined at the syntactical level, so it only works with "
"literals. To concatenate string expressions at run time, the '+' operator "
"may be used::"
msgstr ""

msgid ""
">>> greeting = \"Hello\"\n"
">>> space = \" \"\n"
">>> name = \"Blaise\"\n"
">>> print(greeting + space + name)   # not: print(greeting space name)\n"
"Hello Blaise"
msgstr ""

msgid ""
"Literal concatenation can freely mix raw strings, triple-quoted strings, and "
"formatted string literals. For example::"
msgstr ""

msgid ""
">>> \"Hello\" r', ' f\"{name}!\"\n"
"\"Hello, Blaise!\""
msgstr ""

msgid ""
"This feature can be used to reduce the number of backslashes needed, to "
"split long strings conveniently across long lines, or even to add comments "
"to parts of strings. For example::"
msgstr ""

msgid ""
"re.compile(\"[A-Za-z_]\"       # letter or underscore\n"
"           \"[A-Za-z0-9_]*\"   # letter, digit or underscore\n"
"          )"
msgstr ""

msgid ""
"However, bytes literals may only be combined with other byte literals; not "
"with string literals of any kind. Also, template string literals may only be "
"combined with other template string literals::"
msgstr ""

msgid ""
">>> t\"Hello\" t\"{name}!\"\n"
"Template(strings=('Hello', '!'), interpolations=(...))"
msgstr ""

msgid "Formally:"
msgstr ""

msgid "Parenthesized groups"
msgstr ""

msgid ""
"A :dfn:`parenthesized group` is an expression enclosed in parentheses. The "
"group evaluates to the same value as the expression inside."
msgstr ""

msgid ""
"Groups are used to override or clarify :ref:`operator precedence <operator-"
"precedence>`, in the same way as in math notation. For example::"
msgstr ""

msgid ""
">>> 3 << 2 | 4\n"
"12\n"
">>> 3 << (2 | 4)   # Override precedence of the | (bitwise OR)\n"
"192\n"
">>> (3 << 2) | 4   # Same as without parentheses (but more clear)\n"
"12"
msgstr ""

msgid ""
"Note that not everything in parentheses is a *group*. Specifically, a "
"parenthesized group must include exactly one expression, and cannot end with "
"a comma. See :ref:`tuple displays <tuple-display>` and :ref:`generator "
"expressions <genexpr>` for other parenthesized forms."
msgstr ""

msgid "Formally, the syntax for groups is:"
msgstr ""

msgid "Container displays"
msgstr ""

msgid ""
"For constructing builtin containers (lists, sets, tuples or dictionaries), "
"Python provides special syntax called :dfn:`displays`. There are subtle "
"differences between the four kinds of displays, detailed in the following "
"sections. All displays, however, consist of comma-separated items enclosed "
"in paired delimiters."
msgstr ""

msgid ""
"For example, a *list display* is a series of expressions enclosed in square "
"brackets::"
msgstr ""

msgid ""
">>> [\"one\", \"two\", \"three\"]\n"
"['one', 'two', 'three']\n"
">>> [1 + 2, 2 + 3]\n"
"[3, 5]"
msgstr ""

msgid ""
"In list, tuple and dictionary (but not set) displays, the series may be "
"empty::"
msgstr ""

msgid ""
">>> []  # empty list\n"
"[]\n"
">>> ()  # empty tuple\n"
"()\n"
">>> {}  # empty dictionary\n"
"{}"
msgstr ""

msgid ""
"If the series is not empty, the items may be followed by an additional "
"comma, which has no effect::"
msgstr ""

msgid ""
">>> [\"one\", \"two\", \"three\",]  # note comma after \"three\"\n"
"['one', 'two', 'three']"
msgstr ""

msgid ""
"The trailing comma is often used for displays that span multiple lines "
"(using :ref:`implicit line joining <implicit-joining>`), so when a future "
"programmer adds a new entry at the end, they do not need to modify an "
"existing line::"
msgstr ""

msgid ""
">>> [\n"
"...     'one',\n"
"...     'two',\n"
"...     'three',\n"
"... ]\n"
"['one', 'two', 'three']"
msgstr ""

msgid ""
"At runtime, when a display is evaluated, the listed items are evaluated from "
"left to right and placed into a new container of the appropriate type."
msgstr ""

msgid ""
"For tuple, list and set (but not dict) displays, any item in the display may "
"be prefixed with an asterisk (``*``). This denotes :ref:`iterable unpacking  "
"<iterable-unpacking>`. At runtime, the asterisk-prefixed expression must "
"evaluate to an iterable, whose contents are inserted into the container at "
"the location of the unpacking. For example::"
msgstr ""

msgid ""
">>> numbers = (1, 2)\n"
">>> [*numbers, 'word', *numbers]\n"
"[1, 2, 'word', 1, 2]"
msgstr ""

msgid ""
"Dictionary displays use a similar mechanism called *dictionary unpacking*, "
"denoted with a double asterisk (``**``). See :ref:`dict` for details."
msgstr ""

msgid ""
"A more advanced form of displays are :dfn:`comprehensions`, where items are "
"computed via a set of looping and filtering instructions. See the :ref:"
"`comprehensions` section for details."
msgstr ""

msgid ""
"Iterable and dictionary unpacking in displays, originally proposed by :pep:"
"`448`."
msgstr ""

msgid "List displays"
msgstr ""

msgid ""
"A :dfn:`list display` is a possibly empty series of expressions enclosed in "
"square brackets. For example::"
msgstr ""

msgid ""
">>> [\"one\", \"two\", \"three\"]\n"
"['one', 'two', 'three']\n"
">>> [\"one\"]  # One-element list\n"
"['one']\n"
">>> []       # empty list\n"
"[]"
msgstr ""

msgid "See :ref:`displays` for general information on displays."
msgstr ""

msgid "The formal grammar for list displays is:"
msgstr ""

msgid "Set displays"
msgstr ""

msgid ""
"A :dfn:`set display` is a *non-empty* series of expressions enclosed in "
"curly braces. For example::"
msgstr ""

msgid ""
">>> {\"one\", \"two\", \"three\"}\n"
"{'one', 'three', 'two'}\n"
">>> {\"one\"}  # One-element set\n"
"{'one'}"
msgstr ""

msgid ""
"There is no special syntax for the empty set. The ``{}`` literal is a :ref:"
"`dictionary display <dict>` that constructs an empty dictionary. Call :class:"
"`set() <set>` with no arguments to get an empty set."
msgstr ""

msgid "The formal grammar for set displays is:"
msgstr ""

msgid "Tuple displays"
msgstr ""

msgid ""
"A :dfn:`tuple display` is a series of expressions enclosed in parentheses. "
"For example::"
msgstr ""

msgid ""
">>> (1, 2)\n"
"(1, 2)\n"
">>> ()  # an empty tuple\n"
"()"
msgstr ""

msgid ""
"To avoid ambiguity, if a tuple display has exactly one element, it requires "
"a trailing comma. Without it, you get a :ref:`parenthesized group "
"<parenthesized>`::"
msgstr ""

msgid ""
">>> ('single',)  # single-element tuple\n"
"('single',)\n"
">>> ('single')   # no comma: single string\n"
"'single'"
msgstr ""

msgid ""
"To put it in other words, a tuple display is a parenthesized list of either:"
msgstr ""

msgid "two or more comma-separated expressions, or"
msgstr ""

msgid "zero or more expressions, each followed by a comma."
msgstr ""

msgid ""
"Since tuples are immutable, :ref:`object identity rules for literals "
"<literals-identity>` also apply to tuples: at runtime, two occurrences of "
"tuples with the same values may or may not yield the same object."
msgstr ""

msgid ""
"Python's syntax also includes :ref:`expression lists <exprlists>`, where a "
"comma-separated list of expressions is *not* enclosed in parentheses but "
"evaluates to tuple."
msgstr ""

msgid ""
"In other words, when it comes to tuple syntax, the comma is more important "
"that the use of parentheses. Only the empty tuple is spelled without a comma."
msgstr ""

msgid "The formal grammar for tuple displays is:"
msgstr ""

msgid "Dictionary displays"
msgstr ""

msgid ""
"A :dfn:`dictionary display` is a possibly empty series of :dfn:`dict items` "
"enclosed in curly braces. Each dict item is a colon-separated pair of "
"expressions: the :dfn:`key` and its associated :dfn:`value`. For example::"
msgstr ""

msgid ""
">>> {1: 'one', 2: 'two'}\n"
"{1: 'one', 2: 'two'}"
msgstr ""

msgid ""
"At runtime, when a dictionary comprehension is evaluated, the expressions "
"are evaluated from left to right. Each key object is used as a key into the "
"dictionary to store the corresponding value. This means that you can specify "
"the same key multiple times in the comprehension, and the final dictionary's "
"value for a given key will be the last one given. For example::"
msgstr ""

msgid ""
">>> {\n"
"...     1: 'this will be overridden',\n"
"...     2: 'two',\n"
"...     1: 'also overridden',\n"
"...     1: 'one',\n"
"... }\n"
"{1: 'one', 2: 'two'}"
msgstr ""

msgid ""
"Instead of a key-value pair, a dict item may be an expression prefixed by a "
"double asterisk ``**``. This denotes :dfn:`dictionary unpacking`. At "
"runtime, the expression must evaluate to a :term:`mapping`; each item of the "
"mapping is added to the new dictionary. As with key-value pairs, later "
"values replace values already set by earlier items and unpackings. This may "
"be used to override a set of defaults::"
msgstr ""

msgid ""
">>> defaults = {'color': 'blue', 'count': 8}\n"
">>> overrides = {'color': 'yellow'}\n"
">>> {**defaults, **overrides}\n"
"{'color': 'yellow', 'count': 8}"
msgstr ""

msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`."
msgstr ""

msgid "The formal grammar for dict displays is:"
msgstr ""

msgid "Comprehensions"
msgstr ""

msgid ""
"List, set and dictionary :dfn:`comprehensions` are a form of :ref:`container "
"displays <displays>` where items are computed via a set of looping and "
"filtering instructions rather than listed explicitly."
msgstr ""

msgid ""
"In its simplest form, a comprehension consists of a single expression "
"followed by a :keyword:`!for` clause. The :keyword:`!for` clause has the "
"same syntax as the header of a :ref:`for statement <for>`, without a "
"trailing colon."
msgstr ""

msgid "For example, a list of the first ten squares is::"
msgstr ""

msgid ""
">>> [x**2 for x in range(10)]\n"
"[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
msgstr ""

msgid ""
"At run time, a list comprehension creates a new list. The expression after :"
"keyword:`!in` must evaluate to an :term:`iterable`. For each element of this "
"iterable, the element is bound to the :keyword:`!for` clause's target as in "
"a :keyword:`!for` statement, then the expression before :keyword:`!for` is "
"evaluated with the target in scope and the result is added to the new list. "
"Thus, the example above is roughly equivalent to defining and calling the "
"following function::"
msgstr ""

msgid ""
"def make_list_of_squares(iterable):\n"
"    result = []\n"
"    for x in iterable:\n"
"        result.append(x**2)\n"
"    return result\n"
"\n"
"make_list_of_squares(range(10))"
msgstr ""

msgid ""
"Set comprehensions work similarly. For example, here is a set of lowercase "
"letters::"
msgstr ""

msgid ""
">>> {x.lower() for x in ['a', 'A', 'b', 'C']}\n"
"{'c', 'a', 'b'}"
msgstr ""

msgid "At run time, this corresponds roughly to calling this function::"
msgstr ""

msgid ""
"def make_lowercase_set(iterable):\n"
"    result = set(iterable)\n"
"    for x in iterable:\n"
"        result.append(x.lower())\n"
"    return result\n"
"\n"
"make_lowercase_set(['a', 'A', 'b', 'C'])"
msgstr ""

msgid ""
"Dictionary comprehensions start with a colon-separated key-value pair "
"instead of an expression. For example::"
msgstr ""

msgid ""
">>> {func.__name__: func for func in [print, hex, any]}\n"
"{'print': <built-in function print>,\n"
" 'hex': <built-in function hex>,\n"
" 'any': <built-in function any>}"
msgstr ""

msgid "At run time, this corresponds roughly to::"
msgstr ""

msgid ""
"def make_dict_mapping_names_to_functions(iterable):\n"
"    result = {}\n"
"    for func in iterable:\n"
"        result[func.__name__] = func\n"
"    return result\n"
"\n"
"iterable([print, hex, any])"
msgstr ""

msgid ""
"As in other kinds of dictionary displays, the same key may be specified "
"multiple times. Earlier values are overwritten by ones that are evaluated "
"later."
msgstr ""

msgid ""
"There are no *tuple comprehensions*. A similar syntax is instead used for :"
"ref:`generator expressions <genexpr>`, from which you can construct a tuple "
"like this::"
msgstr ""

msgid ""
">>> tuple(x**2 for x in range(10))\n"
"(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)"
msgstr ""

msgid ""
"Prior to Python 3.8, in dict comprehensions, the evaluation order of key and "
"value was not well-defined.  In CPython, the value was evaluated before the "
"key.  Starting with 3.8, the key is evaluated before the value, as proposed "
"by :pep:`572`."
msgstr ""

msgid "Filtering in comprehensions"
msgstr ""

msgid ""
"The :keyword:`!for` clause may be followed by an :keyword:`!if` clause with "
"an expression."
msgstr ""

msgid ""
"For example, a list of names from the :mod:`math` module that start with "
"``f`` is::"
msgstr ""

msgid ""
">>> [name for name in vars(math) if name.startswith('f')]\n"
"['fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum']"
msgstr ""

msgid ""
"At run time, the expression after :keyword:`!if` is evaluated before each "
"element is added to the resulting container, and if it is false, the element "
"is skipped. Thus, the above example roughly corresponds to defining and "
"calling the following function::"
msgstr ""

msgid ""
"def get_math_f_names(iterable):\n"
"    result = []\n"
"    for name in iterable:\n"
"        if name.startswith('f'):\n"
"           result.append(name)\n"
"    return result\n"
"\n"
"get_math_f_names(vars(math))"
msgstr ""

msgid ""
"Filtering is a special case of more complex comprehensions. See the next "
"section for a more formal description."
msgstr ""

msgid "Complex comprehensions"
msgstr ""

msgid ""
"Generally, a comprehension's initial :keyword:`!for` clause may be followed "
"by zero or more additional :keyword:`!for` or :keyword:`!if` clauses. For "
"example, here is a list of names exposed by two Python modules, filtered to "
"only include names that start with ``a``::"
msgstr ""

msgid ""
">>> import array\n"
">>> import math\n"
">>> [\n"
"...     name\n"
"...     for module in [array, math]\n"
"...     for name in vars(module)\n"
"...     if name.startswith('a')\n"
"... ]\n"
"['array', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh']"
msgstr ""

msgid "At run time, this roughly corresponds to defining and calling::"
msgstr ""

msgid ""
"def get_a_names(iterable):\n"
"    result = []\n"
"    for module in iterable:\n"
"        for name in vars(module):\n"
"            if name.startswith('a'):\n"
"                result.append(name)\n"
"    return result\n"
"\n"
"get_a_names([array, math])"
msgstr ""

msgid ""
"The elements of the new container are those that would be produced by "
"considering each of the :keyword:`!for` or :keyword:`!if` clauses a block, "
"nesting from left to right, and evaluating the expression to produce an "
"element (or dictionary entry) each time the innermost block is reached."
msgstr ""

msgid ""
"Aside from the iterable expression in the leftmost :keyword:`!for` clause, "
"the comprehension is executed in a separate implicitly nested scope. This "
"ensures that names assigned to in the target list don't \"leak\" into the "
"enclosing scope. For example::"
msgstr ""

msgid ""
">>> x = 'old value'\n"
">>> [x**2 for x in range(10)]  # this `x` is local to the comprehension\n"
">>> x\n"
"'old value'"
msgstr ""

msgid ""
"The iterable expression in the leftmost :keyword:`!for` clause is evaluated "
"directly in the enclosing scope and then passed as an argument to the "
"implicitly nested scope."
msgstr ""

msgid ""
"Subsequent :keyword:`!for` clauses and any filter condition in the leftmost :"
"keyword:`!for` clause cannot be evaluated in the enclosing scope as they may "
"depend on the values obtained from the leftmost iterable."
msgstr ""

msgid ""
"To ensure the comprehension always results in a container of the appropriate "
"type, ``yield`` and ``yield from`` expressions are prohibited in the "
"implicitly nested scope."
msgstr ""

msgid ""
":ref:`Assignment expressions <assignment-expressions>` are not allowed "
"inside comprehension iterable expressions (that is, the expressions after "
"the :keyword:`!in` keyword), nor anywhere within comprehensions that appear "
"directly in a class definition."
msgstr ""

msgid "``yield`` and ``yield from`` prohibited in the implicitly nested scope."
msgstr ""

msgid "Unpacking in comprehensions"
msgstr ""

msgid ""
"If the expression of a list or set comprehension is starred, the result will "
"be :ref:`unpacked <iterable-unpacking>` to produce zero or more elements."
msgstr ""

msgid "This is often used for \"flattening\" lists, for example::"
msgstr ""

msgid ""
">>> students = ['Petr', 'Blaise', 'Jarka']\n"
">>> teachers = ['Salim', 'Bartosz']\n"
">>> lists_of_people = [students, teachers]\n"
">>> [*people for people in lists_of_people]\n"
"['Petr', 'Blaise', 'Jarka', 'Salim', 'Bartosz']"
msgstr ""

msgid "At run time, this comprehension roughly corresponds to::"
msgstr ""

msgid ""
"def flatten_names(lists_of_people):\n"
"    result = []\n"
"    for people in lists_of_people:\n"
"        result.extend(people)\n"
"    return result"
msgstr ""

msgid ""
"In dict comprehensions, a double-starred expression will be evaluated and "
"then unpacked using :ref:`dictionary unpacking <dict-unpacking>`, inserting "
"zero or more key/value pairs into the new dictionary. As in other kinds of "
"dictionary displays, if the same key is specified multiple times, the "
"associated value in the resulting dictionary will be the last one specified."
msgstr ""

msgid "For example::"
msgstr "Sebagai contoh::"

msgid ""
">>> system_defaults = {'color': 'blue', 'count': 8}\n"
">>> user_defaults = {'color': 'yellow'}\n"
">>> overrides = {'count': 5}\n"
"\n"
">>> configuration_sets = [system_defaults, user_defaults, overrides]\n"
"\n"
">>> {**d for d in configuration_sets}\n"
"{'color': 'yellow', 'count': 5}"
msgstr ""

msgid ""
"Unpacking in comprehensions using the ``*`` and ``**`` operators was "
"introduced in :pep:`798`."
msgstr ""

msgid "Asynchronous comprehensions"
msgstr ""

msgid ""
"In an :keyword:`async def` function, an :keyword:`!async for` clause may be "
"used to iterate over a :term:`asynchronous iterator`. A comprehension in an :"
"keyword:`!async def` function may consist of either a :keyword:`!for` or :"
"keyword:`!async for` clause following the leading expression, may contain "
"additional :keyword:`!for` or :keyword:`!async for` clauses, and may also "
"use :keyword:`await` expressions."
msgstr ""

msgid ""
"If a comprehension contains :keyword:`!async for` clauses, or if it "
"contains :keyword:`!await` expressions or other asynchronous comprehensions "
"anywhere except the iterable expression in the leftmost :keyword:`!for` "
"clause, it is called an :dfn:`asynchronous comprehension`. An asynchronous "
"comprehension may suspend the execution of the coroutine function in which "
"it appears."
msgstr ""

msgid "Asynchronous comprehensions were introduced in :pep:`530`."
msgstr ""

msgid ""
"Asynchronous comprehensions are now allowed inside comprehensions in "
"asynchronous functions. Outer comprehensions implicitly become asynchronous."
msgstr ""

msgid "Formal grammar for comprehensions"
msgstr ""

msgid "The formal grammar for comprehensions is:"
msgstr ""

msgid "Generator expressions"
msgstr ""

msgid "A generator expression is a compact generator notation in parentheses:"
msgstr ""

msgid ""
"A generator expression yields a new generator object.  Its syntax is the "
"same as for comprehensions, except that it is enclosed in parentheses "
"instead of brackets or curly braces."
msgstr ""

msgid ""
"Variables used in the generator expression are evaluated lazily when the :"
"meth:`~generator.__next__` method is called for the generator object (in the "
"same fashion as normal generators).  However, the iterable expression in the "