# German translation of the Python documentation.

# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

# python-doc bot, 2025

# Swen Bachmann, 2026

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-08-22 12:07+0200\n"

"PO-Revision-Date: 2026-10-15 06:00+0200\n"

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

"Language-Team: German (https://github.com/python/python-docs-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"

#: ../../howto/enum.rst:5

msgid "Enum HOWTO"

msgstr "Enum-HOWTO"

#: ../../howto/enum.rst:11

msgid ""

"An :class:`Enum` is a set of symbolic names bound to unique values. They "

"are similar to global variables, but they offer a more useful :func:`repr`, "

"grouping, type-safety, and a few other features."

msgstr ""

"Ein :class:`Enum` ist eine Menge symbolischer Namen, die an eindeutige Werte "

"gebunden sind. Sie sind globalen Variablen ähnlich, bieten aber ein "

"nützlicheres :func:`repr`, Gruppierung, Typsicherheit und ein paar weitere "

"Eigenschaften."

#: ../../howto/enum.rst:15

msgid ""

"They are most useful when you have a variable that can take one of a limited "

"selection of values. For example, the days of the week::"

msgstr ""

"Am nützlichsten sind sie, wenn du eine Variable hast, die einen aus einer "

"begrenzten Auswahl von Werten annehmen kann. Zum Beispiel die Wochentage::"

#: ../../howto/enum.rst:18

msgid ""

">>> from enum import Enum\n"

">>> class Weekday(Enum):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 3\n"

"... THURSDAY = 4\n"

"... FRIDAY = 5\n"

"... SATURDAY = 6\n"

"... SUNDAY = 7"

msgstr ""

">>> from enum import Enum\n"

">>> class Weekday(Enum):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 3\n"

"... THURSDAY = 4\n"

"... FRIDAY = 5\n"

"... SATURDAY = 6\n"

"... SUNDAY = 7"

#: ../../howto/enum.rst:28

msgid "Or perhaps the RGB primary colors::"

msgstr "Oder vielleicht die RGB-Grundfarben::"

#: ../../howto/enum.rst:30

msgid ""

">>> from enum import Enum\n"

">>> class Color(Enum):\n"

"... RED = 1\n"

"... GREEN = 2\n"

"... BLUE = 3"

msgstr ""

">>> from enum import Enum\n"

">>> class Color(Enum):\n"

"... RED = 1\n"

"... GREEN = 2\n"

"... BLUE = 3"

#: ../../howto/enum.rst:36

msgid ""

"As you can see, creating an :class:`Enum` is as simple as writing a class "

"that inherits from :class:`Enum` itself."

msgstr ""

"Wie du siehst, ist ein :class:`Enum` zu erzeugen so einfach wie eine Klasse "

"zu schreiben, die von :class:`Enum` selbst erbt."

#: ../../howto/enum.rst:39

msgid "Case of Enum Members"

msgstr "Schreibweise von Enum-Mitgliedern"

#: ../../howto/enum.rst:41

msgid ""

"Because Enums are used to represent constants, and to help avoid issues with "

"name clashes between mixin-class methods/attributes and enum names, we "

"strongly recommend using UPPER_CASE names for members, and will be using "

"that style in our examples."

msgstr ""

"Weil Enums Konstanten darstellen und weil es Probleme mit Namenskollisionen "

"zwischen Methoden und Attributen von Mixin-Klassen und Enum-Namen vermeiden "

"hilft, empfehlen wir dringend GROSSBUCHSTABEN-Namen für Mitglieder und "

"verwenden diesen Stil in unseren Beispielen."

#: ../../howto/enum.rst:46

msgid ""

"Depending on the nature of the enum a member's value may or may not be "

"important, but either way that value can be used to get the corresponding "

"member::"

msgstr ""

"Je nach Art des Enums kann der Wert eines Mitglieds wichtig sein oder nicht, "

"aber in beiden Fällen lässt sich dieser Wert verwenden, um das zugehörige "

"Mitglied zu bekommen::"

#: ../../howto/enum.rst:50

msgid ""

">>> Weekday(3)\n"

"<Weekday.WEDNESDAY: 3>"

msgstr ""

">>> Weekday(3)\n"

"<Weekday.WEDNESDAY: 3>"

#: ../../howto/enum.rst:53

msgid ""

"As you can see, the ``repr()`` of a member shows the enum name, the member "

"name, and the value. The ``str()`` of a member shows only the enum name and "

"member name::"

msgstr ""

"Wie du siehst, zeigt das ``repr()`` eines Mitglieds den Enum-Namen, den "

"Mitgliedsnamen und den Wert. Das ``str()`` eines Mitglieds zeigt nur den "

"Enum-Namen und den Mitgliedsnamen::"

#: ../../howto/enum.rst:57

msgid ""

">>> print(Weekday.THURSDAY)\n"

"Weekday.THURSDAY"

msgstr ""

">>> print(Weekday.THURSDAY)\n"

"Weekday.THURSDAY"

#: ../../howto/enum.rst:60

msgid "The *type* of an enumeration member is the enum it belongs to::"

msgstr "Der *Typ* eines Aufzählungsmitglieds ist das Enum, zu dem es gehört::"

#: ../../howto/enum.rst:62

msgid ""

">>> type(Weekday.MONDAY)\n"

"<enum 'Weekday'>\n"

">>> isinstance(Weekday.FRIDAY, Weekday)\n"

"True"

msgstr ""

">>> type(Weekday.MONDAY)\n"

"<enum 'Weekday'>\n"

">>> isinstance(Weekday.FRIDAY, Weekday)\n"

"True"

#: ../../howto/enum.rst:67

msgid "Enum members have an attribute that contains just their :attr:`!name`::"

msgstr ""

"Enum-Mitglieder haben ein Attribut, das nur ihren :attr:`!name` enthält::"

#: ../../howto/enum.rst:69

msgid ""

">>> print(Weekday.TUESDAY.name)\n"

"TUESDAY"

msgstr ""

">>> print(Weekday.TUESDAY.name)\n"

"TUESDAY"

#: ../../howto/enum.rst:72

msgid "Likewise, they have an attribute for their :attr:`!value`::"

msgstr "Ebenso haben sie ein Attribut für ihren :attr:`!value`::"

#: ../../howto/enum.rst:75

msgid ""

">>> Weekday.WEDNESDAY.value\n"

"3"

msgstr ""

">>> Weekday.WEDNESDAY.value\n"

"3"

#: ../../howto/enum.rst:78

msgid ""

"Unlike many languages that treat enumerations solely as name/value pairs, "

"Python Enums can have behavior added. For example, :class:`datetime.date` "

"has two methods for returning the weekday: :meth:`~datetime.date.weekday` "

"and :meth:`~datetime.date.isoweekday`. The difference is that one of them "

"counts from 0-6 and the other from 1-7. Rather than keep track of that "

"ourselves we can add a method to the :class:`!Weekday` enum to extract the "

"day from the :class:`~datetime.date` instance and return the matching enum "

"member::"

msgstr ""

"Anders als viele Sprachen, die Aufzählungen ausschließlich als Name-Wert-"

"Paare behandeln, können Python-Enums Verhalten dazubekommen. So hat :class:"

"`datetime.date` zum Beispiel zwei Methoden, die den Wochentag zurückgeben: :"

"meth:`~datetime.date.weekday` und :meth:`~datetime.date.isoweekday`. Der "

"Unterschied ist, dass die eine von 0 bis 6 und die andere von 1 bis 7 zählt. "

"Anstatt das selbst im Kopf zu behalten, können wir dem Enum :class:`!"

"Weekday` eine Methode hinzufügen, die den Tag aus der :class:`~datetime."

"date`-Instanz zieht und das passende Enum-Mitglied zurückgibt::"

#: ../../howto/enum.rst:87

msgid ""

"@classmethod\n"

"def from_date(cls, date):\n"

" return cls(date.isoweekday())"

msgstr ""

"@classmethod\n"

"def from_date(cls, date):\n"

" return cls(date.isoweekday())"

#: ../../howto/enum.rst:91

msgid "The complete :class:`!Weekday` enum now looks like this::"

msgstr "Das vollständige Enum :class:`!Weekday` sieht nun so aus::"

#: ../../howto/enum.rst:93

msgid ""

">>> class Weekday(Enum):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 3\n"

"... THURSDAY = 4\n"

"... FRIDAY = 5\n"

"... SATURDAY = 6\n"

"... SUNDAY = 7\n"

"... #\n"

"... @classmethod\n"

"... def from_date(cls, date):\n"

"... return cls(date.isoweekday())"

msgstr ""

">>> class Weekday(Enum):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 3\n"

"... THURSDAY = 4\n"

"... FRIDAY = 5\n"

"... SATURDAY = 6\n"

"... SUNDAY = 7\n"

"... #\n"

"... @classmethod\n"

"... def from_date(cls, date):\n"

"... return cls(date.isoweekday())"

#: ../../howto/enum.rst:106

msgid "Now we can find out what today is! Observe::"

msgstr "Jetzt können wir herausfinden, welcher Tag heute ist! Sieh her::"

#: ../../howto/enum.rst:108

msgid ""

">>> import datetime as dt\n"

">>> Weekday.from_date(dt.date.today())\n"

"<Weekday.TUESDAY: 2>"

msgstr ""

">>> import datetime as dt\n"

">>> Weekday.from_date(dt.date.today())\n"

"<Weekday.TUESDAY: 2>"

#: ../../howto/enum.rst:112

msgid ""

"Of course, if you're reading this on some other day, you'll see that day "

"instead."

msgstr ""

"Wenn du das natürlich an einem anderen Tag liest, siehst du stattdessen "

"diesen Tag."

#: ../../howto/enum.rst:114

msgid ""

"This :class:`!Weekday` enum is great if our variable only needs one day, but "

"what if we need several? Maybe we're writing a function to plot chores "

"during a week, and don't want to use a :class:`list` -- we could use a "

"different type of :class:`Enum`::"

msgstr ""

"Dieses Enum :class:`!Weekday` ist großartig, wenn unsere Variable nur einen "

"Tag braucht – aber was, wenn wir mehrere brauchen? Vielleicht schreiben wir "

"eine Funktion, die Aufgaben über eine Woche verteilt, und wollen keine :"

"class:`list` verwenden – wir könnten eine andere Art von :class:`Enum` "

"nehmen::"

#: ../../howto/enum.rst:119

msgid ""

">>> from enum import Flag\n"

">>> class Weekday(Flag):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 4\n"

"... THURSDAY = 8\n"

"... FRIDAY = 16\n"

"... SATURDAY = 32\n"

"... SUNDAY = 64"

msgstr ""

">>> from enum import Flag\n"

">>> class Weekday(Flag):\n"

"... MONDAY = 1\n"

"... TUESDAY = 2\n"

"... WEDNESDAY = 4\n"

"... THURSDAY = 8\n"

"... FRIDAY = 16\n"

"... SATURDAY = 32\n"

"... SUNDAY = 64"

#: ../../howto/enum.rst:129

msgid ""

"We've changed two things: we're inherited from :class:`Flag`, and the values "

"are all powers of 2."

msgstr ""

"Wir haben zwei Dinge geändert: Wir erben von :class:`Flag`, und die Werte "

"sind alle Potenzen von 2."

#: ../../howto/enum.rst:132

msgid ""

"Just like the original :class:`!Weekday` enum above, we can have a single "

"selection::"

msgstr ""

"Genau wie beim ursprünglichen Enum :class:`!Weekday` oben können wir eine "

"einzelne Auswahl treffen::"

#: ../../howto/enum.rst:134

msgid ""

">>> first_week_day = Weekday.MONDAY\n"

">>> first_week_day\n"

"<Weekday.MONDAY: 1>"

msgstr ""

">>> first_week_day = Weekday.MONDAY\n"

">>> first_week_day\n"

"<Weekday.MONDAY: 1>"

#: ../../howto/enum.rst:138

msgid ""

"But :class:`Flag` also allows us to combine several members into a single "

"variable::"

msgstr ""

"Aber :class:`Flag` erlaubt es uns außerdem, mehrere Mitglieder in einer "

"einzigen Variablen zu verbinden::"

#: ../../howto/enum.rst:141

msgid ""

">>> weekend = Weekday.SATURDAY | Weekday.SUNDAY\n"

">>> weekend\n"

"<Weekday.SATURDAY|SUNDAY: 96>"

msgstr ""

">>> weekend = Weekday.SATURDAY | Weekday.SUNDAY\n"

">>> weekend\n"

"<Weekday.SATURDAY|SUNDAY: 96>"

#: ../../howto/enum.rst:145

msgid "You can even iterate over a :class:`Flag` variable::"

msgstr "Du kannst über eine :class:`Flag`-Variable sogar iterieren::"

#: ../../howto/enum.rst:147

msgid ""

">>> for day in weekend:\n"

"... print(day)\n"

"Weekday.SATURDAY\n"

"Weekday.SUNDAY"

msgstr ""

">>> for day in weekend:\n"

"... print(day)\n"

"Weekday.SATURDAY\n"

"Weekday.SUNDAY"

#: ../../howto/enum.rst:152

msgid "Okay, let's get some chores set up::"

msgstr "Gut, richten wir ein paar Aufgaben ein::"

#: ../../howto/enum.rst:154

msgid ""

">>> chores_for_ethan = {\n"

"... 'feed the cat': Weekday.MONDAY | Weekday.WEDNESDAY | Weekday."

"FRIDAY,\n"

"... 'do the dishes': Weekday.TUESDAY | Weekday.THURSDAY,\n"

"... 'answer SO questions': Weekday.SATURDAY,\n"

"... }"

msgstr ""

">>> chores_for_ethan = {\n"

"... 'feed the cat': Weekday.MONDAY | Weekday.WEDNESDAY | Weekday."

"FRIDAY,\n"

"... 'do the dishes': Weekday.TUESDAY | Weekday.THURSDAY,\n"

"... 'answer SO questions': Weekday.SATURDAY,\n"

"... }"

#: ../../howto/enum.rst:160

msgid "And a function to display the chores for a given day::"

msgstr "Und eine Funktion, die die Aufgaben für einen gegebenen Tag anzeigt::"

#: ../../howto/enum.rst:162

msgid ""

">>> def show_chores(chores, day):\n"

"... for chore, days in chores.items():\n"

"... if day in days:\n"

"... print(chore)\n"

"...\n"

">>> show_chores(chores_for_ethan, Weekday.SATURDAY)\n"

"answer SO questions"

msgstr ""

">>> def show_chores(chores, day):\n"

"... for chore, days in chores.items():\n"

"... if day in days:\n"

"... print(chore)\n"

"...\n"

">>> show_chores(chores_for_ethan, Weekday.SATURDAY)\n"

"answer SO questions"

#: ../../howto/enum.rst:170

msgid ""

"In cases where the actual values of the members do not matter, you can save "

"yourself some work and use :func:`auto` for the values::"

msgstr ""

"In Fällen, in denen die tatsächlichen Werte der Mitglieder keine Rolle "

"spielen, kannst du dir Arbeit sparen und für die Werte :func:`auto` "

"verwenden::"

#: ../../howto/enum.rst:173

msgid ""

">>> from enum import auto\n"

">>> class Weekday(Flag):\n"

"... MONDAY = auto()\n"

"... TUESDAY = auto()\n"

"... WEDNESDAY = auto()\n"

"... THURSDAY = auto()\n"

"... FRIDAY = auto()\n"

"... SATURDAY = auto()\n"

"... SUNDAY = auto()\n"

"... WEEKEND = SATURDAY | SUNDAY"

msgstr ""

">>> from enum import auto\n"

">>> class Weekday(Flag):\n"

"... MONDAY = auto()\n"

"... TUESDAY = auto()\n"

"... WEDNESDAY = auto()\n"

"... THURSDAY = auto()\n"

"... FRIDAY = auto()\n"

"... SATURDAY = auto()\n"

"... SUNDAY = auto()\n"

"... WEEKEND = SATURDAY | SUNDAY"

#: ../../howto/enum.rst:189

msgid "Programmatic access to enumeration members and their attributes"

msgstr ""

"Programmgesteuerter Zugriff auf Aufzählungsmitglieder und ihre Attribute"

#: ../../howto/enum.rst:191

msgid ""

"Sometimes it's useful to access members in enumerations programmatically (i."

"e. situations where ``Color.RED`` won't do because the exact color is not "

"known at program-writing time). ``Enum`` allows such access::"

msgstr ""

"Manchmal ist es nützlich, auf Mitglieder von Aufzählungen programmgesteuert "

"zuzugreifen (also in Lagen, in denen ``Color.RED`` nicht in Frage kommt, "

"weil die genaue Farbe zum Zeitpunkt des Programmierens nicht bekannt ist). "

"``Enum`` erlaubt solchen Zugriff::"

#: ../../howto/enum.rst:195

msgid ""

">>> Color(1)\n"

"<Color.RED: 1>\n"

">>> Color(3)\n"

"<Color.BLUE: 3>"

msgstr ""

">>> Color(1)\n"

"<Color.RED: 1>\n"

">>> Color(3)\n"

"<Color.BLUE: 3>"

#: ../../howto/enum.rst:200

msgid "If you want to access enum members by *name*, use item access::"

msgstr ""

"Wenn du über den *Namen* auf Enum-Mitglieder zugreifen willst, verwende den "

"Zugriff per Index::"

#: ../../howto/enum.rst:202

msgid ""

">>> Color['RED']\n"

"<Color.RED: 1>\n"

">>> Color['GREEN']\n"

"<Color.GREEN: 2>"

msgstr ""

">>> Color['RED']\n"

"<Color.RED: 1>\n"

">>> Color['GREEN']\n"

"<Color.GREEN: 2>"

#: ../../howto/enum.rst:207

msgid ""

"If you have an enum member and need its :attr:`!name` or :attr:`!value`::"

msgstr ""

"Wenn du ein Enum-Mitglied hast und seinen :attr:`!name` oder :attr:`!value` "

"brauchst::"

#: ../../howto/enum.rst:209

msgid ""

">>> member = Color.RED\n"

">>> member.name\n"

"'RED'\n"

">>> member.value\n"

"1"

msgstr ""

">>> member = Color.RED\n"

">>> member.name\n"

"'RED'\n"

">>> member.value\n"

"1"

#: ../../howto/enum.rst:217

msgid "Duplicating enum members and values"

msgstr "Enum-Mitglieder und -Werte doppeln"

#: ../../howto/enum.rst:219

msgid "Having two enum members with the same name is invalid::"

msgstr "Zwei Enum-Mitglieder mit demselben Namen zu haben ist unzulässig::"

#: ../../howto/enum.rst:221

msgid ""

">>> class Shape(Enum):\n"

"... SQUARE = 2\n"

"... SQUARE = 3\n"

"...\n"

"Traceback (most recent call last):\n"

"...\n"

"TypeError: 'SQUARE' already defined as 2"

msgstr ""

">>> class Shape(Enum):\n"

"... SQUARE = 2\n"

"... SQUARE = 3\n"

"...\n"

"Traceback (most recent call last):\n"

"...\n"

"TypeError: 'SQUARE' already defined as 2"

#: ../../howto/enum.rst:229

msgid ""

"However, an enum member can have other names associated with it. Given two "

"entries ``A`` and ``B`` with the same value (and ``A`` defined first), ``B`` "

"is an alias for the member ``A``. By-value lookup of the value of ``A`` "

"will return the member ``A``. By-name lookup of ``A`` will return the "

"member ``A``. By-name lookup of ``B`` will also return the member ``A``::"

msgstr ""

"Einem Enum-Mitglied können aber andere Namen zugeordnet sein. Gegeben seien "

"zwei Einträge ``A`` und ``B`` mit demselben Wert (und ``A`` zuerst "

"definiert). Dann ist ``B`` ein Alias für das Mitglied ``A``. Ein "

"Nachschlagen des Werts von ``A`` über den Wert gibt das Mitglied ``A`` "

"zurück. Ein Nachschlagen von ``A`` über den Namen gibt das Mitglied ``A`` "

"zurück. Ein Nachschlagen von ``B`` über den Namen gibt ebenfalls das "

"Mitglied ``A`` zurück::"

#: ../../howto/enum.rst:235

msgid ""

">>> class Shape(Enum):\n"

"... SQUARE = 2\n"

"... DIAMOND = 1\n"

"... CIRCLE = 3\n"

"... ALIAS_FOR_SQUARE = 2\n"

"...\n"

">>> Shape.SQUARE\n"

"<Shape.SQUARE: 2>\n"

">>> Shape.ALIAS_FOR_SQUARE\n"

"<Shape.SQUARE: 2>\n"

">>> Shape(2)\n"

"<Shape.SQUARE: 2>"

msgstr ""

">>> class Shape(Enum):\n"

"... SQUARE = 2\n"

"... DIAMOND = 1\n"

"... CIRCLE = 3\n"

"... ALIAS_FOR_SQUARE = 2\n"

"...\n"

">>> Shape.SQUARE\n"

"<Shape.SQUARE: 2>\n"

">>> Shape.ALIAS_FOR_SQUARE\n"

"<Shape.SQUARE: 2>\n"

">>> Shape(2)\n"

"<Shape.SQUARE: 2>"

#: ../../howto/enum.rst:250

msgid ""

"Attempting to create a member with the same name as an already defined "

"attribute (another member, a method, etc.) or attempting to create an "

"attribute with the same name as a member is not allowed."

msgstr ""

"Zu versuchen, ein Mitglied mit demselben Namen wie ein bereits definiertes "

"Attribut (ein anderes Mitglied, eine Methode usw.) zu erzeugen, oder ein "

"Attribut mit demselben Namen wie ein Mitglied zu erzeugen, ist nicht erlaubt."

#: ../../howto/enum.rst:256

msgid "Ensuring unique enumeration values"

msgstr "Eindeutige Aufzählungswerte sicherstellen"

#: ../../howto/enum.rst:258

msgid ""

"By default, enumerations allow multiple names as aliases for the same value. "

"When this behavior isn't desired, you can use the :deco:`unique` decorator::"

msgstr ""

"Standardmäßig erlauben Aufzählungen mehrere Namen als Aliase für denselben "

"Wert. Ist dieses Verhalten nicht gewünscht, kannst du den Decorator :deco:"

"`unique` verwenden::"

#: ../../howto/enum.rst:261

msgid ""

">>> from enum import Enum, unique\n"

">>> @unique\n"

"... class Mistake(Enum):\n"

"... ONE = 1\n"

"... TWO = 2\n"

"... THREE = 3\n"

"... FOUR = 3\n"

"...\n"

"Traceback (most recent call last):\n"

"...\n"

"ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE"

msgstr ""

">>> from enum import Enum, unique\n"

">>> @unique\n"

"... class Mistake(Enum):\n"

"... ONE = 1\n"

"... TWO = 2\n"

"... THREE = 3\n"

"... FOUR = 3\n"

"...\n"

"Traceback (most recent call last):\n"

"...\n"

"ValueError: duplicate values found in <enum 'Mistake'>: FOUR -> THREE"

#: ../../howto/enum.rst:275

msgid "Using automatic values"

msgstr "Automatische Werte verwenden"

#: ../../howto/enum.rst:277

msgid "If the exact value is unimportant you can use :class:`auto`::"

msgstr "Ist der genaue Wert unwichtig, kannst du :class:`auto` verwenden::"

#: ../../howto/enum.rst:279

msgid ""

">>> from enum import Enum, auto\n"

">>> class Color(Enum):\n"

"... RED = auto()\n"

"... BLUE = auto()\n"

"... GREEN = auto()\n"

"...\n"

">>> [member.value for member in Color]\n"

"[1, 2, 3]"

msgstr ""

">>> from enum import Enum, auto\n"

">>> class Color(Enum):\n"

"... RED = auto()\n"

"... BLUE = auto()\n"

"... GREEN = auto()\n"

"...\n"

">>> [member.value for member in Color]\n"

"[1, 2, 3]"

#: ../../howto/enum.rst:288

msgid ""

"The values are chosen by :func:`~Enum._generate_next_value_`, which can be "

"overridden::"

msgstr ""

"Die Werte werden von :func:`~Enum._generate_next_value_` gewählt, das sich "

"überschreiben lässt::"

#: ../../howto/enum.rst:291

msgid ""

">>> class AutoName(Enum):\n"

"... @staticmethod\n"

"... def _generate_next_value_(name, start, count, last_values):\n"

"... return name\n"

"...\n"

">>> class Ordinal(AutoName):\n"

"... NORTH = auto()\n"

"... SOUTH = auto()\n"

"... EAST = auto()\n"

"... WEST = auto()\n"

"...\n"

">>> [member.value for member in Ordinal]\n"

"['NORTH', 'SOUTH', 'EAST', 'WEST']"

msgstr ""

">>> class AutoName(Enum):\n"

"... @staticmethod\n"

"... def _generate_next_value_(name, start, count, last_values):\n"

"... return name\n"

"...\n"

">>> class Ordinal(AutoName):\n"

"... NORTH = auto()\n"

"... SOUTH = auto()\n"

"... EAST = auto()\n"

"... WEST = auto()\n"

"...\n"

">>> [member.value for member in Ordinal]\n"

"['NORTH', 'SOUTH', 'EAST', 'WEST']"

#: ../../howto/enum.rst:307

msgid ""

"The :meth:`~Enum._generate_next_value_` method must be defined before any "

"members."

msgstr ""

"Die Methode :meth:`~Enum._generate_next_value_` muss vor allen Mitgliedern "

"definiert werden."

#: ../../howto/enum.rst:310

msgid "Iteration"

msgstr "Iteration"

#: ../../howto/enum.rst:312

msgid "Iterating over the members of an enum does not provide the aliases::"

msgstr ""

"Beim Iterieren über die Mitglieder eines Enums kommen die Aliase nicht vor::"

#: ../../howto/enum.rst:314

msgid ""

">>> list(Shape)\n"

"[<Shape.SQUARE: 2>, <Shape.DIAMOND: 1>, <Shape.CIRCLE: 3>]\n"

">>> list(Weekday)\n"

"[<Weekday.MONDAY: 1>, <Weekday.TUESDAY: 2>, <Weekday.WEDNESDAY: 4>, <Weekday."

"THURSDAY: 8>, <Weekday.FRIDAY: 16>, <Weekday.SATURDAY: 32>, <Weekday.SUNDAY: "

"64>]"

msgstr ""

">>> list(Shape)\n"

"[<Shape.SQUARE: 2>, <Shape.DIAMOND: 1>, <Shape.CIRCLE: 3>]\n"

">>> list(Weekday)\n"

"[<Weekday.MONDAY: 1>, <Weekday.TUESDAY: 2>, <Weekday.WEDNESDAY: 4>, <Weekday."

"THURSDAY: 8>, <Weekday.FRIDAY: 16>, <Weekday.SATURDAY: 32>, <Weekday.SUNDAY: "

"64>]"

#: ../../howto/enum.rst:319

msgid ""

"Note that the aliases ``Shape.ALIAS_FOR_SQUARE`` and ``Weekday.WEEKEND`` "

"aren't shown."

msgstr ""

"Beachte, dass die Aliase ``Shape.ALIAS_FOR_SQUARE`` und ``Weekday.WEEKEND`` "

"nicht gezeigt werden."

#: ../../howto/enum.rst:321

msgid ""

"The special attribute ``__members__`` is a read-only ordered mapping of "

"names to members. It includes all names defined in the enumeration, "

"including the aliases::"

msgstr ""

"Das besondere Attribut ``__members__`` ist eine nur lesbare, geordnete "

"Abbildung von Namen auf Mitglieder. Es umfasst alle in der Aufzählung "

"definierten Namen, auch die Aliase::"

#: ../../howto/enum.rst:325

msgid ""

">>> for name, member in Shape.__members__.items():\n"

"... name, member\n"

"...\n"

"('SQUARE', <Shape.SQUARE: 2>)\n"

"('DIAMOND', <Shape.DIAMOND: 1>)\n"

"('CIRCLE', <Shape.CIRCLE: 3>)\n"

"('ALIAS_FOR_SQUARE', <Shape.SQUARE: 2>)"

msgstr ""

">>> for name, member in Shape.__members__.items():\n"

"... name, member\n"

"...\n"

"('SQUARE', <Shape.SQUARE: 2>)\n"

"('DIAMOND', <Shape.DIAMOND: 1>)\n"

"('CIRCLE', <Shape.CIRCLE: 3>)\n"

"('ALIAS_FOR_SQUARE', <Shape.SQUARE: 2>)"

#: ../../howto/enum.rst:333

msgid ""

"The ``__members__`` attribute can be used for detailed programmatic access "

"to the enumeration members. For example, finding all the aliases::"

msgstr ""

"Das Attribut ``__members__`` lässt sich für einen ausführlichen "

"programmgesteuerten Zugriff auf die Aufzählungsmitglieder verwenden – zum "

"Beispiel, um alle Aliase zu finden::"

#: ../../howto/enum.rst:336

msgid ""

">>> [name for name, member in Shape.__members__.items() if member.name != "

"name]\n"

"['ALIAS_FOR_SQUARE']"

msgstr ""

">>> [name for name, member in Shape.__members__.items() if member.name != "

"name]\n"

"['ALIAS_FOR_SQUARE']"

#: ../../howto/enum.rst:341

msgid ""

"Aliases for flags include values with multiple flags set, such as ``3``, and "

"no flags set, i.e. ``0``."

msgstr ""

"Zu den Aliasen bei Flags gehören Werte mit mehreren gesetzten Flags, etwa "

"``3``, und mit keinem gesetzten Flag, also ``0``."

#: ../../howto/enum.rst:346

msgid "Comparisons"

msgstr "Vergleiche"

#: ../../howto/enum.rst:348

msgid "Enumeration members are compared by identity::"

msgstr "Aufzählungsmitglieder werden über die Identität verglichen::"

#: ../../howto/enum.rst:350

msgid ""

">>> Color.RED is Color.RED\n"

"True\n"

">>> Color.RED is Color.BLUE\n"

"False\n"

">>> Color.RED is not Color.BLUE\n"

"True"

msgstr ""

">>> Color.RED is Color.RED\n"

"True\n"

">>> Color.RED is Color.BLUE\n"

"False\n"

">>> Color.RED is not Color.BLUE\n"

"True"

#: ../../howto/enum.rst:357

msgid ""

"Ordered comparisons between enumeration values are *not* supported. Enum "

"members are not integers (but see `IntEnum`_ below)::"

msgstr ""

"Ordnende Vergleiche zwischen Aufzählungswerten werden *nicht* unterstützt. "

"Enum-Mitglieder sind keine Ganzzahlen (siehe aber `IntEnum`_ unten)::"

#: ../../howto/enum.rst:360

msgid ""

">>> Color.RED < Color.BLUE\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: '<' not supported between instances of 'Color' and 'Color'"

msgstr ""

">>> Color.RED < Color.BLUE\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: '<' not supported between instances of 'Color' and 'Color'"

#: ../../howto/enum.rst:365

msgid "Equality comparisons are defined though::"

msgstr "Gleichheitsvergleiche sind allerdings definiert::"

#: ../../howto/enum.rst:367

msgid ""

">>> Color.BLUE == Color.RED\n"

"False\n"

">>> Color.BLUE != Color.RED\n"

"True\n"

">>> Color.BLUE == Color.BLUE\n"

"True"

msgstr ""

">>> Color.BLUE == Color.RED\n"

"False\n"

">>> Color.BLUE != Color.RED\n"

"True\n"

">>> Color.BLUE == Color.BLUE\n"

"True"

#: ../../howto/enum.rst:374

msgid ""

"Equality comparisons against non-enumeration values will always return "

"``False`` (again, :class:`IntEnum` was explicitly designed to behave "

"differently, see below)::"

msgstr ""

"Gleichheitsvergleiche mit Werten, die keine Aufzählungen sind, geben immer "

"``False`` zurück (auch hier gilt: :class:`IntEnum` wurde ausdrücklich dafür "

"entworfen, sich anders zu verhalten, siehe unten)::"

#: ../../howto/enum.rst:378

msgid ""

">>> Color.BLUE == 2\n"

"False"

msgstr ""

">>> Color.BLUE == 2\n"

"False"

#: ../../howto/enum.rst:383

msgid ""

"It is possible to reload modules -- if a reloaded module contains enums, "

"they will be recreated, and the new members may not compare identical/equal "

"to the original members."

msgstr ""

"Es ist möglich, Module neu zu laden – enthält ein neu geladenes Modul Enums, "

"werden sie neu erzeugt, und die neuen Mitglieder sind möglicherweise nicht "

"identisch beziehungsweise gleich zu den ursprünglichen Mitgliedern."

#: ../../howto/enum.rst:388

msgid "Allowed members and attributes of enumerations"

msgstr "Erlaubte Mitglieder und Attribute von Aufzählungen"

#: ../../howto/enum.rst:390

msgid ""

"Most of the examples above use integers for enumeration values. Using "

"integers is short and handy (and provided by default by the `Functional "

"API`_), but not strictly enforced. In the vast majority of use-cases, one "

"doesn't care what the actual value of an enumeration is. But if the value "

"*is* important, enumerations can have arbitrary values."

msgstr ""

"Die meisten Beispiele oben verwenden Ganzzahlen als Aufzählungswerte. "

"Ganzzahlen zu verwenden ist kurz und praktisch (und wird von der `Functional "

"API`_ standardmäßig geliefert), ist aber nicht streng vorgeschrieben. In der "

"weit überwiegenden Zahl der Anwendungsfälle ist es einem gleichgültig, "

"welchen Wert eine Aufzählung tatsächlich hat. Ist der Wert aber *wichtig*, "

"können Aufzählungen beliebige Werte haben."

#: ../../howto/enum.rst:396

msgid ""

"Enumerations are Python classes, and can have methods and special methods as "

"usual. If we have this enumeration::"

msgstr ""

"Aufzählungen sind Python-Klassen und können wie üblich Methoden und "

"besondere Methoden haben. Wenn wir diese Aufzählung haben::"

#: ../../howto/enum.rst:399

msgid ""

">>> class Mood(Enum):\n"

"... FUNKY = 1\n"

"... HAPPY = 3\n"

"...\n"

"... def describe(self):\n"

"... # self is the member here\n"

"... return self.name, self.value\n"

"...\n"

"... def __str__(self):\n"

"... return 'my custom str! {0}'.format(self.value)\n"

"...\n"

"... @classmethod\n"

"... def favorite_mood(cls):\n"

"... # cls here is the enumeration\n"

"... return cls.HAPPY\n"

"..."

msgstr ""

">>> class Mood(Enum):\n"

"... FUNKY = 1\n"

"... HAPPY = 3\n"

"...\n"

"... def describe(self):\n"

"... # self is the member here\n"

"... return self.name, self.value\n"

"...\n"

"... def __str__(self):\n"

"... return 'my custom str! {0}'.format(self.value)\n"

"...\n"

"... @classmethod\n"

"... def favorite_mood(cls):\n"

"... # cls here is the enumeration\n"

"... return cls.HAPPY\n"

"..."

#: ../../howto/enum.rst:416

msgid "Then::"

msgstr "Dann::"

#: ../../howto/enum.rst:418

msgid ""

">>> Mood.favorite_mood()\n"

"<Mood.HAPPY: 3>\n"

">>> Mood.HAPPY.describe()\n"

"('HAPPY', 3)\n"

">>> str(Mood.FUNKY)\n"

"'my custom str! 1'"

msgstr ""

">>> Mood.favorite_mood()\n"

"<Mood.HAPPY: 3>\n"

">>> Mood.HAPPY.describe()\n"

"('HAPPY', 3)\n"

">>> str(Mood.FUNKY)\n"

"'my custom str! 1'"

#: ../../howto/enum.rst:425

msgid ""

"The rules for what is allowed are as follows: names that start and end with "

"a single underscore are reserved by enum and cannot be used; all other "

"attributes defined within an enumeration will become members of this "

"enumeration, with the exception of special methods (:meth:`~object."

"__str__`, :meth:`~object.__add__`, etc.), descriptors (methods are also "

"descriptors), and variable names listed in :attr:`~Enum._ignore_`."

msgstr ""

"Die Regeln für das Erlaubte lauten: Namen, die mit einem einzelnen "

"Unterstrich beginnen und enden, sind für enum reserviert und dürfen nicht "

"verwendet werden. Alle anderen innerhalb einer Aufzählung definierten "

"Attribute werden zu Mitgliedern dieser Aufzählung – mit Ausnahme besonderer "

"Methoden (:meth:`~object.__str__`, :meth:`~object.__add__` usw.), von "

"Deskriptoren (Methoden sind auch Deskriptoren) und von Variablennamen, die "

"in :attr:`~Enum._ignore_` aufgeführt sind."

#: ../../howto/enum.rst:432

msgid ""

"Note: if your enumeration defines :meth:`~object.__new__` and/or :meth:"

"`~object.__init__`, any value(s) given to the enum member will be passed "

"into those methods. See `Planet`_ for an example."

msgstr ""

"Beachte: Definiert deine Aufzählung :meth:`~object.__new__` und/oder :meth:"

"`~object.__init__`, werden alle Werte, die dem Enum-Mitglied gegeben werden, "

"an diese Methoden übergeben. Ein Beispiel dazu ist `Planet`_."

#: ../../howto/enum.rst:438

msgid ""

"The :meth:`~object.__new__` method, if defined, is used during creation of "

"the Enum members; it is then replaced by Enum's :meth:`~object.__new__` "

"which is used after class creation for lookup of existing members. See :ref:"

"`new-vs-init` for more details."

msgstr ""

"Die Methode :meth:`~object.__new__` wird, falls definiert, beim Erzeugen der "

"Enum-Mitglieder verwendet. Sie wird dann durch das :meth:`~object.__new__` "

"von Enum ersetzt, das nach der Klassenerzeugung zum Nachschlagen bestehender "