# Python Documentation Turkish Translation

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

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2023-02-04 22:37+0000\n"

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

"Last-Translator: \n"

"Language-Team: TURKISH <python.docs.tr@gmail.com>\n"

"Language: tr\n"

"MIME-Version: 1.0\n"

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

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

#: reference/compound_stmts.rst:5

msgid "Compound statements"

msgstr ""

#: reference/compound_stmts.rst:9

msgid ""

"Compound statements contain (groups of) other statements; they affect or "

"control the execution of those other statements in some way. In general, "

"compound statements span multiple lines, although in simple incarnations a "

"whole compound statement may be contained in one line."

msgstr ""

#: reference/compound_stmts.rst:14

msgid ""

"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement "

"traditional control flow constructs. :keyword:`try` specifies exception "

"handlers and/or cleanup code for a group of statements, while the :keyword:"

"`with` statement allows the execution of initialization and finalization "

"code around a block of code. Function and class definitions are also "

"syntactically compound statements."

msgstr ""

#: reference/compound_stmts.rst:26

msgid ""

"A compound statement consists of one or more 'clauses.' A clause consists "

"of a header and a 'suite.' The clause headers of a particular compound "

"statement are all at the same indentation level. Each clause header begins "

"with a uniquely identifying keyword and ends with a colon. A suite is a "

"group of statements controlled by a clause. A suite can be one or more "

"semicolon-separated simple statements on the same line as the header, "

"following the header's colon, or it can be one or more indented statements "

"on subsequent lines. Only the latter form of a suite can contain nested "

"compound statements; the following is illegal, mostly because it wouldn't be "

"clear to which :keyword:`if` clause a following :keyword:`else` clause would "

"belong::"

msgstr ""

#: reference/compound_stmts.rst:39

msgid ""

"Also note that the semicolon binds tighter than the colon in this context, "

"so that in the following example, either all or none of the :func:`print` "

"calls are executed::"

msgstr ""

#: reference/compound_stmts.rst:45

msgid "Summarizing:"

msgstr ""

#: reference/compound_stmts.rst:69

msgid ""

"Note that statements always end in a ``NEWLINE`` possibly followed by a "

"``DEDENT``. Also note that optional continuation clauses always begin with "

"a keyword that cannot start a statement, thus there are no ambiguities (the "

"'dangling :keyword:`else`' problem is solved in Python by requiring nested :"

"keyword:`if` statements to be indented)."

msgstr ""

#: reference/compound_stmts.rst:75

msgid ""

"The formatting of the grammar rules in the following sections places each "

"clause on a separate line for clarity."

msgstr ""

#: reference/compound_stmts.rst:84

msgid "The :keyword:`!if` statement"

msgstr ""

#: reference/compound_stmts.rst:92

msgid "The :keyword:`if` statement is used for conditional execution:"

msgstr ""

#: reference/compound_stmts.rst:99

msgid ""

"It selects exactly one of the suites by evaluating the expressions one by "

"one until one is found to be true (see section :ref:`booleans` for the "

"definition of true and false); then that suite is executed (and no other "

"part of the :keyword:`if` statement is executed or evaluated). If all "

"expressions are false, the suite of the :keyword:`else` clause, if present, "

"is executed."

msgstr ""

#: reference/compound_stmts.rst:109

msgid "The :keyword:`!while` statement"

msgstr ""

#: reference/compound_stmts.rst:117

msgid ""

"The :keyword:`while` statement is used for repeated execution as long as an "

"expression is true:"

msgstr ""

#: reference/compound_stmts.rst:124

msgid ""

"This repeatedly tests the expression and, if it is true, executes the first "

"suite; if the expression is false (which may be the first time it is tested) "

"the suite of the :keyword:`!else` clause, if present, is executed and the "

"loop terminates."

msgstr ""

#: reference/compound_stmts.rst:133

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and goes back to testing the expression."

msgstr ""

#: reference/compound_stmts.rst:142

msgid "The :keyword:`!for` statement"

msgstr ""

#: reference/compound_stmts.rst:153

msgid ""

"The :keyword:`for` statement is used to iterate over the elements of a "

"sequence (such as a string, tuple or list) or other iterable object:"

msgstr ""

#: reference/compound_stmts.rst:160

msgid ""

"The expression list is evaluated once; it should yield an iterable object. "

"An iterator is created for the result of the ``expression_list``. The suite "

"is then executed once for each item provided by the iterator, in the order "

"returned by the iterator. Each item in turn is assigned to the target list "

"using the standard rules for assignments (see :ref:`assignment`), and then "

"the suite is executed. When the items are exhausted (which is immediately "

"when the sequence is empty or an iterator raises a :exc:`StopIteration` "

"exception), the suite in the :keyword:`!else` clause, if present, is "

"executed, and the loop terminates."

msgstr ""

#: reference/compound_stmts.rst:173

msgid ""

"A :keyword:`break` statement executed in the first suite terminates the loop "

"without executing the :keyword:`!else` clause's suite. A :keyword:"

"`continue` statement executed in the first suite skips the rest of the suite "

"and continues with the next item, or with the :keyword:`!else` clause if "

"there is no next item."

msgstr ""

#: reference/compound_stmts.rst:179

msgid ""

"The for-loop makes assignments to the variables in the target list. This "

"overwrites all previous assignments to those variables including those made "

"in the suite of the for-loop::"

msgstr ""

#: reference/compound_stmts.rst:193

msgid ""

"Names in the target list are not deleted when the loop is finished, but if "

"the sequence is empty, they will not have been assigned to at all by the "

"loop. Hint: the built-in type :func:`range` represents immutable arithmetic "

"sequences of integers. For instance, iterating ``range(3)`` successively "

"yields 0, 1, and then 2."

msgstr ""

#: reference/compound_stmts.rst:204

msgid "The :keyword:`!try` statement"

msgstr ""

#: reference/compound_stmts.rst:214

msgid ""

"The :keyword:`try` statement specifies exception handlers and/or cleanup "

"code for a group of statements:"

msgstr ""

#: reference/compound_stmts.rst:227

msgid ""

"The :keyword:`except` clause(s) specify one or more exception handlers. When "

"no exception occurs in the :keyword:`try` clause, no exception handler is "

"executed. When an exception occurs in the :keyword:`!try` suite, a search "

"for an exception handler is started. This search inspects the except "

"clauses in turn until one is found that matches the exception. An "

"expression-less except clause, if present, must be last; it matches any "

"exception. For an except clause with an expression, that expression is "

"evaluated, and the clause matches the exception if the resulting object is "

"\"compatible\" with the exception. An object is compatible with an "

"exception if the object is the class or a :term:`non-virtual base class "

"<abstract base class>` of the exception object, or a tuple containing an "

"item that is the class or a non-virtual base class of the exception object."

msgstr ""

#: reference/compound_stmts.rst:240

msgid ""

"If no except clause matches the exception, the search for an exception "

"handler continues in the surrounding code and on the invocation stack. [#]_"

msgstr ""

#: reference/compound_stmts.rst:243

msgid ""

"If the evaluation of an expression in the header of an except clause raises "

"an exception, the original search for a handler is canceled and a search "

"starts for the new exception in the surrounding code and on the call stack "

"(it is treated as if the entire :keyword:`try` statement raised the "

"exception)."

msgstr ""

#: reference/compound_stmts.rst:250

msgid ""

"When a matching except clause is found, the exception is assigned to the "

"target specified after the :keyword:`!as` keyword in that except clause, if "

"present, and the except clause's suite is executed. All except clauses must "

"have an executable block. When the end of this block is reached, execution "

"continues normally after the entire try statement. (This means that if two "

"nested handlers exist for the same exception, and the exception occurs in "

"the try clause of the inner handler, the outer handler will not handle the "

"exception.)"

msgstr ""

#: reference/compound_stmts.rst:258

msgid ""

"When an exception has been assigned using ``as target``, it is cleared at "

"the end of the except clause. This is as if ::"

msgstr ""

#: reference/compound_stmts.rst:264

msgid "was translated to ::"

msgstr ""

#: reference/compound_stmts.rst:272

msgid ""

"This means the exception must be assigned to a different name to be able to "

"refer to it after the except clause. Exceptions are cleared because with "

"the traceback attached to them, they form a reference cycle with the stack "

"frame, keeping all locals in that frame alive until the next garbage "

"collection occurs."

msgstr ""

#: reference/compound_stmts.rst:281

msgid ""

"Before an except clause's suite is executed, details about the exception are "

"stored in the :mod:`sys` module and can be accessed via :func:`sys."

"exc_info`. :func:`sys.exc_info` returns a 3-tuple consisting of the "

"exception class, the exception instance and a traceback object (see section :"

"ref:`types`) identifying the point in the program where the exception "

"occurred. The details about the exception accessed via :func:`sys.exc_info` "

"are restored to their previous values when leaving an exception handler::"

msgstr ""

#: reference/compound_stmts.rst:313

msgid ""

"The optional :keyword:`!else` clause is executed if the control flow leaves "

"the :keyword:`try` suite, no exception was raised, and no :keyword:"

"`return`, :keyword:`continue`, or :keyword:`break` statement was executed. "

"Exceptions in the :keyword:`!else` clause are not handled by the preceding :"

"keyword:`except` clauses."

msgstr ""

#: reference/compound_stmts.rst:321

msgid ""

"If :keyword:`finally` is present, it specifies a 'cleanup' handler. The :"

"keyword:`try` clause is executed, including any :keyword:`except` and :"

"keyword:`!else` clauses. If an exception occurs in any of the clauses and "

"is not handled, the exception is temporarily saved. The :keyword:`!finally` "

"clause is executed. If there is a saved exception it is re-raised at the "

"end of the :keyword:`!finally` clause. If the :keyword:`!finally` clause "

"raises another exception, the saved exception is set as the context of the "

"new exception. If the :keyword:`!finally` clause executes a :keyword:"

"`return`, :keyword:`break` or :keyword:`continue` statement, the saved "

"exception is discarded::"

msgstr ""

#: reference/compound_stmts.rst:340

msgid ""

"The exception information is not available to the program during execution "

"of the :keyword:`finally` clause."

msgstr ""

#: reference/compound_stmts.rst:348

msgid ""

"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement "

"is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!"

"finally` statement, the :keyword:`finally` clause is also executed 'on the "

"way out.'"

msgstr ""

#: reference/compound_stmts.rst:352

msgid ""

"The return value of a function is determined by the last :keyword:`return` "

"statement executed. Since the :keyword:`finally` clause always executes, a :"

"keyword:`!return` statement executed in the :keyword:`!finally` clause will "

"always be the last one executed::"

msgstr ""

#: reference/compound_stmts.rst:366

msgid ""

"Additional information on exceptions can be found in section :ref:"

"`exceptions`, and information on using the :keyword:`raise` statement to "

"generate exceptions may be found in section :ref:`raise`."

msgstr ""

#: reference/compound_stmts.rst:370

msgid ""

"Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :"

"keyword:`finally` clause due to a problem with the implementation."

msgstr ""

#: reference/compound_stmts.rst:379

msgid "The :keyword:`!with` statement"

msgstr ""

#: reference/compound_stmts.rst:388

msgid ""

"The :keyword:`with` statement is used to wrap the execution of a block with "

"methods defined by a context manager (see section :ref:`context-managers`). "

"This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"

"`finally` usage patterns to be encapsulated for convenient reuse."

msgstr ""

#: reference/compound_stmts.rst:398

msgid ""

"The execution of the :keyword:`with` statement with one \"item\" proceeds as "

"follows:"

msgstr ""

#: reference/compound_stmts.rst:400

msgid ""

"The context expression (the expression given in the :token:`~python-grammar:"

"with_item`) is evaluated to obtain a context manager."

msgstr ""

#: reference/compound_stmts.rst:403

msgid "The context manager's :meth:`__enter__` is loaded for later use."

msgstr ""

#: reference/compound_stmts.rst:405

msgid "The context manager's :meth:`__exit__` is loaded for later use."

msgstr ""

#: reference/compound_stmts.rst:407

msgid "The context manager's :meth:`__enter__` method is invoked."

msgstr ""

#: reference/compound_stmts.rst:409

msgid ""

"If a target was included in the :keyword:`with` statement, the return value "

"from :meth:`__enter__` is assigned to it."

msgstr ""

#: reference/compound_stmts.rst:414

msgid ""

"The :keyword:`with` statement guarantees that if the :meth:`__enter__` "

"method returns without an error, then :meth:`__exit__` will always be "

"called. Thus, if an error occurs during the assignment to the target list, "

"it will be treated the same as an error occurring within the suite would be. "

"See step 7 below."

msgstr ""

#: reference/compound_stmts.rst:420

msgid "The suite is executed."

msgstr ""

#: reference/compound_stmts.rst:422

msgid ""

"The context manager's :meth:`__exit__` method is invoked. If an exception "

"caused the suite to be exited, its type, value, and traceback are passed as "

"arguments to :meth:`__exit__`. Otherwise, three :const:`None` arguments are "

"supplied."

msgstr ""

#: reference/compound_stmts.rst:427

msgid ""

"If the suite was exited due to an exception, and the return value from the :"

"meth:`__exit__` method was false, the exception is reraised. If the return "

"value was true, the exception is suppressed, and execution continues with "

"the statement following the :keyword:`with` statement."

msgstr ""

#: reference/compound_stmts.rst:432

msgid ""

"If the suite was exited for any reason other than an exception, the return "

"value from :meth:`__exit__` is ignored, and execution proceeds at the normal "

"location for the kind of exit that was taken."

msgstr ""

#: reference/compound_stmts.rst:436 reference/compound_stmts.rst:1427

#: reference/compound_stmts.rst:1468

msgid "The following code::"

msgstr ""

#: reference/compound_stmts.rst:441 reference/compound_stmts.rst:466

#: reference/compound_stmts.rst:1473

msgid "is semantically equivalent to::"

msgstr ""

#: reference/compound_stmts.rst:460

msgid ""

"With more than one item, the context managers are processed as if multiple :"

"keyword:`with` statements were nested::"

msgstr ""

#: reference/compound_stmts.rst:472

msgid ""

"You can also write multi-item context managers in multiple lines if the "

"items are surrounded by parentheses. For example::"

msgstr ""

#: reference/compound_stmts.rst:481

msgid "Support for multiple context expressions."

msgstr ""

#: reference/compound_stmts.rst:484

msgid ""

"Support for using grouping parentheses to break the statement in multiple "

"lines."

msgstr ""

#: reference/compound_stmts.rst:490

msgid ":pep:`343` - The \"with\" statement"

msgstr ""

#: reference/compound_stmts.rst:490

msgid ""

"The specification, background, and examples for the Python :keyword:`with` "

"statement."

msgstr ""

#: reference/compound_stmts.rst:496

msgid "The :keyword:`!match` statement"

msgstr ""

#: reference/compound_stmts.rst:510

msgid "The match statement is used for pattern matching. Syntax:"

msgstr ""

#: reference/compound_stmts.rst:519

msgid ""

"This section uses single quotes to denote :ref:`soft keywords <soft-"

"keywords>`."

msgstr ""

#: reference/compound_stmts.rst:522

msgid ""

"Pattern matching takes a pattern as input (following ``case``) and a subject "

"value (following ``match``). The pattern (which may contain subpatterns) is "

"matched against the subject value. The outcomes are:"

msgstr ""

#: reference/compound_stmts.rst:526

msgid "A match success or failure (also termed a pattern success or failure)."

msgstr ""

#: reference/compound_stmts.rst:528

msgid ""

"Possible binding of matched values to a name. The prerequisites for this "

"are further discussed below."

msgstr ""

#: reference/compound_stmts.rst:531

msgid ""

"The ``match`` and ``case`` keywords are :ref:`soft keywords <soft-keywords>`."

msgstr ""

#: reference/compound_stmts.rst:535 reference/compound_stmts.rst:1090

msgid ":pep:`634` -- Structural Pattern Matching: Specification"

msgstr ""

#: reference/compound_stmts.rst:536 reference/compound_stmts.rst:1091

msgid ":pep:`636` -- Structural Pattern Matching: Tutorial"

msgstr ""

#: reference/compound_stmts.rst:540

msgid "Overview"

msgstr ""

#: reference/compound_stmts.rst:542

msgid "Here's an overview of the logical flow of a match statement:"

msgstr ""

#: reference/compound_stmts.rst:545

msgid ""

"The subject expression ``subject_expr`` is evaluated and a resulting subject "

"value obtained. If the subject expression contains a comma, a tuple is "

"constructed using :ref:`the standard rules <typesseq-tuple>`."

msgstr ""

#: reference/compound_stmts.rst:549

msgid ""

"Each pattern in a ``case_block`` is attempted to match with the subject "

"value. The specific rules for success or failure are described below. The "

"match attempt can also bind some or all of the standalone names within the "

"pattern. The precise pattern binding rules vary per pattern type and are "

"specified below. **Name bindings made during a successful pattern match "

"outlive the executed block and can be used after the match statement**."

msgstr ""

#: reference/compound_stmts.rst:558

msgid ""

"During failed pattern matches, some subpatterns may succeed. Do not rely on "

"bindings being made for a failed match. Conversely, do not rely on "

"variables remaining unchanged after a failed match. The exact behavior is "

"dependent on implementation and may vary. This is an intentional decision "

"made to allow different implementations to add optimizations."

msgstr ""

#: reference/compound_stmts.rst:565

msgid ""

"If the pattern succeeds, the corresponding guard (if present) is evaluated. "

"In this case all name bindings are guaranteed to have happened."

msgstr ""

#: reference/compound_stmts.rst:568

msgid ""

"If the guard evaluates as true or is missing, the ``block`` inside "

"``case_block`` is executed."

msgstr ""

#: reference/compound_stmts.rst:571

msgid "Otherwise, the next ``case_block`` is attempted as described above."

msgstr ""

#: reference/compound_stmts.rst:573

msgid "If there are no further case blocks, the match statement is completed."

msgstr ""

#: reference/compound_stmts.rst:577

msgid ""

"Users should generally never rely on a pattern being evaluated. Depending "

"on implementation, the interpreter may cache values or use other "

"optimizations which skip repeated evaluations."

msgstr ""

#: reference/compound_stmts.rst:581

msgid "A sample match statement::"

msgstr ""

#: reference/compound_stmts.rst:597

msgid ""

"In this case, ``if flag`` is a guard. Read more about that in the next "

"section."

msgstr ""

#: reference/compound_stmts.rst:600

msgid "Guards"

msgstr ""

#: reference/compound_stmts.rst:607

msgid ""

"A ``guard`` (which is part of the ``case``) must succeed for code inside the "

"``case`` block to execute. It takes the form: :keyword:`if` followed by an "

"expression."

msgstr ""

#: reference/compound_stmts.rst:612

msgid "The logical flow of a ``case`` block with a ``guard`` follows:"

msgstr ""

#: reference/compound_stmts.rst:614

msgid ""

"Check that the pattern in the ``case`` block succeeded. If the pattern "

"failed, the ``guard`` is not evaluated and the next ``case`` block is "

"checked."

msgstr ""

#: reference/compound_stmts.rst:618

msgid "If the pattern succeeded, evaluate the ``guard``."

msgstr ""

#: reference/compound_stmts.rst:620

msgid ""

"If the ``guard`` condition evaluates as true, the case block is selected."

msgstr ""

#: reference/compound_stmts.rst:623

msgid ""

"If the ``guard`` condition evaluates as false, the case block is not "

"selected."

msgstr ""

#: reference/compound_stmts.rst:626

msgid ""

"If the ``guard`` raises an exception during evaluation, the exception "

"bubbles up."

msgstr ""

#: reference/compound_stmts.rst:629

msgid ""

"Guards are allowed to have side effects as they are expressions. Guard "

"evaluation must proceed from the first to the last case block, one at a "

"time, skipping case blocks whose pattern(s) don't all succeed. (I.e., guard "

"evaluation must happen in order.) Guard evaluation must stop once a case "

"block is selected."

msgstr ""

#: reference/compound_stmts.rst:639

msgid "Irrefutable Case Blocks"

msgstr ""

#: reference/compound_stmts.rst:643

msgid ""

"An irrefutable case block is a match-all case block. A match statement may "

"have at most one irrefutable case block, and it must be last."

msgstr ""

#: reference/compound_stmts.rst:646

msgid ""

"A case block is considered irrefutable if it has no guard and its pattern is "

"irrefutable. A pattern is considered irrefutable if we can prove from its "

"syntax alone that it will always succeed. Only the following patterns are "

"irrefutable:"

msgstr ""

#: reference/compound_stmts.rst:651

msgid ":ref:`as-patterns` whose left-hand side is irrefutable"

msgstr ""

#: reference/compound_stmts.rst:653

msgid ":ref:`or-patterns` containing at least one irrefutable pattern"

msgstr ""

#: reference/compound_stmts.rst:655

msgid ":ref:`capture-patterns`"

msgstr ""

#: reference/compound_stmts.rst:657

msgid ":ref:`wildcard-patterns`"

msgstr ""

#: reference/compound_stmts.rst:659

msgid "parenthesized irrefutable patterns"

msgstr ""

#: reference/compound_stmts.rst:663

msgid "Patterns"

msgstr ""

#: reference/compound_stmts.rst:670

msgid "This section uses grammar notations beyond standard EBNF:"

msgstr ""

#: reference/compound_stmts.rst:672

msgid "the notation ``SEP.RULE+`` is shorthand for ``RULE (SEP RULE)*``"

msgstr ""

#: reference/compound_stmts.rst:674

msgid "the notation ``!RULE`` is shorthand for a negative lookahead assertion"

msgstr ""

#: reference/compound_stmts.rst:677

msgid "The top-level syntax for ``patterns`` is:"

msgstr ""

#: reference/compound_stmts.rst:691

msgid ""

"The descriptions below will include a description \"in simple terms\" of "

"what a pattern does for illustration purposes (credits to Raymond Hettinger "

"for a document that inspired most of the descriptions). Note that these "

"descriptions are purely for illustration purposes and **may not** reflect "

"the underlying implementation. Furthermore, they do not cover all valid "

"forms."

msgstr ""

#: reference/compound_stmts.rst:701

msgid "OR Patterns"

msgstr ""

#: reference/compound_stmts.rst:703

msgid ""

"An OR pattern is two or more patterns separated by vertical bars ``|``. "

"Syntax:"

msgstr ""

#: reference/compound_stmts.rst:709

msgid ""

"Only the final subpattern may be :ref:`irrefutable <irrefutable_case>`, and "

"each subpattern must bind the same set of names to avoid ambiguity."

msgstr ""

#: reference/compound_stmts.rst:712

msgid ""

"An OR pattern matches each of its subpatterns in turn to the subject value, "

"until one succeeds. The OR pattern is then considered successful. "

"Otherwise, if none of the subpatterns succeed, the OR pattern fails."

msgstr ""

#: reference/compound_stmts.rst:716

msgid ""

"In simple terms, ``P1 | P2 | ...`` will try to match ``P1``, if it fails it "

"will try to match ``P2``, succeeding immediately if any succeeds, failing "

"otherwise."

msgstr ""

#: reference/compound_stmts.rst:722

msgid "AS Patterns"

msgstr ""

#: reference/compound_stmts.rst:724

msgid ""

"An AS pattern matches an OR pattern on the left of the :keyword:`as` keyword "

"against a subject. Syntax:"

msgstr ""

#: reference/compound_stmts.rst:730

msgid ""

"If the OR pattern fails, the AS pattern fails. Otherwise, the AS pattern "

"binds the subject to the name on the right of the as keyword and succeeds. "

"``capture_pattern`` cannot be a a ``_``."

msgstr ""

#: reference/compound_stmts.rst:734

msgid ""

"In simple terms ``P as NAME`` will match with ``P``, and on success it will "

"set ``NAME = <subject>``."

msgstr ""

#: reference/compound_stmts.rst:741

msgid "Literal Patterns"

msgstr ""

#: reference/compound_stmts.rst:743

msgid ""

"A literal pattern corresponds to most :ref:`literals <literals>` in Python. "

"Syntax:"

msgstr ""

#: reference/compound_stmts.rst:756

msgid ""

"The rule ``strings`` and the token ``NUMBER`` are defined in the :doc:"

"`standard Python grammar <./grammar>`. Triple-quoted strings are "

"supported. Raw strings and byte strings are supported. :ref:`f-strings` "

"are not supported."

msgstr ""

#: reference/compound_stmts.rst:761

msgid ""

"The forms ``signed_number '+' NUMBER`` and ``signed_number '-' NUMBER`` are "

"for expressing :ref:`complex numbers <imaginary>`; they require a real "

"number on the left and an imaginary number on the right. E.g. ``3 + 4j``."

msgstr ""

#: reference/compound_stmts.rst:765

msgid ""

"In simple terms, ``LITERAL`` will succeed only if ``<subject> == LITERAL``. "

"For the singletons ``None``, ``True`` and ``False``, the :keyword:`is` "

"operator is used."

msgstr ""

#: reference/compound_stmts.rst:771

msgid "Capture Patterns"

msgstr ""

#: reference/compound_stmts.rst:773

msgid "A capture pattern binds the subject value to a name. Syntax:"

msgstr ""

#: reference/compound_stmts.rst:779

msgid ""

"A single underscore ``_`` is not a capture pattern (this is what ``!'_'`` "

"expresses). It is instead treated as a :token:`~python-grammar:"

"wildcard_pattern`."

msgstr ""

#: reference/compound_stmts.rst:783

msgid ""

"In a given pattern, a given name can only be bound once. E.g. ``case x, "

"x: ...`` is invalid while ``case [x] | x: ...`` is allowed."

msgstr ""

#: reference/compound_stmts.rst:786

msgid ""

"Capture patterns always succeed. The binding follows scoping rules "

"established by the assignment expression operator in :pep:`572`; the name "

"becomes a local variable in the closest containing function scope unless "

"there's an applicable :keyword:`global` or :keyword:`nonlocal` statement."

msgstr ""

#: reference/compound_stmts.rst:791

msgid ""

"In simple terms ``NAME`` will always succeed and it will set ``NAME = "

"<subject>``."

msgstr ""

#: reference/compound_stmts.rst:796

msgid "Wildcard Patterns"

msgstr ""

#: reference/compound_stmts.rst:798

msgid ""

"A wildcard pattern always succeeds (matches anything) and binds no name. "

"Syntax:"

msgstr ""

#: reference/compound_stmts.rst:804

msgid ""

"``_`` is a :ref:`soft keyword <soft-keywords>` within any pattern, but only "

"within patterns. It is an identifier, as usual, even within ``match`` "

"subject expressions, ``guard``\\ s, and ``case`` blocks."

msgstr ""

#: reference/compound_stmts.rst:808

msgid "In simple terms, ``_`` will always succeed."

msgstr ""

#: reference/compound_stmts.rst:813

msgid "Value Patterns"

msgstr ""

#: reference/compound_stmts.rst:815

msgid "A value pattern represents a named value in Python. Syntax:"

msgstr ""

#: reference/compound_stmts.rst:823

msgid ""

"The dotted name in the pattern is looked up using standard Python :ref:`name "

"resolution rules <resolve_names>`. The pattern succeeds if the value found "

"compares equal to the subject value (using the ``==`` equality operator)."

msgstr ""

#: reference/compound_stmts.rst:828

msgid ""

"In simple terms ``NAME1.NAME2`` will succeed only if ``<subject> == NAME1."

"NAME2``"

msgstr ""

#: reference/compound_stmts.rst:832

msgid ""

"If the same value occurs multiple times in the same match statement, the "

"interpreter may cache the first value found and reuse it rather than repeat "

"the same lookup. This cache is strictly tied to a given execution of a "

"given match statement."

msgstr ""

#: reference/compound_stmts.rst:840

msgid "Group Patterns"

msgstr ""

#: reference/compound_stmts.rst:842

msgid ""

"A group pattern allows users to add parentheses around patterns to emphasize "

"the intended grouping. Otherwise, it has no additional syntax. Syntax:"

msgstr ""

#: reference/compound_stmts.rst:849

msgid "In simple terms ``(P)`` has the same effect as ``P``."

msgstr ""

#: reference/compound_stmts.rst:854

msgid "Sequence Patterns"

msgstr ""

#: reference/compound_stmts.rst:856

msgid ""

"A sequence pattern contains several subpatterns to be matched against "

"sequence elements. The syntax is similar to the unpacking of a list or tuple."

msgstr ""

#: reference/compound_stmts.rst:867

msgid ""

"There is no difference if parentheses or square brackets are used for "

"sequence patterns (i.e. ``(...)`` vs ``[...]`` )."

msgstr ""

#: reference/compound_stmts.rst:871

msgid ""

"A single pattern enclosed in parentheses without a trailing comma (e.g. ``(3 "

"| 4)``) is a :ref:`group pattern <group-patterns>`. While a single pattern "

"enclosed in square brackets (e.g. ``[3 | 4]``) is still a sequence pattern."

msgstr ""

#: reference/compound_stmts.rst:876

msgid ""

"At most one star subpattern may be in a sequence pattern. The star "

"subpattern may occur in any position. If no star subpattern is present, the "

"sequence pattern is a fixed-length sequence pattern; otherwise it is a "

"variable-length sequence pattern."

msgstr ""

#: reference/compound_stmts.rst:881

msgid ""

"The following is the logical flow for matching a sequence pattern against a "

"subject value:"

msgstr ""

#: reference/compound_stmts.rst:884

msgid ""

"If the subject value is not a sequence [#]_, the sequence pattern fails."

msgstr ""

#: reference/compound_stmts.rst:887

msgid ""

"If the subject value is an instance of ``str``, ``bytes`` or ``bytearray`` "

"the sequence pattern fails."

msgstr ""

#: reference/compound_stmts.rst:890

msgid ""

"The subsequent steps depend on whether the sequence pattern is fixed or "

"variable-length."

msgstr ""

#: reference/compound_stmts.rst:893

msgid "If the sequence pattern is fixed-length:"

msgstr ""

#: reference/compound_stmts.rst:895

msgid ""

"If the length of the subject sequence is not equal to the number of "

"subpatterns, the sequence pattern fails"

msgstr ""

#: reference/compound_stmts.rst:898

msgid ""

"Subpatterns in the sequence pattern are matched to their corresponding items "

"in the subject sequence from left to right. Matching stops as soon as a "

"subpattern fails. If all subpatterns succeed in matching their "

"corresponding item, the sequence pattern succeeds."

msgstr ""

#: reference/compound_stmts.rst:903

msgid "Otherwise, if the sequence pattern is variable-length:"

msgstr ""

#: reference/compound_stmts.rst:905

msgid ""

"If the length of the subject sequence is less than the number of non-star "

"subpatterns, the sequence pattern fails."

msgstr ""

#: reference/compound_stmts.rst:908

msgid ""

"The leading non-star subpatterns are matched to their corresponding items as "

"for fixed-length sequences."

msgstr ""

#: reference/compound_stmts.rst:911

msgid ""

"If the previous step succeeds, the star subpattern matches a list formed of "

"the remaining subject items, excluding the remaining items corresponding to "

"non-star subpatterns following the star subpattern."

msgstr ""

#: reference/compound_stmts.rst:915

msgid ""

"Remaining non-star subpatterns are matched to their corresponding subject "

"items, as for a fixed-length sequence."

msgstr ""

#: reference/compound_stmts.rst:918

msgid ""

"The length of the subject sequence is obtained via :func:`len` (i.e. via "

"the :meth:`__len__` protocol). This length may be cached by the interpreter "

"in a similar manner as :ref:`value patterns <value-patterns>`."

msgstr ""

#: reference/compound_stmts.rst:924

msgid ""

"In simple terms ``[P1, P2, P3,`` ... ``, P<N>]`` matches only if all the "

"following happens:"

msgstr ""

#: reference/compound_stmts.rst:927

msgid "check ``<subject>`` is a sequence"

msgstr ""

#: reference/compound_stmts.rst:928

msgid "``len(subject) == <N>``"

msgstr ""

#: reference/compound_stmts.rst:929

msgid ""

"``P1`` matches ``<subject>[0]`` (note that this match can also bind names)"

msgstr ""

#: reference/compound_stmts.rst:930

msgid ""

"``P2`` matches ``<subject>[1]`` (note that this match can also bind names)"

msgstr ""

#: reference/compound_stmts.rst:931

msgid "... and so on for the corresponding pattern/element."

msgstr ""

#: reference/compound_stmts.rst:936

msgid "Mapping Patterns"

msgstr ""

#: reference/compound_stmts.rst:938

msgid ""

"A mapping pattern contains one or more key-value patterns. The syntax is "

"similar to the construction of a dictionary. Syntax:"

msgstr ""

#: reference/compound_stmts.rst:949