# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR Swen Bachmann <142266608+sba72@users.noreply.github.com>, 2026.

#

# Translators: @sba72

# python-doc bot, 2025

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-09-14 20:17+0000\n"

"PO-Revision-Date: 2026-07-31 21:01+0000\n"

"Last-Translator: @sba72\n"

"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/de/)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

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

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

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../tutorial/controlflow.rst:5

msgid "More Control Flow Tools"

msgstr "Mehr Werkzeuge zur Ablaufsteuerung"

#: ../../tutorial/controlflow.rst:7

msgid ""

"As well as the :keyword:`while` statement just introduced, Python uses a few "

"more that we will encounter in this chapter."

msgstr ""

"Neben der eben vorgestellten :keyword:`while`-Anweisung verwendet Python "

"noch ein paar weitere, die uns in diesem Kapitel begegnen werden."

#: ../../tutorial/controlflow.rst:14

msgid ":keyword:`!if` Statements"

msgstr ":keyword:`!if`-Anweisungen"

#: ../../tutorial/controlflow.rst:16

msgid ""

"Perhaps the most well-known statement type is the :keyword:`if` statement. "

"For example::"

msgstr ""

"Die wohl bekannteste Anweisungsart ist die :keyword:`if`-Anweisung. Zum "

"Beispiel::"

#: ../../tutorial/controlflow.rst:19

msgid ""

">>> x = int(input(\"Please enter an integer: \"))\n"

"Please enter an integer: 42\n"

">>> if x < 0:\n"

"... x = 0\n"

"... print('Negative changed to zero')\n"

"... elif x == 0:\n"

"... print('Zero')\n"

"... elif x == 1:\n"

"... print('Single')\n"

"... else:\n"

"... print('More')\n"

"...\n"

"More"

msgstr ""

">>> x = int(input(\"Please enter an integer: \"))\n"

"Please enter an integer: 42\n"

">>> if x < 0:\n"

"... x = 0\n"

"... print('Negative changed to zero')\n"

"... elif x == 0:\n"

"... print('Zero')\n"

"... elif x == 1:\n"

"... print('Single')\n"

"... else:\n"

"... print('More')\n"

"...\n"

"More"

#: ../../tutorial/controlflow.rst:33

msgid ""

"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "

"part is optional. The keyword ':keyword:`!elif`' is short for 'else if', "

"and is useful to avoid excessive indentation. An :keyword:`!if` ... :"

"keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the "

"``switch`` or ``case`` statements found in other languages."

msgstr ""

"Es kann kein oder mehrere :keyword:`elif`-Teile geben, und der :keyword:"

"`else`-Teil ist optional. Das Schlüsselwort ':keyword:`!elif`' ist die "

"Abkürzung für 'else if' und ist nützlich, um übermäßige Einrückungen zu "

"vermeiden. Eine :keyword:`!if` ... :keyword:`!elif` ... :keyword:`!elif` ...-"

"Sequenz ersetzt die ``switch``- oder ``case``-Anweisungen, die man aus "

"anderen Sprachen kennt."

#: ../../tutorial/controlflow.rst:39

msgid ""

"If you're comparing the same value to several constants, or checking for "

"specific types or attributes, you may also find the :keyword:`!match` "

"statement useful. For more details see :ref:`tut-match`."

msgstr ""

"Wenn du denselben Wert mit mehreren Konstanten vergleichst oder auf "

"bestimmte Typen oder Attribute prüfst, findest du möglicherweise auch die :"

"keyword:`!match`-Anweisung nützlich. Für weitere Details siehe :ref:`tut-"

"match`."

#: ../../tutorial/controlflow.rst:46

msgid ":keyword:`!for` Statements"

msgstr ":keyword:`!for`-Anweisungen"

#: ../../tutorial/controlflow.rst:51

msgid ""

"The :keyword:`for` statement in Python differs a bit from what you may be "

"used to in C or Pascal. Rather than always iterating over an arithmetic "

"progression of numbers (like in Pascal), or giving the user the ability to "

"define both the iteration step and halting condition (as C), Python's :"

"keyword:`!for` statement iterates over the items of any sequence (a list or "

"a string), in the order that they appear in the sequence. For example (no "

"pun intended):"

msgstr ""

"Die :keyword:`for`-Anweisung in Python unterscheidet sich ein wenig von dem, "

"was du vielleicht aus C oder Pascal gewohnt bist. Anstatt immer über eine "

"arithmetische Zahlenfolge zu iterieren (wie in Pascal) oder der nutzenden "

"Person die Möglichkeit zu geben, sowohl den Iterationsschritt als auch die "

"Abbruchbedingung zu definieren (wie in C), iteriert Pythons :keyword:`!for`-"

"Anweisung über die Elemente einer beliebigen Sequenz (eine Liste oder eine "

"Zeichenkette) in der Reihenfolge, in der sie in der Sequenz erscheinen. Zum "

"Beispiel (ohne Wortspiel):"

#: ../../tutorial/controlflow.rst:63

msgid ""

">>> # Measure some strings:\n"

">>> words = ['cat', 'window', 'defenestrate']\n"

">>> for w in words:\n"

"... print(w, len(w))\n"

"...\n"

"cat 3\n"

"window 6\n"

"defenestrate 12"

msgstr ""

">>> # Einige Zeichenketten messen:\n"

">>> words = ['cat', 'window', 'defenestrate']\n"

">>> for w in words:\n"

"... print(w, len(w))\n"

"...\n"

"cat 3\n"

"window 6\n"

"defenestrate 12"

#: ../../tutorial/controlflow.rst:72

msgid ""

"Code that modifies a collection while iterating over that same collection "

"can be tricky to get right. Instead, it is usually more straight-forward to "

"loop over a copy of the collection or to create a new collection::"

msgstr ""

"Code, der eine Sammlung verändert, während über dieselbe Sammlung iteriert "

"wird, kann knifflig sein. Stattdessen ist es gewöhnlich einfacher, über eine "

"Kopie der Sammlung zu iterieren oder eine neue Sammlung zu erstellen::"

#: ../../tutorial/controlflow.rst:76

msgid ""

"# Create a sample collection\n"

"users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}\n"

"\n"

"# Strategy: Iterate over a copy\n"

"for user, status in users.copy().items():\n"

" if status == 'inactive':\n"

" del users[user]\n"

"\n"

"# Strategy: Create a new collection\n"

"active_users = {}\n"

"for user, status in users.items():\n"

" if status == 'active':\n"

" active_users[user] = status"

msgstr ""

"# Eine Beispiel-Sammlung erstellen\n"

"users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}\n"

"\n"

"# Strategie: Über eine Kopie iterieren\n"

"for user, status in users.copy().items():\n"

" if status == 'inactive':\n"

" del users[user]\n"

"\n"

"# Strategie: Eine neue Sammlung erstellen\n"

"active_users = {}\n"

"for user, status in users.items():\n"

" if status == 'active':\n"

" active_users[user] = status"

#: ../../tutorial/controlflow.rst:94

msgid "The :func:`range` Function"

msgstr "Die Funktion :func:`range`"

#: ../../tutorial/controlflow.rst:96

msgid ""

"If you do need to iterate over a sequence of numbers, the built-in function :"

"func:`range` comes in handy. It generates arithmetic progressions::"

msgstr ""

"Wenn du über eine Zahlenfolge iterieren musst, ist die integrierte Funktion :"

"func:`range` praktisches Hilfsmittel. Sie erzeugt arithmetische Folgen::"

#: ../../tutorial/controlflow.rst:99

msgid ""

">>> for i in range(5):\n"

"... print(i)\n"

"...\n"

"0\n"

"1\n"

"2\n"

"3\n"

"4"

msgstr ""

">>> for i in range(5):\n"

"... print(i)\n"

"...\n"

"0\n"

"1\n"

"2\n"

"3\n"

"4"

#: ../../tutorial/controlflow.rst:108

msgid ""

"The given end point is never part of the generated sequence; ``range(10)`` "

"generates 10 values, the legal indices for items of a sequence of length "

"10. It is possible to let the range start at another number, or to specify "

"a different increment (even negative; sometimes this is called the 'step')::"

msgstr ""

"Der angegebene Endpunkt ist nie Teil der erzeugten Sequenz; ``range(10)`` "

"erzeugt 10 Werte, welche genau den gültigen Indizes für die Elemente einer "

"Sequenz der Länge 10 entsprechen. Es ist möglich, die Spanne bei einer "

"anderen Zahl beginnen zu lassen oder einen anderen Schrittabstand anzugeben "

"(sogar negativ – manchmal wird dies als „Schrittweite“ bezeichnet)::"

#: ../../tutorial/controlflow.rst:113

msgid ""

">>> list(range(5, 10))\n"

"[5, 6, 7, 8, 9]\n"

"\n"

">>> list(range(0, 10, 3))\n"

"[0, 3, 6, 9]\n"

"\n"

">>> list(range(-10, -100, -30))\n"

"[-10, -40, -70]"

msgstr ""

">>> list(range(5, 10))\n"

"[5, 6, 7, 8, 9]\n"

"\n"

">>> list(range(0, 10, 3))\n"

"[0, 3, 6, 9]\n"

"\n"

">>> list(range(-10, -100, -30))\n"

"[-10, -40, -70]"

#: ../../tutorial/controlflow.rst:122

msgid ""

"To iterate over the indices of a sequence, you can combine :func:`range` "

"and :func:`len` as follows::"

msgstr ""

"Um über die Indizes einer Sequenz zu iterieren, kannst du :func:`range` und :"

"func:`len` wie folgt kombinieren::"

#: ../../tutorial/controlflow.rst:125

msgid ""

">>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n"

">>> for i in range(len(a)):\n"

"... print(i, a[i])\n"

"...\n"

"0 Mary\n"

"1 had\n"

"2 a\n"

"3 little\n"

"4 lamb"

msgstr ""

">>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n"

">>> for i in range(len(a)):\n"

"... print(i, a[i])\n"

"...\n"

"0 Mary\n"

"1 had\n"

"2 a\n"

"3 little\n"

"4 lamb"

#: ../../tutorial/controlflow.rst:135

msgid ""

"In most such cases, however, it is convenient to use the :func:`enumerate` "

"function, see :ref:`tut-loopidioms`."

msgstr ""

"In den meisten dieser Fälle ist es jedoch praktischer, die Funktion :func:"

"`enumerate` zu verwenden, siehe :ref:`tut-loopidioms`."

#: ../../tutorial/controlflow.rst:138

msgid "A strange thing happens if you just print a range::"

msgstr "Etwas Merkwürdiges passiert, wenn du ein range einfach ausgibst::"

#: ../../tutorial/controlflow.rst:140

msgid ""

">>> range(10)\n"

"range(0, 10)"

msgstr ""

">>> range(10)\n"

"range(0, 10)"

#: ../../tutorial/controlflow.rst:143

msgid ""

"In many ways the object returned by :func:`range` behaves as if it is a "

"list, but in fact it isn't. It is an object which returns the successive "

"items of the desired sequence when you iterate over it, but it doesn't "

"really make the list, thus saving space."

msgstr ""

"In vielerlei Hinsicht verhält sich das von :func:`range` zurückgegebene "

"Objekt wie eine Liste, aber das ist es in Wahrheit nicht. Es ist ein Objekt, "

"das die aufeinanderfolgenden Elemente der gewünschten Sequenz zurückgibt, "

"wenn man darüber iteriert, aber es erstellt die Liste nicht wirklich und "

"spart so Speicherplatz."

#: ../../tutorial/controlflow.rst:148

msgid ""

"We say such an object is :term:`iterable`, that is, suitable as a target for "

"functions and constructs that expect something from which they can obtain "

"successive items until the supply is :term:`exhausted`. We have seen that "

"the :keyword:`for` statement is such a construct, while an example of a "

"function that takes an iterable is :func:`sum`::"

msgstr ""

"Wir nennen ein solches Objekt :term:`iterierbar <iterable>`, das heißt, es "

"eignet sich als Ziel für Funktionen und Konstrukte, die etwas erwarten, "

"woraus sie aufeinanderfolgende Elemente beziehen können, bis der Vorrat :"

"term:`erschöpft <exhausted>` ist. Wir haben gesehen, dass die :keyword:`for`-"

"Anweisung ein solches Konstrukt ist, während ein Beispiel für eine Funktion, "

"die ein iterierbares Objekt entgegennimmt, :func:`sum` ist::"

#: ../../tutorial/controlflow.rst:154

msgid ""

">>> sum(range(4)) # 0 + 1 + 2 + 3\n"

"6"

msgstr ""

">>> sum(range(4)) # 0 + 1 + 2 + 3\n"

"6"

#: ../../tutorial/controlflow.rst:157

msgid ""

"Later we will see more functions that return iterables and take iterables as "

"arguments. In chapter :ref:`tut-structures`, we will discuss :func:`list` "

"in more detail."

msgstr ""

"Später werden wir weitere Funktionen sehen, die Iterables zurückgeben und "

"Iterables als Argumente entgegennehmen. Im Kapitel :ref:`tut-structures` "

"werden wir genauer über :func:`list` sprechen."

#: ../../tutorial/controlflow.rst:164

msgid ":keyword:`!break` and :keyword:`!continue` Statements"

msgstr ":keyword:`!break`- und :keyword:`!continue`-Anweisungen"

#: ../../tutorial/controlflow.rst:166

msgid ""

"The :keyword:`break` statement breaks out of the innermost enclosing :"

"keyword:`for` or :keyword:`while` loop::"

msgstr ""

"Die :keyword:`break`-Anweisung bricht aus der innersten umschließenden :"

"keyword:`for`- oder :keyword:`while`-Schleife aus::"

#: ../../tutorial/controlflow.rst:169

msgid ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(f\"{n} equals {x} * {n//x}\")\n"

"... break\n"

"...\n"

"4 equals 2 * 2\n"

"6 equals 2 * 3\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

msgstr ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(f\"{n} equals {x} * {n//x}\")\n"

"... break\n"

"...\n"

"4 equals 2 * 2\n"

"6 equals 2 * 3\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

#: ../../tutorial/controlflow.rst:180

msgid ""

"The :keyword:`continue` statement continues with the next iteration of the "

"loop::"

msgstr ""

"Die :keyword:`continue`-Anweisung setzt die Ausführung mit der nächsten "

"Iteration der Schleife fort::"

#: ../../tutorial/controlflow.rst:183

msgid ""

">>> for num in range(2, 10):\n"

"... if num % 2 == 0:\n"

"... print(f\"Found an even number {num}\")\n"

"... continue\n"

"... print(f\"Found an odd number {num}\")\n"

"...\n"

"Found an even number 2\n"

"Found an odd number 3\n"

"Found an even number 4\n"

"Found an odd number 5\n"

"Found an even number 6\n"

"Found an odd number 7\n"

"Found an even number 8\n"

"Found an odd number 9"

msgstr ""

">>> for num in range(2, 10):\n"

"... if num % 2 == 0:\n"

"... print(f\"Found an even number {num}\")\n"

"... continue\n"

"... print(f\"Found an odd number {num}\")\n"

"...\n"

"Found an even number 2\n"

"Found an odd number 3\n"

"Found an even number 4\n"

"Found an odd number 5\n"

"Found an even number 6\n"

"Found an odd number 7\n"

"Found an even number 8\n"

"Found an odd number 9"

#: ../../tutorial/controlflow.rst:202

msgid ":keyword:`!else` Clauses on Loops"

msgstr ":keyword:`!else`-Klauseln bei Schleifen"

#: ../../tutorial/controlflow.rst:204

msgid ""

"In a :keyword:`!for` or :keyword:`!while` loop the :keyword:`!break` "

"statement may be paired with an :keyword:`!else` clause. If the loop "

"finishes without executing the :keyword:`!break`, the :keyword:`!else` "

"clause executes."

msgstr ""

"In einer :keyword:`!for`- oder :keyword:`!while`-Schleife kann die :keyword:"

"`!break`-Anweisung mit einer :keyword:`!else`-Klausel kombiniert werden. "

"Wenn die Schleife beendet wird, ohne dass :keyword:`!break` ausgeführt "

"wurde, wird die :keyword:`!else`-Klausel ausgeführt."

#: ../../tutorial/controlflow.rst:208

msgid ""

"In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the "

"loop finishes its final iteration, that is, if no break occurred."

msgstr ""

"In einer :keyword:`for`-Schleife wird die :keyword:`!else`-Klausel "

"ausgeführt, nachdem die Schleife ihre letzte Iteration beendet hat, also "

"wenn kein break aufgetreten ist."

#: ../../tutorial/controlflow.rst:211

msgid ""

"In a :keyword:`while` loop, it's executed after the loop's condition becomes "

"false."

msgstr ""

"In einer :keyword:`while`-Schleife wird sie ausgeführt, nachdem die "

"Bedingung der Schleife falsch wird."

#: ../../tutorial/controlflow.rst:213

msgid ""

"In either kind of loop, the :keyword:`!else` clause is **not** executed if "

"the loop was terminated by a :keyword:`break`. Of course, other ways of "

"ending the loop early, such as a :keyword:`return` or a raised exception, "

"will also skip execution of the :keyword:`else` clause."

msgstr ""

"In beiden Schleifenarten wird die :keyword:`!else`-Klausel **nicht** "

"ausgeführt, wenn die Schleife durch ein :keyword:`break` abgebrochen wurde. "

"Andere Arten, die Schleife vorzeitig zu beenden, wie etwa ein :keyword:"

"`return` oder eine ausgelöste Ausnahme (Exception), überspringen die "

"Ausführung der :keyword:`else`-Klausel natürlich ebenfalls."

#: ../../tutorial/controlflow.rst:218

msgid ""

"This is exemplified in the following :keyword:`!for` loop, which searches "

"for prime numbers::"

msgstr ""

"Dies wird in der folgenden :keyword:`!for`-Schleife veranschaulicht, die "

"nach Primzahlen sucht::"

#: ../../tutorial/controlflow.rst:221

msgid ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(n, 'equals', x, '*', n//x)\n"

"... break\n"

"... else:\n"

"... # loop fell through without finding a factor\n"

"... print(n, 'is a prime number')\n"

"...\n"

"2 is a prime number\n"

"3 is a prime number\n"

"4 equals 2 * 2\n"

"5 is a prime number\n"

"6 equals 2 * 3\n"

"7 is a prime number\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

msgstr ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(n, 'equals', x, '*', n//x)\n"

"... break\n"

"... else:\n"

"... # loop fell through without finding a factor\n"

"... print(n, 'is a prime number')\n"

"...\n"

"2 is a prime number\n"

"3 is a prime number\n"

"4 equals 2 * 2\n"

"5 is a prime number\n"

"6 equals 2 * 3\n"

"7 is a prime number\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

#: ../../tutorial/controlflow.rst:239

msgid ""

"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "

"to the ``for`` loop, **not** the ``if`` statement.)"

msgstr ""

"(Ja, das ist der korrekte Code. Sieh genau hin: Die ``else``-Klausel gehört "

"zur ``for``-Schleife, **nicht** zur ``if``-Anweisung.)"

#: ../../tutorial/controlflow.rst:242

msgid ""

"One way to think of the else clause is to imagine it paired with the ``if`` "

"inside the loop. As the loop executes, it will run a sequence like if/if/if/"

"else. The ``if`` is inside the loop, encountered a number of times. If the "

"condition is ever true, a ``break`` will happen. If the condition is never "

"true, the ``else`` clause outside the loop will execute."

msgstr ""

"Eine Möglichkeit, sich die else-Klausel vorzustellen, besteht darin, sie "

"gedanklich mit dem ``if`` innerhalb der Schleife zu koppeln. Wenn die "

"Schleife ausgeführt wird, durchläuft sie eine Sequenz wie if/if/if/else. Das "

"``if`` befindet sich innerhalb der Schleife und wird mehrmals angetroffen. "

"Wenn die Bedingung irgendwann wahr ist, erfolgt ein ``break``. Wenn die "

"Bedingung nie wahr ist, wird die ``else``-Klausel außerhalb der Schleife "

"ausgeführt."

#: ../../tutorial/controlflow.rst:248

msgid ""

"When used with a loop, the ``else`` clause has more in common with the "

"``else`` clause of a :keyword:`try` statement than it does with that of "

"``if`` statements: a ``try`` statement's ``else`` clause runs when no "

"exception occurs, and a loop's ``else`` clause runs when no ``break`` "

"occurs. For more on the ``try`` statement and exceptions, see :ref:`tut-"

"handling`."

msgstr ""

"Wenn sie mit einer Schleife verwendet wird, hat die ``else``-Klausel mehr "

"mit der ``else``-Klausel einer :keyword:`try`-Anweisung gemeinsam als mit "

"der von ``if``-Anweisungen: Die ``else``-Klausel einer ``try``-Anweisung "

"wird ausgeführt, wenn keine Ausnahme auftritt, und die ``else``-Klausel "

"einer Schleife wird ausgeführt, wenn kein ``break`` auftritt. Für weitere "

"Informationen zur ``try``-Anweisung und zu Ausnahmen siehe :ref:`tut-"

"handling`."

#: ../../tutorial/controlflow.rst:258

msgid ":keyword:`!pass` Statements"

msgstr ":keyword:`!pass`-Anweisungen"

#: ../../tutorial/controlflow.rst:260

msgid ""

"The :keyword:`pass` statement does nothing. It can be used when a statement "

"is required syntactically but the program requires no action. For example::"

msgstr ""

"Die :keyword:`pass`-Anweisung tut nichts. Sie kann verwendet werden, wenn "

"eine Anweisung syntaktisch erforderlich ist, das Programm aber keine Aktion "

"erfordert. Zum Beispiel::"

#: ../../tutorial/controlflow.rst:263

msgid ""

">>> while True:\n"

"... pass # Busy-wait for keyboard interrupt (Ctrl+C)\n"

"..."

msgstr ""

">>> while True:\n"

"... pass # Warten auf Tastaturunterbrechung (Strg+C)\n"

"..."

#: ../../tutorial/controlflow.rst:267

msgid "This is commonly used for creating minimal classes::"

msgstr "Dies wird häufig verwendet, um minimale Klassen zu erstellen::"

#: ../../tutorial/controlflow.rst:269

msgid ""

">>> class MyEmptyClass:\n"

"... pass\n"

"..."

msgstr ""

">>> class MyEmptyClass:\n"

"... pass\n"

"..."

#: ../../tutorial/controlflow.rst:273

msgid ""

"Another place :keyword:`pass` can be used is as a place-holder for a "

"function or conditional body when you are working on new code, allowing you "

"to keep thinking at a more abstract level. The :keyword:`!pass` is silently "

"ignored::"

msgstr ""

"Ein weiterer Ort, an dem :keyword:`pass` verwendet werden kann, ist als "

"Platzhalter für einen Funktionsrumpf oder einen bedingten Zweig, wenn du an "

"neuem Code arbeiten. So kannst du weiterhin auf einer abstrakteren Ebene "

"denken. Das :keyword:`!pass` wird stillschweigend ignoriert::"

#: ../../tutorial/controlflow.rst:277

msgid ""

">>> def initlog(*args):\n"

"... pass # Remember to implement this!\n"

"..."

msgstr ""

">>> def initlog(*args):\n"

"... pass # Denke daran, dies zu implementieren!\n"

"..."

#: ../../tutorial/controlflow.rst:281

msgid ""

"For this last case, many people use the ellipsis literal :code:`...` instead "

"of :code:`pass`. This use has no special meaning to Python, and is not part "

"of the language definition (you could use any constant expression here), "

"but :code:`...` is used conventionally as a placeholder body as well. See :"

"ref:`bltin-ellipsis-object`."

msgstr ""

"Für diesen letzten Fall verwenden viele Leute das Ellipsis-Literal :code:`..."

"` anstelle von :code:`pass`. Diese Verwendung hat für Python keine besondere "

"Bedeutung und ist kein Teil der Sprachdefinition (Du könntes hier jeden "

"konstanten Ausdruck verwenden), aber :code:`...` wird konventionell "

"ebenfalls als Platzhalter für einen Rumpf verwendet. Siehe :ref:`bltin-"

"ellipsis-object`."

#: ../../tutorial/controlflow.rst:291

msgid ":keyword:`!match` Statements"

msgstr ":keyword:`!match`-Anweisungen"

#: ../../tutorial/controlflow.rst:293

msgid ""

"A :keyword:`match` statement takes an expression and compares its value to "

"successive patterns given as one or more case blocks. This is superficially "

"similar to a switch statement in C, Java or JavaScript (and many other "

"languages), but it's more similar to pattern matching in languages like Rust "

"or Haskell. Only the first pattern that matches gets executed and it can "

"also extract components (sequence elements or object attributes) from the "

"value into variables. If no case matches, none of the branches is executed."

msgstr ""

"Eine :keyword:`match`-Anweisung nimmt einen Ausdruck entgegen und vergleicht "

"dessen Wert mit aufeinanderfolgenden Mustern, die als ein oder mehrere case-"

"Blöcke angegeben sind. Dies ähnelt oberflächlich einer switch-Anweisung in "

"C, Java oder JavaScript (und vielen anderen Sprachen), entspricht aber eher "

"dem Pattern Matching in Sprachen wie Rust oder Haskell. Nur das erste "

"Muster, das passt, wird ausgeführt, und es kann auch Komponenten "

"(Sequenzelemente oder Objektattribute) aus dem Wert in Variablen "

"extrahieren. Wenn kein case passt, wird keiner der Zweige ausgeführt."

#: ../../tutorial/controlflow.rst:302

msgid ""

"The simplest form compares a subject value against one or more literals::"

msgstr ""

"Die einfachste Form vergleicht einen Subjektwert mit einem oder mehreren "

"Literalen::"

#: ../../tutorial/controlflow.rst:304

msgid ""

"def http_error(status):\n"

" match status:\n"

" case 400:\n"

" return \"Bad request\"\n"

" case 404:\n"

" return \"Not found\"\n"

" case 418:\n"

" return \"I'm a teapot\"\n"

" case _:\n"

" return \"Something's wrong with the internet\""

msgstr ""

"def http_error(status):\n"

" match status:\n"

" case 400:\n"

" return \"Bad request\"\n"

" case 404:\n"

" return \"Not found\"\n"

" case 418:\n"

" return \"I'm a teapot\"\n"

" case _:\n"

" return \"Something's wrong with the internet\""

#: ../../tutorial/controlflow.rst:315

msgid ""

"Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and "

"never fails to match."

msgstr ""

"Beachte den letzten Block: Der \\\"Variablenname\\\" ``_`` fungiert als "

"*Platzhalter* (Wildcard) und passt immer."

#: ../../tutorial/controlflow.rst:318

msgid ""

"You can combine several literals in a single pattern using ``|`` (\"or\")::"

msgstr ""

"Du kannst mehrere Literale in einem einzigen Muster mithilfe von ``|`` (\\"

"\"oder\\\") kombinieren::"

#: ../../tutorial/controlflow.rst:320

msgid ""

"case 401 | 403 | 404:\n"

" return \"Not allowed\""

msgstr ""

"case 401 | 403 | 404:\n"

" return \"Not allowed\""

#: ../../tutorial/controlflow.rst:323

msgid ""

"Patterns can look like unpacking assignments, and can be used to bind "

"variables::"

msgstr ""

"Muster können wie Entpackungs-Zuweisungen aussehen und verwendet werden, um "

"Variablen zu binden::"

#: ../../tutorial/controlflow.rst:326

msgid ""

"# point is an (x, y) tuple\n"

"match point:\n"

" case (0, 0):\n"

" print(\"Origin\")\n"

" case (0, y):\n"

" print(f\"Y={y}\")\n"

" case (x, 0):\n"

" print(f\"X={x}\")\n"

" case (x, y):\n"

" print(f\"X={x}, Y={y}\")\n"

" case _:\n"

" raise ValueError(\"Not a point\")"

msgstr ""

"# point ist ein (x, y)-Tupel\n"

"match point:\n"

" case (0, 0):\n"

" print(\"Origin\")\n"

" case (0, y):\n"

" print(f\"Y={y}\")\n"

" case (x, 0):\n"

" print(f\"X={x}\")\n"

" case (x, y):\n"

" print(f\"X={x}, Y={y}\")\n"

" case _:\n"

" raise ValueError(\"Not a point\")"

#: ../../tutorial/controlflow.rst:339

msgid ""

"Study that one carefully! The first pattern has two literals, and can be "

"thought of as an extension of the literal pattern shown above. But the next "

"two patterns combine a literal and a variable, and the variable *binds* a "

"value from the subject (``point``). The fourth pattern captures two values, "

"which makes it conceptually similar to the unpacking assignment ``(x, y) = "

"point``."

msgstr ""

"Schau es dir genau an! Das erste Muster hat zwei Literale und kann als "

"Erweiterung des oben gezeigten Literal-Musters betrachtet werden. Die "

"nächsten beiden Muster kombinieren jedoch ein Literal und eine Variable, und "

"die Variable *bindet* einen Wert aus dem Subjekt (``point``). Das vierte "

"Muster erfasst zwei Werte, was es konzeptionell ähnlich wie das Entpacken "

"einer Zuweisung ``(x, y) = point`` macht."

#: ../../tutorial/controlflow.rst:346

msgid ""

"If you are using classes to structure your data you can use the class name "

"followed by an argument list resembling a constructor, but with the ability "

"to capture attributes into variables::"

msgstr ""

"Wenn du Klassen zur Strukturierung deiner Daten verwenden, kannst du den "

"Klassennamen gefolgt von einer Argumentliste verwenden, die einem "

"Konstruktor ähneln, jedoch die Möglichkeit bieten, Attribute in Variablen zu "

"erfassen::"

#: ../../tutorial/controlflow.rst:350

msgid ""

"class Point:\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"def where_is(point):\n"

" match point:\n"

" case Point(x=0, y=0):\n"

" print(\"Origin\")\n"

" case Point(x=0, y=y):\n"

" print(f\"Y={y}\")\n"

" case Point(x=x, y=0):\n"

" print(f\"X={x}\")\n"

" case Point():\n"

" print(\"Somewhere else\")\n"

" case _:\n"

" print(\"Not a point\")"

msgstr ""

"class Point:\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"def where_is(point):\n"

" match point:\n"

" case Point(x=0, y=0):\n"

" print(\"Origin\")\n"

" case Point(x=0, y=y):\n"

" print(f\"Y={y}\")\n"

" case Point(x=x, y=0):\n"

" print(f\"X={x}\")\n"

" case Point():\n"

" print(\"Somewhere else\")\n"

" case _:\n"

" print(\"Not a point\")"

#: ../../tutorial/controlflow.rst:368

msgid ""

"You can use positional parameters with some builtin classes that provide an "

"ordering for their attributes (e.g. dataclasses). You can also define a "

"specific position for attributes in patterns by setting the "

"``__match_args__`` special attribute in your classes. If it's set to (\"x\", "

"\"y\"), the following patterns are all equivalent (and all bind the ``y`` "

"attribute to the ``var`` variable)::"

msgstr ""

"Du kannst Positions-Parameter mit einigen integrierten Klassen verwenden, "

"die eine Reihenfolge für ihre Attribute festlegen (z. B. dataclasses). Du "

"kannst auch eine spezifische Position für Attribute in Mustern definieren, "

"indem du das spezielle Attribut ``__match_args__`` in deinen Klassen setzt. "

"Wenn es auf (\\\"x\\\", \\\"y\\\") gesetzt ist, sind die folgenden Muster "

"alle äquivalent (und binden alle das Attribut ``y`` an die Variable "

"``var``)::"

#: ../../tutorial/controlflow.rst:374

msgid ""

"Point(1, var)\n"

"Point(1, y=var)\n"

"Point(x=1, y=var)\n"

"Point(y=var, x=1)"

msgstr ""

"Point(1, var)\n"

"Point(1, y=var)\n"

"Point(x=1, y=var)\n"

"Point(y=var, x=1)"

#: ../../tutorial/controlflow.rst:379

msgid ""

"A recommended way to read patterns is to look at them as an extended form of "

"what you would put on the left of an assignment, to understand which "

"variables would be set to what. Only the standalone names (like ``var`` "

"above) are assigned to by a match statement. Dotted names (like ``foo."

"bar``), attribute names (the ``x=`` and ``y=`` above) or class names "

"(recognized by the \"(...)\" next to them like ``Point`` above) are never "

"assigned to."

msgstr ""

"Eine empfohlene Art, Muster zu lesen, besteht darin, sie als eine erweiterte "

"Form dessen zu betrachten, was du auf die linke Seite einer Zuweisung setzen "

"würdest, um zu verstehen, welche Variablen auf was gesetzt werden. Nur den "

"einzeln stehenden Namen (wie ``var`` oben) wird von einer match-Anweisung "

"etwas zugewiesen. Namen mit Punkten (wie ``foo.bar``), Attributnamen (die "

"``x=`` und ``y=`` oben) oder Klassennamen (erkennbar am \"\\\"(...)\\\" "

"daneben wie ``Point`` oben) wird niemals etwas zugewiesen."

#: ../../tutorial/controlflow.rst:386

msgid ""

"Patterns can be arbitrarily nested. For example, if we have a short list of "

"Points, with ``__match_args__`` added, we could match it like this::"

msgstr ""

"Muster können beliebig verschachtelt werden. Wenn wir beispielsweise eine "

"kurze Liste von Point-Objekten haben, denen ``__match_args__`` hinzugefügt "

"wurde, könnten wir sie wie folgt abgleichen::"

#: ../../tutorial/controlflow.rst:389

msgid ""

"class Point:\n"

" __match_args__ = ('x', 'y')\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"match points:\n"

" case []:\n"

" print(\"No points\")\n"

" case [Point(0, 0)]:\n"

" print(\"The origin\")\n"

" case [Point(x, y)]:\n"

" print(f\"Single point {x}, {y}\")\n"

" case [Point(0, y1), Point(0, y2)]:\n"

" print(f\"Two on the Y axis at {y1}, {y2}\")\n"

" case _:\n"

" print(\"Something else\")"

msgstr ""

"class Point:\n"

" __match_args__ = ('x', 'y')\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"match points:\n"

" case []:\n"

" print(\"No points\")\n"

" case [Point(0, 0)]:\n"

" print(\"The origin\")\n"

" case [Point(x, y)]:\n"

" print(f\"Single point {x}, {y}\")\n"

" case [Point(0, y1), Point(0, y2)]:\n"

" print(f\"Two on the Y axis at {y1}, {y2}\")\n"

" case _:\n"

" print(\"Something else\")"

#: ../../tutorial/controlflow.rst:407

msgid ""

"We can add an ``if`` clause to a pattern, known as a \"guard\". If the "

"guard is false, ``match`` goes on to try the next case block. Note that "

"value capture happens before the guard is evaluated::"

msgstr ""

"Wir können einem Muster eine ``if``-Klausel hinzufügen, die als \\\"Guard\\ "

"(Wächter) bezeichnet wird. Wenn der Guard nicht zutrifft, fährt ``match`` "

"mit dem nächsten case-Block fort. Beachte, dass das Erfassen der Werte "

"erfolgt, bevor der Guard ausgewertet wird::"

#: ../../tutorial/controlflow.rst:411

msgid ""

"match point:\n"

" case Point(x, y) if x == y:\n"

" print(f\"Y=X at {x}\")\n"

" case Point(x, y):\n"

" print(f\"Not on the diagonal\")"

msgstr ""

"match point:\n"

" case Point(x, y) if x == y:\n"

" print(f\"Y=X at {x}\")\n"

" case Point(x, y):\n"

" print(f\"Not on the diagonal\")"

#: ../../tutorial/controlflow.rst:417

msgid "Several other key features of this statement:"

msgstr "Einige weitere Hauptmerkmale dieser Anweisung:"

#: ../../tutorial/controlflow.rst:419

msgid ""

"Like unpacking assignments, tuple and list patterns have exactly the same "

"meaning and actually match arbitrary sequences. An important exception is "

"that they don't match iterators or strings."

msgstr ""

"Wie bei Zuweisungen durch Entpacken haben Tupel- und Listenmuster exakt "

"dieselbe Bedeutung und passen tatsächlich auf beliebige Sequenzen. Eine "

"wichtige Ausnahme ist, dass sie nicht auf Iteratoren oder Zeichenketten "

"passen."

#: ../../tutorial/controlflow.rst:423

msgid ""

"Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, "

"*rest)`` work similar to unpacking assignments. The name after ``*`` may "

"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items "

"without binding the remaining items."

msgstr ""

"Sequenzmuster unterstützen erweitertes Entpacken: ``[x, y, *rest]`` und "

"``(x, y, *rest)`` funktionieren ähnlich wie Zuweisungen durch Entpacken. Der "

"Name nach ``*`` darf auch ``_`` sein, sodass ``(x, y, *_)`` auf eine Sequenz "

"von mindestens zwei Elementen passt, ohne die verbleibenden Elemente zu "

"binden."

#: ../../tutorial/controlflow.rst:428

msgid ""

"Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the "

"``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary. Unlike "

"sequence patterns, extra keys are ignored. An unpacking like ``**rest`` is "

"also supported. (But ``**_`` would be redundant, so it is not allowed.)"

msgstr ""

"Mapping-Muster: ``{\"bandwidth\": b, \"latency\": l}`` fängt die Werte "

"``\"bandwidth\"`` und ``\"latency\"`` aus einem Dictionary ab. Anders als "

"bei Sequenzmustern werden zusätzliche Schlüssel ignoriert. Ein Entpacken wie "

"``**rest`` wird ebenfalls unterstützt. (Aber ``**_`` wäre redundant und ist "

"daher nicht erlaubt.)"

#: ../../tutorial/controlflow.rst:433

msgid "Subpatterns may be captured using the ``as`` keyword::"

msgstr "Untermuster können mit dem Schlüsselwort ``as`` abgefangen werden::"

#: ../../tutorial/controlflow.rst:435

msgid "case (Point(x1, y1), Point(x2, y2) as p2): ..."

msgstr "case (Point(x1, y1), Point(x2, y2) as p2): ..."

#: ../../tutorial/controlflow.rst:437

msgid ""

"will capture the second element of the input as ``p2`` (as long as the input "

"is a sequence of two points)"

msgstr ""

"fängt das zweite Element der Eingabe als ``p2`` ab (solange die Eingabe eine "

"Sequenz aus zwei Punkten ist)"

#: ../../tutorial/controlflow.rst:440

msgid ""

"Most literals are compared by equality, however the singletons ``True``, "

"``False`` and ``None`` are compared by identity."

msgstr ""

"Die meisten Literale werden auf Gleichheit verglichen, die Singletons "

"``True``, ``False`` und ``None`` jedoch auf Identität."

#: ../../tutorial/controlflow.rst:443

msgid ""

"Patterns may use named constants. These must be dotted names to prevent "

"them from being interpreted as capture variables::"

msgstr ""

"Muster dürfen benannte Konstanten verwenden. Diese müssen punktierte Namen "

"sein, um zu verhindern, dass sie als Erfassungsvariable interpretiert "

"werden::"