# 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:
# python-doc bot, 2025
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-05 16:53+0200\n"
"PO-Revision-Date: 2026-08-10 00:02+0000\n"
"Last-Translator: Swen Bachmann <142266608+sba72@users.noreply.github.com>\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/classes.rst:5
msgid "Classes"
msgstr "Klassen"

#: ../../tutorial/classes.rst:7
msgid ""
"Classes provide a means of bundling data and functionality together.  "
"Creating a new class creates a new *type* of object, allowing new "
"*instances* of that type to be made.  Each class instance can have "
"attributes attached to it for maintaining its state.  Class instances can "
"also have methods (defined by its class) for modifying its state."
msgstr ""
"Klassen bieten die Möglichkeit, Daten und Funktionalitäten zusammenzufassen. "
"Das Erstellen einer neuen Klasse erzeugt einen neuen *Typ* von Objekt, was "
"es ermöglicht, neue *Instanzen* dieses Typs zu erstellen. Jede "
"Klasseninstanz kann über Attribute verfügen, um ihren Zustand zu verwalten. "
"Klasseninstanzen können auch über Methoden (definiert durch ihre Klasse) "
"verfügen, um ihren Zustand zu ändern."

#: ../../tutorial/classes.rst:13
msgid ""
"Compared with other programming languages, Python's class mechanism adds "
"classes with a minimum of new syntax and semantics.  It is a mixture of the "
"class mechanisms found in C++ and Modula-3.  Python classes provide all the "
"standard features of Object Oriented Programming: the class inheritance "
"mechanism allows multiple base classes, a derived class can override any "
"methods of its base class or classes, and a method can call the method of a "
"base class with the same name.  Objects can contain arbitrary amounts and "
"kinds of data.  As is true for modules, classes partake of the dynamic "
"nature of Python: they are created at runtime, and can be modified further "
"after creation."
msgstr ""
"Im Vergleich zu anderen Programmiersprachen fügt der Klassenmechanismus von "
"Python Klassen mit einem Minimum an neuer Syntax und Semantik hinzu. Er ist "
"eine Mischung aus den Klassenmechanismen von C++ und Modula-3. Python-"
"Klassen bieten alle Standardfunktionen der objektorientierten "
"Programmierung: Der Vererbungungsmechanismus erlaubt mehrere Basisklassen, "
"eine abgeleitete Klasse kann jede Methode ihrer Basisklasse(n) "
"überschreiben, und eine Methode kann die gleichnamige Methode einer "
"Basisklasse aufrufen. Objekte können beliebige Mengen und Arten von Daten "
"enthalten. Wie auch Module zeichnen sich Klassen durch die dynamische Natur "
"von Python aus: Sie werden zur Laufzeit erzeugt und können nach ihrer "
"Erstellung weiter verändert werden."

#: ../../tutorial/classes.rst:23
msgid ""
"In C++ terminology, normally class members (including the data members) are "
"*public* (except see below :ref:`tut-private`), and all member functions are "
"*virtual*.  As in Modula-3, there are no shorthands for referencing the "
"object's members from its methods: the method function is declared with an "
"explicit first argument representing the object, which is provided "
"implicitly by the call.  As in Smalltalk, classes themselves are objects.  "
"This provides semantics for importing and renaming.  Unlike C++ and "
"Modula-3, built-in types can be used as base classes for extension by the "
"user.  Also, like in C++, most built-in operators with special syntax "
"(arithmetic operators, subscripting etc.) can be redefined for class "
"instances."
msgstr ""
"In der C++-Terminologie sind Klassenmitglieder (einschließlich der "
"Datenelemente) normalerweise *public* (Ausnahmen siehe unten :ref:`tut-"
"private`), und alle Elementfunktionen sind *virtual*. Wie in Modula-3 gibt "
"es keine Kurzschreibweisen für den Zugriff auf die Elemente eines Objekts "
"aus dessen Methoden: Die Methodenfunktion wird mit einem expliziten ersten "
"Argument deklariert, das das Objekt darstellt und beim Aufruf implizit "
"übergeben wird. Wie in Smalltalk sind Klassen selbst Objekte. Dies bietet "
"eine Semantik zum Importieren und Umbenennen. Anders als in C++ und Modula-3 "
"können integrierte Typen als Basisklassen für Erweiterungen durch den "
"Benutzer verwendet werden. Zudem können, wie in C++, die meisten "
"integrierten Operatoren mit spezieller Syntax (arithmetische Operatoren, "
"Indizierung usw.) für Klasseninstanzen neu definiert werden."

#: ../../tutorial/classes.rst:34
msgid ""
"(Lacking universally accepted terminology to talk about classes, I will make "
"occasional use of Smalltalk and C++ terms.  I would use Modula-3 terms, "
"since its object-oriented semantics are closer to those of Python than C++, "
"but I expect that few readers have heard of it.)"
msgstr ""
"(Da eine allgemein akzeptierte Terminologie für Klassen fehlt, werde ich "
"gelegentlich Begriffe aus Smalltalk und C++ verwenden. Ich würde Begriffe "
"aus Modula-3 verwenden, da dessen objektorientierte Semantik der von Python "
"näher kommt als die von C++, aber ich nehme an, dass nur wenige Leser davon "
"gehört haben.)"

#: ../../tutorial/classes.rst:43
msgid "A Word About Names and Objects"
msgstr "Ein Wort zu Namen und Objekten"

#: ../../tutorial/classes.rst:45
msgid ""
"Objects have individuality, and multiple names (in multiple scopes) can be "
"bound to the same object.  This is known as aliasing in other languages.  "
"This is usually not appreciated on a first glance at Python, and can be "
"safely ignored when dealing with immutable basic types (numbers, strings, "
"tuples).  However, aliasing has a possibly surprising effect on the "
"semantics of Python code involving mutable objects such as lists, "
"dictionaries, and most other types. This is usually used to the benefit of "
"the program, since aliases behave like pointers in some respects.  For "
"example, passing an object is cheap since only a pointer is passed by the "
"implementation; and if a function modifies an object passed as an argument, "
"the caller will see the change --- this eliminates the need for two "
"different argument passing mechanisms as in Pascal."
msgstr ""
"Objekte besitzen eine eigene Identität, und mehrere Namen (in verschiedenen "
"Gültigkeitsbereichen) können an dasselbe Objekt gebunden sein. Dies ist in "
"anderen Sprachen als Aliasing bekannt. Auf den ersten Blick wird dies bei "
"Python meist nicht wahrgenommen und kann beim Umgang mit unveränderlichen "
"Datentypen (Zahlen, Zeichenketten, Tupel) getrost ignoriert werden. Aliasing "
"hat jedoch eine unter Umständen überraschende Wirkung auf die Semantik von "
"Python-Code, der veränderliche Objekte wie Listen, Dictionaries und die "
"meisten anderen Typen enthält. Dies wird gewöhnlich zum Vorteil des "
"Programms genutzt, da sich Aliase in mancher Hinsicht wie Zeiger verhalten. "
"Beispielsweise ist die Übergabe eines Objekts günstig, da von der "
"Implementierung nur ein Zeiger übergeben wird; und wenn eine Funktion ein "
"als Argument übergebenes Objekt verändert, sieht der Aufrufer diese Änderung "
"--- was zwei verschiedene Mechanismen zur Argumentübergabe wie in Pascal "
"überflüssig macht."

#: ../../tutorial/classes.rst:61
msgid "Python Scopes and Namespaces"
msgstr "Python-Gültigkeitsbereiche und Namensräume"

#: ../../tutorial/classes.rst:63
msgid ""
"Before introducing classes, I first have to tell you something about "
"Python's scope rules.  Class definitions play some neat tricks with "
"namespaces, and you need to know how scopes and namespaces work to fully "
"understand what's going on. Incidentally, knowledge about this subject is "
"useful for any advanced Python programmer."
msgstr ""
"Bevor wir Klassen einführen, muss ich dir zuerst etwas über Pythons "
"Gültigkeitsbereiche (Scopes) erzählen. Klassendefinitionen wenden einige "
"Raffinessen bei Namensräumen an, und du musst wissen, wie "
"Gültigkeitsbereiche und Namensräume funktionieren, um vollständig zu "
"verstehen, was passiert. Nebenbei bemerkt ist das Wissen über dieses Thema "
"für jeden fortgeschrittenen Python-Programmierer nützlich."

#: ../../tutorial/classes.rst:69
msgid "Let's begin with some definitions."
msgstr "Beginnen wir mit einigen Definitionen."

#: ../../tutorial/classes.rst:71
msgid ""
"A *namespace* is a mapping from names to objects.  Most namespaces are "
"currently implemented as Python dictionaries, but that's normally not "
"noticeable in any way (except for performance), and it may change in the "
"future.  Examples of namespaces are: the set of built-in names (containing "
"functions such as :func:`abs`, and built-in exception names); the global "
"names in a module; and the local names in a function invocation.  In a sense "
"the set of attributes of an object also form a namespace.  The important "
"thing to know about namespaces is that there is absolutely no relation "
"between names in different namespaces; for instance, two different modules "
"may both define a function ``maximize`` without confusion --- users of the "
"modules must prefix it with the module name."
msgstr ""
"Ein *Namensraum* ist eine Zuordnung von Namen zu Objekten. Die meisten "
"Namensräume sind derzeit als Python-Dictionaries implementiert, was aber "
"normalerweise in keiner Weise auffällt (außer bei der Performance) und sich "
"in Zukunft ändern kann. Beispiele für Namensräume sind: die Menge der "
"integrierten Namen (die Funktionen wie :func:`abs` und integrierte Ausnahmen "
"enthält), die globalen Namen in einem Modul und die lokalen Namen bei einem "
"Funktionsaufruf. In gewissem Sinne bildet auch die Menge der Attribute eines "
"Objekts einen Namensraum. Das Wichtigste über Namensräume ist, dass es "
"absolut keine Beziehung zwischen Namen in verschiedenen Namensräumen gibt, "
"so können beispielsweise zwei verschiedene Module eine Funktion ``maximize`` "
"ohne Verwirrung definieren --- Benutzer der Module müssen ihr den Modulnamen "
"voranstellen."

#: ../../tutorial/classes.rst:82
msgid ""
"By the way, I use the word *attribute* for any name following a dot --- for "
"example, in the expression ``z.real``, ``real`` is an attribute of the "
"object ``z``.  Strictly speaking, references to names in modules are "
"attribute references: in the expression ``modname.funcname``, ``modname`` is "
"a module object and ``funcname`` is an attribute of it.  In this case there "
"happens to be a straightforward mapping between the module's attributes and "
"the global names defined in the module: they share the same namespace!  [#]_"
msgstr ""
"Übrigens verwende ich das Wort *Attribut* für jeden Namen, der einem Punkt "
"folgt --- im Ausdruck ``z.real`` ist beispielsweise ``real`` ein Attribut "
"des Objekts ``z``. Strenge genommen sind Referenzen auf Namen in Modulen "
"Attributreferenzen: Im Ausdruck ``modname.funcname`` ist ``modname`` ein "
"Modulobjekt und ``funcname`` ein Attribut davon. In diesem Fall gibt es "
"zufällig eine direkte Zuordnung zwischen den Attributen des Moduls und den "
"im Modul definierten globalen Namen: Sie teilen sich denselben Namensraum! "
"[#]_"

#: ../../tutorial/classes.rst:90
msgid ""
"Attributes may be read-only or writable.  In the latter case, assignment to "
"attributes is possible.  Module attributes are writable: you can write "
"``modname.the_answer = 42``.  Writable attributes may also be deleted with "
"the :keyword:`del` statement.  For example, ``del modname.the_answer`` will "
"remove the attribute :attr:`!the_answer` from the object named by "
"``modname``."
msgstr ""
"Attribute können schreibgeschützt oder beschreibbar sein. Im letzteren Fall "
"ist eine Zuweisung an Attribute möglich. Modulattribute sind beschreibbar: "
"du kannst ``modname.the_answer = 42`` schreiben. Beschreibbare Attribute "
"\"können auch mit der Anweisung :keyword:`del` gelöscht werden. Zum Beispiel "
"entfernt ``del modname.the_answer`` das Attribut :attr:`!the_answer` aus dem "
"Objekt namens ``modname``."

#: ../../tutorial/classes.rst:96
msgid ""
"Namespaces are created at different moments and have different lifetimes.  "
"The namespace containing the built-in names is created when the Python "
"interpreter starts up, and is never deleted.  The global namespace for a "
"module is created when the module definition is read in; normally, module "
"namespaces also last until the interpreter quits.  The statements executed "
"by the top-level invocation of the interpreter, either read from a script "
"file or interactively, are considered part of a module called :mod:"
"`__main__`, so they have their own global namespace.  (The built-in names "
"actually also live in a module; this is called :mod:`builtins`.)"
msgstr ""
"Namensräume werden zu unterschiedlichen Zeitpunkten erstellt und haben "
"unterschiedliche Lebensdauern. Der Namensraum, der die integrierten Namen "
"enthält, wird beim Start des Python-Interpreters erstellt und niemals "
"gelöscht. Der globale Namensraum für ein Modul wird beim Einlesen der "
"Moduldefinition erstellt, normalerweise bleiben Modulnamensräume ebenfalls "
"bestehen, bis der Interpreter beendet wird. Die Anweisungen, die auf "
"oberster Ebene des Interpreters ausgeführt werden, sei es aus einer "
"Skriptdatei oder interaktiv, gelten als Teil eines Moduls namens :mod:"
"`__main__` und haben daher ihren eigenen globalen Namensraum. (Die "
"integrierten Namen befinden sich eigentlich ebenfalls in einem Modul; dieses "
"heißt :mod:`builtins`.)"

#: ../../tutorial/classes.rst:106
msgid ""
"The local namespace for a function is created when the function is called, "
"and deleted when the function returns or raises an exception that is not "
"handled within the function.  (Actually, forgetting would be a better way to "
"describe what actually happens.)  Of course, recursive invocations each have "
"their own local namespace."
msgstr ""
"Der lokale Namensraum für eine Funktion wird beim Aufruf der Funktion "
"erstellt und gelöscht, wenn die Funktion zurückkehrt oder eine Ausnahme "
"auslöst, die nicht innerhalb der Funktion behandelt wird.  (Eigentlich wäre "
"Vergessen eine bessere Beschreibung für das, was tatsächlich passiert.)  "
"Selbstverständlich haben rekursive Aufrufe jeweils ihren eigenen lokalen "
"Namensraum."

#: ../../tutorial/classes.rst:112
msgid ""
"A *scope* is a textual region of a Python program where a namespace is "
"directly accessible.  \"Directly accessible\" here means that an unqualified "
"reference to a name attempts to find the name in the namespace."
msgstr ""
"Ein *Gültigkeitsbereich* (Scope) ist ein Quelltextbereich eines Python-"
"Programms, in dem ein Namensraum direkt zugänglich ist. \"Direkt "
"zugänglich\" bedeutet hier, dass eine unqualifizierte Referenz auf einen "
"Namen versucht, den Namen in diesem Namensraum zu finden."

#: ../../tutorial/classes.rst:116
msgid ""
"Although scopes are determined statically, they are used dynamically. At any "
"time during execution, there are 3 or 4 nested scopes whose namespaces are "
"directly accessible:"
msgstr ""
"Obwohl Gültigkeitsbereiche statisch bestimmt werden, werden sie dynamisch "
"verwendet. Zu jedem Zeitpunkt der Ausführung gibt es 3 oder 4 verschachtelte "
"Gültigkeitsbereiche, deren Namensräume direkt zugänglich sind:"

#: ../../tutorial/classes.rst:120
msgid "the innermost scope, which is searched first, contains the local names"
msgstr ""
"der innerste Gültigkeitsbereich, der zuerst durchsucht wird, enthält die "
"lokalen Namen"

#: ../../tutorial/classes.rst:121
msgid ""
"the scopes of any enclosing functions, which are searched starting with the "
"nearest enclosing scope, contain non-local, but also non-global names"
msgstr ""
"die Gültigkeitsbereiche etwaiger umgebender Funktionen, die ausgehend vom "
"nächstgelegenen umgebenden Bereich durchsucht werden, enthalten nicht-"
"lokale, aber auch nicht-globale Namen"

#: ../../tutorial/classes.rst:123
msgid "the next-to-last scope contains the current module's global names"
msgstr ""
"der vorletzte Gültigkeitsbereich enthält die globalen Namen des aktuellen "
"Moduls"

#: ../../tutorial/classes.rst:124
msgid ""
"the outermost scope (searched last) is the namespace containing built-in "
"names"
msgstr ""
"der äußerste Gültigkeitsbereich (der zuletzt durchsucht wird) ist der "
"Namensraum, der die integrierten Namen enthält"

#: ../../tutorial/classes.rst:126
msgid ""
"If a name is declared global, then all references and assignments go "
"directly to the next-to-last scope containing the module's global names.  To "
"rebind variables found outside of the innermost scope, the :keyword:"
"`nonlocal` statement can be used; if not declared nonlocal, those variables "
"are read-only (an attempt to write to such a variable will simply create a "
"*new* local variable in the innermost scope, leaving the identically named "
"outer variable unchanged)."
msgstr ""
"Wird ein Name als global deklariert, gehen alle Referenzen und Zuweisungen "
"direkt an den vorletzten Gültigkeitsbereich, der die globalen Namen des "
"Moduls enthält. Um Variablen neuzuweisen, die sich außerhalb des innersten "
"Gültigkeitsbereichs befinden, kann die Anweisung :keyword:`nonlocal` "
"verwendet werden, sind sie nicht als nonlocal deklariert, sind diese "
"Variablen schreibgeschützt (ein Versuch, in eine solche Variable zu "
"schreiben, erzeugt lediglich eine *neue* lokale Variable im innersten "
"Gültigkeitsbereich und lässt die gleichnamige äußere Variable unverändert)."

#: ../../tutorial/classes.rst:133
msgid ""
"Usually, the local scope references the local names of the (textually) "
"current function.  Outside functions, the local scope references the same "
"namespace as the global scope: the module's namespace. Class definitions "
"place yet another namespace in the local scope."
msgstr ""
"Normally verweist der lokale Gültigkeitsbereich auf die lokalen Namen der "
"(im Quelltext) aktuellen Funktion. Außerhalb von Funktionen verweist der "
"lokale Gültigkeitsbereich auf denselben Namensraum wie der globale "
"Gültigkeitsbereich: den Namensraum des Moduls. Klassendefinitionen "
"platzieren einen weiteren Namensraum im lokalen Gültigkeitsbereich."

#: ../../tutorial/classes.rst:138
msgid ""
"It is important to realize that scopes are determined textually: the global "
"scope of a function defined in a module is that module's namespace, no "
"matter from where or by what alias the function is called.  On the other "
"hand, the actual search for names is done dynamically, at run time --- "
"however, the language definition is evolving towards static name resolution, "
"at \"compile\" time, so don't rely on dynamic name resolution!  (In fact, "
"local variables are already determined statically.)"
msgstr ""
"Es ist wichtig zu verstehen, dass Gültigkeitsbereiche quelltextbezogen "
"bestimmt werden: Der globale Gültigkeitsbereich einer in einem Modul "
"definierten Funktion ist der Namensraum dieses Moduls, ganz gleich, von wo "
"oder unter welchem Alias die Funktion aufgerufen wird. Andererseits erfolgt "
"die tatsächliche Suche nach Namen dynamisch zur Laufzeit --- die "
"Sprachdefinition entwickelt sich jedoch in Richtung einer statischen "
"Namensauflösung zur \"Kompilierzeit\", verlasse dich also nicht auf die "
"dynamische Namensauflösung! (Tatsächlich werden lokale Variablen bereits "
"statisch bestimmt.)"

#: ../../tutorial/classes.rst:146
msgid ""
"A special quirk of Python is that -- if no :keyword:`global` or :keyword:"
"`nonlocal` statement is in effect -- assignments to names always go into the "
"innermost scope. Assignments do not copy data --- they just bind names to "
"objects.  The same is true for deletions: the statement ``del x`` removes "
"the binding of ``x`` from the namespace referenced by the local scope.  In "
"fact, all operations that introduce new names use the local scope: in "
"particular, :keyword:`import` statements and function definitions bind the "
"module or function name in the local scope."
msgstr ""
"Eine Besonderheit von Python ist, dass Zuweisungen an Namen – wenn keine :"
"keyword:`global`- oder :keyword:`nonlocal`-Anweisung gilt – immer in den "
"innersten Gültigkeitsbereich eingehen. Zuweisungen kopieren keine Daten --- "
"sie binden lediglich Namen an Objekte. Das Gleiche gilt für Löschungen: Die "
"Anweisung ``del x`` entfernt die Bindung von ``x`` aus dem Namensraum, auf "
"den der lokale Gültigkeitsbereich verweist. Tatsächlich nutzen alle "
"Operationen, die neue Namen einführen, den lokalen Gültigkeitsbereich: "
"Insbesondere binden :keyword:`import`-Anweisungen und Funktionsdefinitionen "
"den Modul- oder Funktionsnamen im lokalen Gültigkeitsbereich."

#: ../../tutorial/classes.rst:154
msgid ""
"The :keyword:`global` statement can be used to indicate that particular "
"variables live in the global scope and should be rebound there; the :keyword:"
"`nonlocal` statement indicates that particular variables live in an "
"enclosing scope and should be rebound there."
msgstr ""
"Die Anweisung :keyword:`global` kann verwendet werden, um anzugeben, dass "
"bestimmte Variablen im globalen Gültigkeitsbereich liegen und dort neu "
"gebunden werden sollen, die Anweisung :keyword:`nonlocal` gibt an, dass "
"bestimmte Variablen in einem umgebenden Gültigkeitsbereich liegen und dort "
"neu gebunden werden sollen."

#: ../../tutorial/classes.rst:162
msgid "Scopes and Namespaces Example"
msgstr "Beispiel für Gültigkeitsbereiche und Namensräume"

#: ../../tutorial/classes.rst:164
msgid ""
"This is an example demonstrating how to reference the different scopes and "
"namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect "
"variable binding::"
msgstr ""
"Dies ist ein Beispiel, das zeigt, wie auf die verschiedenen "
"Gültigkeitsbereiche und Namensräume zugegriffen wird und wie :keyword:"
"`global` und :keyword:`nonlocal` die Variablenbindung beeinflussen::"

#: ../../tutorial/classes.rst:168
msgid ""
"def scope_test():\n"
"    def do_local():\n"
"        spam = \"local spam\"\n"
"\n"
"    def do_nonlocal():\n"
"        nonlocal spam\n"
"        spam = \"nonlocal spam\"\n"
"\n"
"    def do_global():\n"
"        global spam\n"
"        spam = \"global spam\"\n"
"\n"
"    spam = \"test spam\"\n"
"    do_local()\n"
"    print(\"After local assignment:\", spam)\n"
"    do_nonlocal()\n"
"    print(\"After nonlocal assignment:\", spam)\n"
"    do_global()\n"
"    print(\"After global assignment:\", spam)\n"
"\n"
"scope_test()\n"
"print(\"In global scope:\", spam)"
msgstr ""
"def scope_test():\n"
"    def do_local():\n"
"        spam = \"local spam\"\n"
"\n"
"    def do_nonlocal():\n"
"        nonlocal spam\n"
"        spam = \"nonlocal spam\"\n"
"\n"
"    def do_global():\n"
"        global spam\n"
"        spam = \"global spam\"\n"
"\n"
"    spam = \"test spam\"\n"
"    do_local()\n"
"    print(\"After local assignment:\", spam)\n"
"    do_nonlocal()\n"
"    print(\"After nonlocal assignment:\", spam)\n"
"    do_global()\n"
"    print(\"After global assignment:\", spam)\n"
"\n"
"scope_test()\n"
"print(\"In global scope:\", spam)"

#: ../../tutorial/classes.rst:191
msgid "The output of the example code is:"
msgstr "Die Ausgabe des Beispielcodes lautet:"

#: ../../tutorial/classes.rst:193
msgid ""
"After local assignment: test spam\n"
"After nonlocal assignment: nonlocal spam\n"
"After global assignment: nonlocal spam\n"
"In global scope: global spam"
msgstr ""
"After local assignment: test spam\n"
"After nonlocal assignment: nonlocal spam\n"
"After global assignment: nonlocal spam\n"
"In global scope: global spam"

#: ../../tutorial/classes.rst:200
msgid ""
"Note how the *local* assignment (which is default) didn't change "
"*scope_test*\\'s binding of *spam*.  The :keyword:`nonlocal` assignment "
"changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` "
"assignment changed the module-level binding."
msgstr ""
"Beachte, wie die *lokale* Zuweisung (die der Standard ist) die Bindung von "
"*spam* in *scope_test* nicht verändert hat. Die :keyword:`nonlocal`-"
"Zuweisung hat die Bindung von *spam* in *scope_test* geändert und die :"
"keyword:`global`-Zuweisung hat die Bindung auf Modulebene geändert."

#: ../../tutorial/classes.rst:205
msgid ""
"You can also see that there was no previous binding for *spam* before the :"
"keyword:`global` assignment."
msgstr ""
"Du kannst auch sehen, dass vor der :keyword:`global`-Zuweisung keine "
"vorherige Bindung für *spam* existierte."

#: ../../tutorial/classes.rst:212
msgid "A First Look at Classes"
msgstr "Ein erster Blick auf Klassen"

#: ../../tutorial/classes.rst:214
msgid ""
"Classes introduce a little bit of new syntax, three new object types, and "
"some new semantics."
msgstr ""
"Klassen führen ein wenig neue Syntax, drei neue Objekttypen und einige neue "
"Semantiken ein."

#: ../../tutorial/classes.rst:221
msgid "Class Definition Syntax"
msgstr "Syntax von Klassendefinitionen"

#: ../../tutorial/classes.rst:223
msgid "The simplest form of class definition looks like this::"
msgstr "Die einfachste Form einer Klassendefinition sieht so aus::"

#: ../../tutorial/classes.rst:225
msgid ""
"class ClassName:\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"
msgstr ""
"class ClassName:\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"

#: ../../tutorial/classes.rst:232
msgid ""
"Class definitions, like function definitions (:keyword:`def` statements) "
"must be executed before they have any effect.  (You could conceivably place "
"a class definition in a branch of an :keyword:`if` statement, or inside a "
"function.)"
msgstr ""
"Klassendefinitionen müssen, genau wie Funktionsdefinitionen (:keyword:`def`-"
"Anweisungen), ausgeführt werden, bevor sie eine Wirkung haben. (Man könnte "
"eine Klassendefinition denkbarer Weise in einem Zweig einer :keyword:`if`-"
"Anweisung oder innerhalb einer Funktion platzieren.)"

#: ../../tutorial/classes.rst:236
msgid ""
"In practice, the statements inside a class definition will usually be "
"function definitions, but other statements are allowed, and sometimes useful "
"--- we'll come back to this later.  The function definitions inside a class "
"normally have a peculiar form of argument list, dictated by the calling "
"conventions for methods --- again, this is explained later."
msgstr ""
"In der Praxis sind die Anweisungen innerhalb einer Klassendefinition "
"üblicherweise  Funktionsdefinitionen, aber andere Anweisungen sind zulässig "
"und manchmal nützlich --- darauf kommen wir später zurück. Die "
"Funktionsdefinitionen innerhalb einer Klasse haben normalerweise eine "
"besondere Form von Argumentliste, die durch die Aufrufkonventionen für "
"Methoden vorgegeben ist --- auch dies wird später erklärt."

#: ../../tutorial/classes.rst:242
msgid ""
"When a class definition is entered, a new namespace is created, and used as "
"the local scope --- thus, all assignments to local variables go into this "
"new namespace.  In particular, function definitions bind the name of the new "
"function here."
msgstr ""
"Wird eine Klassendefinition betreten, wird ein neuer Namensraum erzeugt und "
"als lokaler Gültigkeitsbereich verwendet --- somit gehen alle Zuweisungen an "
"lokale Variablen in diesen neuen Namensraum. Insbesondere binden "
"Funktionsdefinitionen hier den Namen der neuen Funktion."

#: ../../tutorial/classes.rst:247
msgid ""
"When a class definition is left normally (via the end), a *class object* is "
"created.  This is basically a wrapper around the contents of the namespace "
"created by the class definition; we'll learn more about class objects in the "
"next section.  The original local scope (the one in effect just before the "
"class definition was entered) is reinstated, and the class object is bound "
"here to the class name given in the class definition header (:class:`!"
"ClassName` in the example)."
msgstr ""
"Wird eine Klassendefinition normal verlassen (durch das Ende), wird ein "
"*Klassenobjekt* erzeugt. Dies ist im Wesentlichen eine Hülle um den Inhalt "
"des durch die Klassendefinition erstellten Namensraums; wir werden im "
"nächsten Abschnitt mehr über Klassenobjekte lernen. Der ursprüngliche lokale "
"Gültigkeitsbereich (derjenige, der direkt vor dem Betreten der "
"Klassendefinition galt) wird wiederhergestellt und das Klassenobjekt wird "
"hier an den im Kopf der Klassendefinition angegebenen Klassennamen (:class:`!"
"ClassName` im Beispiel) gebunden."

#: ../../tutorial/classes.rst:259
msgid "Class Objects"
msgstr "Klassenobjekte"

#: ../../tutorial/classes.rst:261
msgid ""
"Class objects support two kinds of operations: attribute references and "
"instantiation."
msgstr ""
"Klassenobjekte unterstützen zwei Arten von Operationen: Attributreferenzen "
"und Instanziierung."

#: ../../tutorial/classes.rst:264
msgid ""
"*Attribute references* use the standard syntax used for all attribute "
"references in Python: ``obj.name``.  Valid attribute names are all the names "
"that were in the class's namespace when the class object was created.  So, "
"if the class definition looked like this::"
msgstr ""
"*Attributreferenzen* verwenden die Standardsyntax, die für alle "
"Attributreferenzen in Python genutzt wird: ``obj.name``. Gültige "
"Attributnamen sind alle Namen, die sich im Namensraum der Klasse befanden, "
"als das Klassenobjekt erzeugt wurde. Wenn die Klassendefinition also so "
"aussah::"

#: ../../tutorial/classes.rst:269
msgid ""
"class MyClass:\n"
"    \"\"\"A simple example class\"\"\"\n"
"    i = 12345\n"
"\n"
"    def f(self):\n"
"        return 'hello world'"
msgstr ""
"class MyClass:\n"
"    \"\"\"A simple example class\"\"\"\n"
"    i = 12345\n"
"\n"
"    def f(self):\n"
"        return 'hello world'"

#: ../../tutorial/classes.rst:276
msgid ""
"then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "
"returning an integer and a function object, respectively. Class attributes "
"can also be assigned to, so you can change the value of ``MyClass.i`` by "
"assignment. :attr:`~type.__doc__` is also a valid attribute, returning the "
"docstring belonging to the class: ``\"A simple example class\"``."
msgstr ""
"dann sind ``MyClass.i`` und ``MyClass.f`` gültige Attributreferenzen, die "
"jeweils eine Ganzzahl beziehungsweise ein Funktionsobjekt zurückgeben. "
"Klassenattribute können auch zugewiesen werden, sodass man den Wert von "
"``MyClass.i`` durch eine Zuweisung ändern kann. :attr:`~type.__doc__` ist "
"ebenfalls ein gültiges Attribut, das den zur Klasse gehörenden Docstring "
"zurückgibt: ``\"A simple example class\"``."

#: ../../tutorial/classes.rst:282
msgid ""
"Class *instantiation* uses function notation.  Just pretend that the class "
"object is a parameterless function that returns a new instance of the class. "
"For example (assuming the above class)::"
msgstr ""
"Die *Instanziierung* einer Klasse verwendet Funktionsnotation. Stell dir "
"einfach vor, dass das Klassenobjekt eine parameterlose Funktion ist, die "
"eine neue Instanz der Klasse zurückgibt. Zum Beispiel (unter Annahme der "
"obigen Klasse)::"

#: ../../tutorial/classes.rst:286 ../../tutorial/classes.rst:303
msgid "x = MyClass()"
msgstr "x = MyClass()"

#: ../../tutorial/classes.rst:288
msgid ""
"creates a new *instance* of the class and assigns this object to the local "
"variable ``x``."
msgstr ""
"erzeugt eine neue *Instanz* der Klasse und weist dieses Objekt der lokalen "
"Variablen ``x`` zu."

#: ../../tutorial/classes.rst:291
msgid ""
"The instantiation operation (\"calling\" a class object) creates an empty "
"object. Many classes like to create objects with instances customized to a "
"specific initial state. Therefore a class may define a special method named :"
"meth:`~object.__init__`, like this::"
msgstr ""
"Die Instanziierungsoperation (das \\\"Aufrufen\\\" eines Klassenobjekts) "
"erzeugt ein leeres Objekt. Viele Klassen erzeugen Objekte bevorzugt mit "
"Instanzen, die auf einen bestimmten Anfangszustand angepasst sind. Daher "
"kann eine Klasse eine spezielle Methode namens :meth:`~object.__init__` "
"definieren, wie etwa so::"

#: ../../tutorial/classes.rst:296
msgid ""
"def __init__(self):\n"
"    self.data = []"
msgstr ""
"def __init__(self):\n"
"    self.data = []"

#: ../../tutorial/classes.rst:299
msgid ""
"When a class defines an :meth:`~object.__init__` method, class instantiation "
"automatically invokes :meth:`!__init__` for the newly created class "
"instance.  So in this example, a new, initialized instance can be obtained "
"by::"
msgstr ""
"Wenn eine Klasse eine :meth:`~object.__init__`-Methode definiert, ruft die "
"Klasseninstanziierung automatisch :meth:`!__init__` für die neu erzeugte "
"Klasseninstanz auf. In diesem Beispiel kann eine neue, initialisierte "
"Instanz also wie folgt erzeugt werden::"

#: ../../tutorial/classes.rst:305
msgid ""
"Of course, the :meth:`~object.__init__` method may have arguments for "
"greater flexibility.  In that case, arguments given to the class "
"instantiation operator are passed on to :meth:`!__init__`.  For example, ::"
msgstr ""
"Natürlich kann die :meth:`~object.__init__`-Methode für mehr Flexibilität "
"auch Argumente besitzen. In diesem Fall werden dem "
"Klasseninstanziierungsoperator übergabene Argumente an :meth:`!__init__` "
"weitergeleitet. Zum Beispiel::"

#: ../../tutorial/classes.rst:309
msgid ""
">>> class Complex:\n"
"...     def __init__(self, realpart, imagpart):\n"
"...         self.r = realpart\n"
"...         self.i = imagpart\n"
"...\n"
">>> x = Complex(3.0, -4.5)\n"
">>> x.r, x.i\n"
"(3.0, -4.5)"
msgstr ""
">>> class Complex:\n"
"...     def __init__(self, realpart, imagpart):\n"
"...         self.r = realpart\n"
"...         self.i = imagpart\n"
"...\n"
">>> x = Complex(3.0, -4.5)\n"
">>> x.r, x.i\n"
"(3.0, -4.5)"

#: ../../tutorial/classes.rst:322
msgid "Instance Objects"
msgstr "Instanzobjekte"

#: ../../tutorial/classes.rst:324
msgid ""
"Now what can we do with instance objects?  The only operations understood by "
"instance objects are attribute references.  There are two kinds of valid "
"attribute names: data attributes and methods."
msgstr ""
"Was können wir nun mit Instanzobjekten tun? Die einzigen Operationen, die "
"von Instanzobjekten verstanden werden, sind Attributreferenzen. Es gibt zwei "
"Arten von gültigen Attributnamen: Datenattribute und Methoden."

#: ../../tutorial/classes.rst:328
msgid ""
"*Data attributes* correspond to \"instance variables\" in Smalltalk, and to "
"\"data members\" in C++.  Data attributes need not be declared; like local "
"variables, they spring into existence when they are first assigned to.  For "
"example, if ``x`` is the instance of :class:`!MyClass` created above, the "
"following piece of code will print the value ``16``, without leaving a "
"trace::"
msgstr ""
"*Datenattribute* entsprechen „Instanzvariablen“ in Smalltalk und "
"„Datenelementen“ in C++. Datenattribute müssen nicht deklariert werden; wie "
"lokale Variablen entstehen sie, wenn ihnen erstmals etwas zugewiesen wird. "
"Wenn ``x`` beispielsweise die oben erzeugte Instanz von :class:`!MyClass` "
"ist, gibt der folgende Codeabschnitt den Wert ``16`` aus, ohne Spuren zu "
"hinterlassen::\""

#: ../../tutorial/classes.rst:334
msgid ""
"x.counter = 1\n"
"while x.counter < 10:\n"
"    x.counter = x.counter * 2\n"
"print(x.counter)\n"
"del x.counter"
msgstr ""
"x.counter = 1\n"
"while x.counter < 10:\n"
"    x.counter = x.counter * 2\n"
"print(x.counter)\n"
"del x.counter"

#: ../../tutorial/classes.rst:340
msgid ""
"The other kind of instance attribute reference is a *method*. A method is a "
"function that \"belongs to\" an object."
msgstr ""
"Die andere Art von Instanzattributreferenz ist eine *Methode*. Eine Methode "
"ist eine Funktion, die zu einem Objekt „gehört“."

#: ../../tutorial/classes.rst:345
msgid ""
"Valid method names of an instance object depend on its class.  By "
"definition, all attributes of a class that are function  objects define "
"corresponding methods of its instances.  So in our example, ``x.f`` is a "
"valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is "
"not, since ``MyClass.i`` is not.  But ``x.f`` is not the same thing as "
"``MyClass.f`` --- it is a *method object*, not a function object."
msgstr ""
"Gültige Methodennamen eines Instanzobjekts hängen von dessen Klasse ab. "
"Definitionsgemäß definieren alle Attribute einer Klasse, die "
"Funktionsobjekte sind, entsprechende Methoden ihrer Instanzen. In unserem "
"Beispiel ist ``x.f`` also eine gültige Methodenreferenz, da ``MyClass.f`` "
"eine Funktion ist, ``x.i`` hingege nicht, da ``MyClass.i`` keine ist. Aber "
"``x.f`` ist nicht dasselbe wie ``MyClass.f`` --- es ist ein "
"*Methodenobjekt*, kein Funktionsobjekt."

#: ../../tutorial/classes.rst:356
msgid "Method Objects"
msgstr "Methodenobjekte"

#: ../../tutorial/classes.rst:358
msgid "Usually, a method is called right after it is bound::"
msgstr ""
"Normalerweise wird eine Methode direkt aufgerufen, nachdem sie gebunden "
"wurde::"

#: ../../tutorial/classes.rst:360
msgid "x.f()"
msgstr "x.f()"

#: ../../tutorial/classes.rst:362
msgid ""
"If ``x = MyClass()``, as above, this will return the string ``'hello "
"world'``. However, it is not necessary to call a method right away: ``x.f`` "
"is a method object, and can be stored away and called at a later time.  For "
"example::"
msgstr ""
"Wenn ``x = MyClass()`` gilt (wie oben), gibt dies die Zeichenkette ``'hello "
"world'`` zurück. Es ist jedoch nicht notwendig, eine Methode sofort "
"aufzurufen: ``x.f`` ist ein Methodenobjekt und kann gespeichert und zu einem "
"späteren Zeitpunkt aufgerufen werden. Zum Beispiel::"

#: ../../tutorial/classes.rst:366
msgid ""
"xf = x.f\n"
"while True:\n"
"    print(xf())"
msgstr ""
"xf = x.f\n"
"while True:\n"
"    print(xf())"

#: ../../tutorial/classes.rst:370
msgid "will continue to print ``hello world`` until the end of time."
msgstr "gibt bis ans Ende der Zeit weiterhin ``hello world`` aus."

#: ../../tutorial/classes.rst:372
msgid ""
"What exactly happens when a method is called?  You may have noticed that ``x."
"f()`` was called without an argument above, even though the function "
"definition for :meth:`!f` specified an argument.  What happened to the "
"argument? Surely Python raises an exception when a function that requires an "
"argument is called without any --- even if the argument isn't actually "
"used..."
msgstr ""
"Was genau passiert, wenn eine Methode aufgerufen wird? Du hast vielleicht "
"bemerkt, dass ``x.f()`` oben ohne Argument aufgerufen wurde, obwohl die "
"Funktionsdefinition für :meth:`!f` ein Argument angab. Was ist mit dem "
"Argument passiert? Python löst sicherlich eine Ausnahme aus, wenn eine "
"Funktion, die ein Argument erfordert, ohne ein solches aufgerufen wird --- "
"selbst wenn das Argument gar nicht verwendet wird..."

#: ../../tutorial/classes.rst:378
msgid ""
"Actually, you may have guessed the answer: the special thing about methods "
"is that the instance object is passed as the first argument of the "
"function.  In our example, the call ``x.f()`` is exactly equivalent to "
"``MyClass.f(x)``.  In general, calling a method with a list of *n* arguments "
"is equivalent to calling the corresponding function with an argument list "
"that is created by inserting the method's instance object before the first "
"argument."
msgstr ""
"Eigentlich hast du die Antwort vielleicht schon geahnt: Das Besondere an "
"Methoden ist, dass das Instanzobjekt als erstes Argument der Funktion "
"übergeben wird. In unserem Beispiel ist der Aufruf ``x.f()`` genau "
"äquivalent zu ``MyClass.f(x)``. Im Allgemeinen entspricht der Aufruf einer "
"Methode mit einer Liste von *n* Argumenten dem Aufruf der entsprechenden "
"Funktion mit einer Argumentliste, die durch Einfügen des Instanzobjekts der "
"Methode vor dem ersten Argument erstellt wird."

#: ../../tutorial/classes.rst:385
msgid ""
"In general, methods work as follows.  When a non-data attribute of an "
"instance is referenced, the instance's class is searched. If the name "
"denotes a valid class attribute that is a function object, references to "
"both the instance object and the function object are packed into a method "
"object.  When the method object is called with an argument list, a new "
"argument list is constructed from the instance object and the argument list, "
"and the function object is called with this new argument list."
msgstr ""
"Im Allgemeinen funktionieren Methoden wie folgt: Wenn auf ein Attribut einer "
"Instanz verwiesen wird, das kein Datenattribut ist, wird die Klasse der "
"Instanz durchsucht. Bezeichnet der Name ein gültiges Klassenattribut, das "
"ein Funktionsobjekt ist, werden Referenzen auf das Instanzobjekt und das "
"Funktionsobjekt in ein Methodenobjekt gepackt. Wird das Methodenobjekt mit "
"einer Argumentliste aufgerufen, wird aus dem Instanzobjekt und der "
"Argumentliste eine neue Argumentliste erstellt und das Funktionsobjekt mit "
"dieser neuen Argumentliste aufgerufen."

#: ../../tutorial/classes.rst:398
msgid "Class and Instance Variables"
msgstr "Klassen- und Instanzvariablen"

#: ../../tutorial/classes.rst:400
msgid ""
"Generally speaking, instance variables are for data unique to each instance "
"and class variables are for attributes and methods shared by all instances "
"of the class::"
msgstr ""
"Allgemein gesagt sind Instanzvariablen für Daten gedacht, die für jede "
"Instanz eindeutig sind, während Klassenvariablen für Attribute und Methoden "
"gedacht sind, die von allen Instanzen der Klasse geteilt werden::"

#: ../../tutorial/classes.rst:404
msgid ""
"class Dog:\n"
"\n"
"    kind = 'canine'         # class variable shared by all instances\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name    # instance variable unique to each instance\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.kind                  # shared by all dogs\n"
"'canine'\n"
">>> e.kind                  # shared by all dogs\n"
"'canine'\n"
">>> d.name                  # unique to d\n"
"'Fido'\n"
">>> e.name                  # unique to e\n"
"'Buddy'"
msgstr ""
"class Dog:\n"
"\n"
"    kind = 'canine'         # class variable shared by all instances\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name    # instance variable unique to each instance\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.kind                  # shared by all dogs\n"
"'canine'\n"
">>> e.kind                  # shared by all dogs\n"
"'canine'\n"
">>> d.name                  # unique to d\n"
"'Fido'\n"
">>> e.name                  # unique to e\n"
"'Buddy'"

#: ../../tutorial/classes.rst:422
msgid ""
"As discussed in :ref:`tut-object`, shared data can have possibly surprising "
"effects involving :term:`mutable` objects such as lists and dictionaries. "
"For example, the *tricks* list in the following code should not be used as a "
"class variable because just a single list would be shared by all *Dog* "
"instances::"
msgstr ""
"Wie in :ref:`tut-object` besprochen, können geteilte Daten in Verbindung "
"mit :term:`veränderbaren <mutable>` Objekten wie Listen und Wörterbüchern "
"überraschende Effekte haben. Die Liste *tricks* im folgenden Code sollte "
"beispielsweise nicht als Klassenvariable verwendet werden, da nur eine "
"einzige Liste von allen *Dog*-Instanzen geteilt würde::"

#: ../../tutorial/classes.rst:428
msgid ""
"class Dog:\n"
"\n"
"    tricks = []             # mistaken use of a class variable\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('roll over')\n"
">>> e.add_trick('play dead')\n"
">>> d.tricks                # unexpectedly shared by all dogs\n"
"['roll over', 'play dead']"
msgstr ""
"class Dog:\n"
"\n"
"    tricks = []             # falsche Verwendung einer Klassenvariable\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('roll over')\n"
">>> e.add_trick('play dead')\n"
">>> d.tricks                # unerwartet von allen Hunden geteilt\n"
"['roll over', 'play dead']"

#: ../../tutorial/classes.rst:445
msgid "Correct design of the class should use an instance variable instead::"
msgstr ""
"Ein korrektes Design der Klasse sollte stattdessen eine Instanzvariable "
"verwenden::"

#: ../../tutorial/classes.rst:447
msgid ""
"class Dog:\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"        self.tricks = []    # creates a new empty list for each dog\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('roll over')\n"
">>> e.add_trick('play dead')\n"
">>> d.tricks\n"
"['roll over']\n"
">>> e.tricks\n"
"['play dead']"
msgstr ""
"class Dog:\n"
"\n"
"    def __init__(self, name):\n"
"        self.name = name\n"
"        self.tricks = []    # erzeugt eine neue leere Liste für jeden Hund\n"
"\n"
"    def add_trick(self, trick):\n"
"        self.tricks.append(trick)\n"
"\n"
">>> d = Dog('Fido')\n"
">>> e = Dog('Buddy')\n"
">>> d.add_trick('roll over')\n"
">>> e.add_trick('play dead')\n"
">>> d.tricks\n"
"['roll over']\n"
">>> e.tricks\n"
"['play dead']"

#: ../../tutorial/classes.rst:469
msgid "Random Remarks"
msgstr "Ergänzende Hinweise"

#: ../../tutorial/classes.rst:473
msgid ""
"If the same attribute name occurs in both an instance and in a class, then "
"attribute lookup prioritizes the instance::"
msgstr ""
"Tritt derselbe Attributname sowohl in einer Instanz als auch in einer Klasse "
"auf, bevorzugt die Attributsuche die Instanz::"

#: ../../tutorial/classes.rst:476
msgid ""
">>> class Warehouse:\n"
"...    purpose = 'storage'\n"
"...    region = 'west'\n"
"...\n"
">>> w1 = Warehouse()\n"
">>> print(w1.purpose, w1.region)\n"
"storage west\n"
">>> w2 = Warehouse()\n"
">>> w2.region = 'east'\n"
">>> print(w2.purpose, w2.region)\n"
"storage east"
msgstr ""
">>> class Warehouse:\n"
"...    purpose = 'storage'\n"
"...    region = 'west'\n"
"...\n"
">>> w1 = Warehouse()\n"
">>> print(w1.purpose, w1.region)\n"
"storage west\n"
">>> w2 = Warehouse()\n"
">>> w2.region = 'east'\n"
">>> print(w2.purpose, w2.region)\n"
"storage east"

#: ../../tutorial/classes.rst:488
msgid ""
"Data attributes may be referenced by methods as well as by ordinary users "
"(\"clients\") of an object.  In other words, classes are not usable to "
"implement pure abstract data types.  In fact, nothing in Python makes it "
"possible to enforce data hiding --- it is all based upon convention.  (On "
"the other hand, the Python implementation, written in C, can completely hide "
"implementation details and control access to an object if necessary; this "
"can be used by extensions to Python written in C.)"
msgstr ""
"Datenattribute können sowohl von Methoden als auch von gewöhnlichen "
"Benutzern („Clients“) eines Objekts referenziert werden. Mit anderen Worten: "
"Klassen sind nicht dazu geeignet, reine abstrakte Datentypen zu "
"implementieren. In Python gibt es tatsächlich nichts, was eine Kapselung "
"(Data Hiding) erzwingen könnte --- alles beruht auf Konventionen. "
"(Andererseits kann die in C geschriebene Python-Implementierung "
"Implementierungsdetails vollständig verbergen und den Zugriff auf ein Objekt "
"bei Bedarf steuern; dies kann von in C geschriebenen Python-Erweiterungen "
"genutzt werden.)"

#: ../../tutorial/classes.rst:496
msgid ""
"Clients should use data attributes with care --- clients may mess up "
"invariants maintained by the methods by stamping on their data attributes.  "
"Note that clients may add data attributes of their own to an instance object "
"without affecting the validity of the methods, as long as name conflicts are "
"avoided --- again, a naming convention can save a lot of headaches here."
msgstr ""
"Benutzer sollten Datenattribute mit Vorsicht verwenden --- sie können von "
"Methoden aufrechterhaltene Invarianten beschädigen, indem sie deren "
"Datenattribute überschreiben. Beachte, dass Benutzer einem Instanzobjekt "
"eigene Datenattribute hinzufügen können, ohne die Gültigkeit der Methoden zu "
"beeinträchtigen, solange Namenskonflikte vermieden werden --- auch hier kann "
"eine Namenskonvention viel Ärger ersparen."

#: ../../tutorial/classes.rst:502
msgid ""
"There is no shorthand for referencing data attributes (or other methods!) "
"from within methods.  I find that this actually increases the readability of "
"methods: there is no chance of confusing local variables and instance "
"variables when glancing through a method."
msgstr ""
"Es gibt keine Kurzschreibweise, um innerhalb von Methoden auf Datenattribute "
"(oder andere Methoden!) zu verweisen. Dies erhöht tatsächlich die Lesbarkeit "
"von Methoden: Beim Durchsehen einer Methode besteht keine Gefahr, lokale "
"Variablen und Instanzvariablen zu verwechseln."

#: ../../tutorial/classes.rst:507
msgid ""
"Often, the first argument of a method is called ``self``.  This is nothing "
"more than a convention: the name ``self`` has absolutely no special meaning "
"to Python.  Note, however, that by not following the convention your code "
"may be less readable to other Python programmers, and it is also conceivable "
"that a *class browser* program might be written that relies upon such a "
"convention."
msgstr ""
"Oft wird das erste Argument einer Methode ``self`` genannt. Dies ist nichts "
"weiter als eine Konvention: Der Name ``self`` hat für Python absolut keine "
"spezielle Bedeutung. Beachte jedoch, dass dein Code für andere Python-"
"Programmierer schwerer lesbar sein kann, wenn du dich nicht an diese "
"Konvention hältst, und es ist auch denkbar, dass ein *Class-Browser*-"
"Programm geschrieben wird, das sich auf eine solche Konvention verlässt."

#: ../../tutorial/classes.rst:513
msgid ""
"Any function object that is a class attribute defines a method for instances "
"of that class.  It is not necessary that the function definition is "
"textually enclosed in the class definition: assigning a function object to a "
"local variable in the class is also ok.  For example::"
msgstr ""
"Jedes Funktionsobjekt, das ein Klassenattribut ist, definiert eine Methode "
"für Instanzen dieser Klasse. Es ist nicht erforderlich, dass die "
"Funktionsdefinition textuell in die Klassendefinition eingeschlossen ist: "
"Das Zuweisen eines Funktionsobjekts zu einer lokalen Variable in der Klasse "
"ist ebenfalls in Ordnung. Zum Beispiel::"

#: ../../tutorial/classes.rst:518
msgid ""
"# Function defined outside the class\n"
"def f1(self, x, y):\n"
"    return min(x, x+y)\n"
"\n"
"class C:\n"
"    f = f1\n"
"\n"
"    def g(self):\n"
"        return 'hello world'\n"
"\n"
"    h = g"
msgstr ""
"# Außerhalb der Klasse definierte Funktion\n"
"def f1(self, x, y):\n"
"    return min(x, x+y)\n"
"\n"
"class C:\n"
"    f = f1\n"
"\n"
"    def g(self):\n"
"        return 'hello world'\n"
"\n"
"    h = g"

#: ../../tutorial/classes.rst:530
msgid ""
"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`!C` that "
"refer to function objects, and consequently they are all methods of "
"instances of :class:`!C` --- ``h`` being exactly equivalent to ``g``.  Note "
"that this practice usually only serves to confuse the reader of a program."
msgstr ""
"Nun sind ``f``, ``g`` und ``h`` alles Attribute der Klasse :class:`!C`, die "
"auf Funktionsobjekte verweisen, und folglich sind sie alle Methoden von "
"Instanzen von :class:`!C` --- wobei ``h`` genau äquivalent zu ``g`` ist. "
"Beachte, dass diese Praxis gewöhnlich nur dazu dient, den Leser eines "
"Programms zu verwirren."

#: ../../tutorial/classes.rst:535
msgid ""
"Methods may call other methods by using method attributes of the ``self`` "
"argument::"
msgstr ""
"Methoden können andere Methoden aufrufen, indem sie Methodenattribute des "
"\"\n"
"\"``self``-Arguments verwenden::"

#: ../../tutorial/classes.rst:538
msgid ""
"class Bag:\n"
"    def __init__(self):\n"
"        self.data = []\n"
"\n"
"    def add(self, x):\n"
"        self.data.append(x)\n"
"\n"
"    def addtwice(self, x):\n"
"        self.add(x)\n"
"        self.add(x)"
msgstr ""
"class Bag:\n"
"    def __init__(self):\n"
"        self.data = []\n"
"\n"
"    def add(self, x):\n"
"        self.data.append(x)\n"
"\n"
"    def addtwice(self, x):\n"
"        self.add(x)\n"
"        self.add(x)"

#: ../../tutorial/classes.rst:549
msgid ""
"Methods may reference global names in the same way as ordinary functions.  "
"The global scope associated with a method is the module containing its "
"definition.  (A class is never used as a global scope.)  While one rarely "
"encounters a good reason for using global data in a method, there are many "
"legitimate uses of the global scope: for one thing, functions and modules "
"imported into the global scope can be used by methods, as well as functions "
"and classes defined in it.  Usually, the class containing the method is "
"itself defined in this global scope, and in the next section we'll find some "
"good reasons why a method would want to reference its own class."
msgstr ""
"Methoden können auf globale Namen auf dieselbe Weise verweisen wie "
"gewöhnliche Funktionen. Der mit einer Methode verknüpfte globale "
"Gültigkeitsbereich ist das Modul, das ihre Definition enthält. (Eine Klasse "
"wird nie als globaler Gültigkeitsbereich verwendet.) Während man selten "
"einen guten Grund dafür findet, globale Daten in einer Methode zu verwenden, "
"gibt es viele berechtigte Anwendungen für den globalen Gültigkeitsbereich: "
"Zum einen können in den globalen Gültigkeitsbereich importierte Funktionen "
"und Module von Methoden verwendet werden, ebenso wie darin definierte "
"Funktionen und Klassen. Üblicherweise ist die Klasse, die die Methode "
"enthält, selbst in diesem globalen Gültigkeitsbereich definiert, und im "
"nächsten Abschnitt werden wir einige gute Gründe dafür finden, warum eine "
"Methode auf ihre eigene Klasse verweisen möchte."

#: ../../tutorial/classes.rst:559
msgid ""
"Each value is an object, and therefore has a *class* (also called its "
"*type*). It is stored as ``object.__class__``."
msgstr ""
"Jeder Wert ist ein Objekt und hat daher eine *Klasse* (auch *Typ* genannt). "
"Diese ist als ``object.__class__`` gespeichert."

#: ../../tutorial/classes.rst:566
msgid "Inheritance"
msgstr "Vererbung"

#: ../../tutorial/classes.rst:568
msgid ""
"Of course, a language feature would not be worthy of the name \"class\" "
"without supporting inheritance.  The syntax for a derived class definition "
"looks like this::"
msgstr ""
"Natürlich wäre ein Sprachfeature des Namens „Klasse“ nicht würdig, wenn es "
"keine Vererbung unterstützen würde. Die Syntax für die Definition einer "
"abgeleiteten Klasse sieht wie folgt aus::"

#: ../../tutorial/classes.rst:572
msgid ""
"class DerivedClassName(BaseClassName):\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"
msgstr ""
"class DerivedClassName(BaseClassName):\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"

#: ../../tutorial/classes.rst:579
msgid ""
"The name :class:`!BaseClassName` must be defined in a namespace accessible "
"from the scope containing the derived class definition.  In place of a base "
"class name, other arbitrary expressions are also allowed.  This can be "
"useful, for example, when the base class is defined in another module::"
msgstr ""
"Der Name :class:`!BaseClassName` muss in einem Namensraum definiert sein, "
"der aus dem Gültigkeitsbereich der abgeleiteten Klassendefinition heraus "
"zugänglich ist. Anstelle eines Basisklassennamens sind auch andere beliebige "
"Ausdrücke erlaubt. Dies kann beispielsweise nützlich sein, wenn die "
"Basisklasse in einem anderen Modul definiert ist::"

#: ../../tutorial/classes.rst:585
msgid "class DerivedClassName(modname.BaseClassName):"
msgstr "class DerivedClassName(modname.BaseClassName):"

#: ../../tutorial/classes.rst:587
msgid ""
"Execution of a derived class definition proceeds the same as for a base "
"class. When the class object is constructed, the base class is remembered.  "
"This is used for resolving attribute references: if a requested attribute is "
"not found in the class, the search proceeds to look in the base class.  This "
"rule is applied recursively if the base class itself is derived from some "
"other class."
msgstr ""
"Die Ausführung einer abgeleiteten Klassendefinition verläuft genauso wie für "
"eine Basisklasse. Wenn das Klassenobjekt erzeugt wird, wird die Basisklasse "
"gemerkt. Dies wird zur Auflösung von Attributreferenzen verwendet: Wird ein "
"angefordertes Attribut nicht in der Klasse gefunden, wird in der Basisklasse "
"weitergesucht. Diese Regel wird rekursiv angewendet, wenn die Basisklasse "
"selbst von einer anderen Klasse abgeleitet ist."

#: ../../tutorial/classes.rst:593
msgid ""
"There's nothing special about instantiation of derived classes: "
"``DerivedClassName()`` creates a new instance of the class.  Method "
"references are resolved as follows: the corresponding class attribute is "
"searched, descending down the chain of base classes if necessary, and the "
"method reference is valid if this yields a function object."
msgstr ""
"Die Instanziierung abgeleiteter Klassen weist keine Besonderheiten auf: "
"``DerivedClassName()`` erzeugt eine neue Instanz der Klasse. "
"Methodenreferenzen werden wie folgt aufgelöst: Das entsprechende "
"Klassenattribut wird gesucht, wobei bei Bedarf die Kette der Basisklassen "
"durchsucht wird. Die Methodenreferenz ist gültig, wenn dies ein "
"Funktionsobjekt ergibt."

#: ../../tutorial/classes.rst:599
msgid ""
"Derived classes may override methods of their base classes.  Because methods "
"have no special privileges when calling other methods of the same object, a "
"method of a base class that calls another method defined in the same base "
"class may end up calling a method of a derived class that overrides it.  "
"(For C++ programmers: all methods in Python are effectively ``virtual``.)"
msgstr ""
"Abgeleitete Klassen können Methoden ihrer Basisklassen überschreiben. Da "
"Methoden keine besonderen Privilegien beim Aufruf anderer Methoden desselben "
"Objekts besitzen, kann das Aufrufen einer in derselben Basisklasse "
"definierten Methode letztlich dazu führen, dass eine Methode einer "
"abgeleiteten Klasse aufgerufen wird, die diese überschreibt. (Für C++ "
"Programmierer: Alle Methoden in Python sind effektiv ``virtual``.)"

#: ../../tutorial/classes.rst:605
msgid ""
"An overriding method in a derived class may in fact want to extend rather "
"than simply replace the base class method of the same name. There is a "
"simple way to call the base class method directly: just call ``BaseClassName."
"methodname(self, arguments)``.  This is occasionally useful to clients as "
"well.  (Note that this only works if the base class is accessible as "
"``BaseClassName`` in the global scope.)"
msgstr ""
"Eine überschreibende Methode in einer abgeleiteten Klasse möchte die Methode "
"gleichen Namens der Basisklasse womöglich erweitern, anstatt sie einfach zu "
"ersetzen. Es gibt einen einfachen Weg, die Methode der Basisklasse direkt "
"aufzurufen: Man ruft einfach ``BaseClassName.methodname(self, arguments)`` "
"auf. Dies ist gelegentlich auch für Clients nützlich. (Beachte, dass dies "
"nur funktioniert, wenn die Basisklasse als ``BaseClassName`` im globalen "
"Gültigkeitsbereich zugänglich ist.)"

#: ../../tutorial/classes.rst:612
msgid "Python has two built-in functions that work with inheritance:"
msgstr "Python bietet zwei integrierte Funktionen, die mit Vererbung arbeiten:"

#: ../../tutorial/classes.rst:614
msgid ""
"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "
"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
"derived from :class:`int`."
msgstr ""
"Verwende :func:`isinstance`, um den Typ einer Instanz zu überprüfen: "
"``isinstance(obj, int)`` ist nur dann ``True``, wenn ``obj.__class__`` "
"gleich :class:`int` oder einer von :class:`int` abgeleiteten Klasse ist."

#: ../../tutorial/classes.rst:618
msgid ""
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
"is ``True`` since :class:`bool` is a subclass of :class:`int`.  However, "
"``issubclass(float, int)`` is ``False`` since :class:`float` is not a "
"subclass of :class:`int`."
msgstr ""
"Verwende :func:`issubclass`, um die Klassenvererbung zu überprüfen: "
"``issubclass(bool, int)`` ist ``True``, da :class:`bool` eine Unterklasse "
"von :class:`int` ist. ``issubclass(float, int)`` ist jedoch ``False``, da :"
"class:`float` keine Unterklasse von :class:`int` ist."

#: ../../tutorial/classes.rst:628
msgid "Multiple Inheritance"
msgstr "Mehrfachvererbung"

#: ../../tutorial/classes.rst:630
msgid ""
"Python supports a form of multiple inheritance as well.  A class definition "
"with multiple base classes looks like this::"
msgstr ""
"Python unterstützt auch eine Form der Mehrfachvererbung. Eine "
"Klassendefinition mit mehreren Basisklassen sieht wie folgt aus::"

#: ../../tutorial/classes.rst:633
msgid ""
"class DerivedClassName(Base1, Base2, Base3):\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"
msgstr ""
"class DerivedClassName(Base1, Base2, Base3):\n"
"    <statement-1>\n"
"    .\n"
"    .\n"
"    .\n"
"    <statement-N>"

#: ../../tutorial/classes.rst:640
msgid ""
"For most purposes, in the simplest cases, you can think of the search for "
"attributes inherited from a parent class as depth-first, left-to-right, not "
"searching twice in the same class where there is an overlap in the "
"hierarchy. Thus, if an attribute is not found in :class:`!DerivedClassName`, "
"it is searched for in :class:`!Base1`, then (recursively) in the base "
"classes of :class:`!Base1`, and if it was not found there, it was searched "
"for in :class:`!Base2`, and so on."
msgstr ""
"Für die meisten Zwecke kann man sich die Suche nach Attributen, die von "
"einer Elternklasse geerbt wurden, in den einfachsten Fällen als Tiefensuche "
"von links nach rechts vorstellen, bei der dieselbe Klasse bei "
"Überschneidungen in der Hierarchie nicht zweimal durchsucht wird. Wenn ein "
"Attribut also nicht in :class:`!DerivedClassName` gefunden wird, wird in :"
"class:`!Base1` gesucht, dann (rekursiv) in den Basisklassen von :class:`!"
"Base1`, und falls es dort nicht gefunden wurde, wird in :class:`!Base2` "
"gesucht und so weiter."

#: ../../tutorial/classes.rst:647
msgid ""
"In fact, it is slightly more complex than that; the method resolution order "
"changes dynamically to support cooperative calls to :func:`super`.  This "
"approach is known in some other multiple-inheritance languages as call-next-"
"method and is more powerful than the super call found in single-inheritance "
"languages."
msgstr ""
"Tatsächlich ist es etwas komplexer: Die Method Auflösungsreihenfolge (Method "
"Resolution Order) ändert sich dynamisch, um kooperative Aufrufe von :func:"
"`super` zu unterstützen. Dieser Ansatz ist in einigen anderen Sprachen mit "
"Mehrfachvererbung als „call-next-method“ bekannt und ist mächtiger als der "
"Super-Aufruf in Sprachen mit einfacher Vererbung."

#: ../../tutorial/classes.rst:653
msgid ""
"Dynamic ordering is necessary because all cases of multiple inheritance "
"exhibit one or more diamond relationships (where at least one of the parent "
"classes can be accessed through multiple paths from the bottommost class).  "
"For example, all classes inherit from :class:`object`, so any case of "
"multiple inheritance provides more than one path to reach :class:`object`.  "
"To keep the base classes from being accessed more than once, the dynamic "
"algorithm linearizes the search order in a way that preserves the left-to-"
"right ordering specified in each class, that calls each parent only once, "
"and that is monotonic (meaning that a class can be subclassed without "
"affecting the precedence order of its parents). Taken together, these "
"properties make it possible to design reliable and extensible classes with "
"multiple inheritance.  For more detail, see :ref:`python_2.3_mro`."
msgstr ""
"Eine dynamische Reihenfolge ist erforderlich, da alle Fälle von "
"Mehrfachvererbung eine oder mehrere Diamant-Beziehungen aufweisen (bei denen "
"auf mindestens eine der Elternklassen über mehrere Pfade von der untersten "
"Klasse aus zugegriffen werden kann). So erben beispielsweise alle Klassen "
"von :class:`object`, sodass jeder Fall von Mehrfachvererbung mehr als einen "
"Pfad bietet, um :class:`object` zu erreichen. Um zu verhindern, dass auf die "
"Basisklassen mehr als einmal zugegriffen wird, linearisiert der dynamische "
"Algorithmus die Suchreihenfolge so, dass die in jeder Klasse angegebene "
"Reihenfolge von links nach rechts erhalten bleibt, jede Elternklasse nur "
"einmal aufgerufen wird und die Reihenfolge monoton ist (was bedeutet, dass "
"von einer Klasse abgeleitet werden kann, ohne die Vorrangstellung ihrer "
"Elternklassen zu beeinträchtigen). Zusammengefasst ermöglichen diese "
"Eigenschaften den Entwurf zuverlässiger und erweiterbarer Klassen mit "
"Mehrfachvererbung. Weitere Details findest du unter :ref:`python_2.3_mro`."

#: ../../tutorial/classes.rst:670
msgid "Private Variables"
msgstr "Private Variablen"

#: ../../tutorial/classes.rst:672
msgid ""
"\"Private\" instance variables that cannot be accessed except from inside an "
"object don't exist in Python.  However, there is a convention that is "
"followed by most Python code: a name prefixed with an underscore (e.g. "
"``_spam``) should be treated as a non-public part of the API (whether it is "
"a function, a method or a data member).  It should be considered an "
"implementation detail and subject to change without notice."
msgstr ""
"Private“ Instanzvariablen, auf die nur von innerhalb eines Objekts "
"zugegriffen werden kann, gibt es in Python nicht. Es gibt jedoch eine "
"Konvention, an die sich der meiste Python-Code hält: Ein Name mit einem "
"führenden Unterstrich (z. B. ``_spam``) sollte als nicht-öffentlicher Teil "
"der API behandelt werden (unabhängig davon, ob es sich um eine Funktion, "
"eine Methode oder ein Datenelement handelt). Er sollte als "
"Implementierungsdetail betrachtet werden, das sich ohne Ankündigung ändern "
"kann."

#: ../../tutorial/classes.rst:682
msgid ""
"Since there is a valid use-case for class-private members (namely to avoid "
"name clashes of names with names defined by subclasses), there is limited "
"support for such a mechanism, called :dfn:`name mangling`.  Any identifier "
"of the form ``__spam`` (at least two leading underscores, at most one "
"trailing underscore) is textually replaced with ``_classname__spam``, where "
"``classname`` is the current class name with leading underscore(s) "
"stripped.  This mangling is done without regard to the syntactic position of "
"the identifier, as long as it occurs within the definition of a class."
msgstr ""
"Da es einen berechtigten Anwendungsfall für klassenprivate Elemente gibt "
"(nämlich das Vermeiden von Namenskollisionen mit Namen, die von Unterklassen "
"definiert werden), gibt es eine begrenzte Unterstützung für einen solchen "
"Mechanismus, der als :dfn:`Name-Mangling` bezeichnet wird. Jeder Bezeichner "
"der Form ``__spam`` (mindestens zwei führende Unterstriche, höchstens ein "
"nachstehender Unterstrich) wird textuell durch ``_classname__spam`` ersetzt, "
"wobei ``classname`` der aktuelle Klassenname ohne führende Unterstriche ist. "
"Diese Umbenennung (Mangling) erfolgt ohne Rücksicht auf die syntaktische "
"Position des Bezeichners, solange es innerhalb der Definition einer Klasse "
"auftritt."

#: ../../tutorial/classes.rst:693
msgid ""
"The :ref:`private name mangling specifications <private-name-mangling>` for "
"details and special cases."
msgstr ""
"Die :ref:`Spezifikationen zur Namensumbenennung privater Elemente <private-"
"name-mangling>` für Details und Spezialfälle."

#: ../../tutorial/classes.rst:696
msgid ""
"Name mangling is helpful for letting subclasses override methods without "
"breaking intraclass method calls.  For example::"
msgstr ""
"Die Namensumbenennung ist nützlich, um Unterklassen das Überschreiben von "
"Methoden zu ermöglichen, ohne interne Methodenaufrufe innerhalb der Klasse "
"zu beeinträchtigen. Zum Beispiel::"

#: ../../tutorial/classes.rst:699
msgid ""
"class Mapping:\n"
"    def __init__(self, iterable):\n"
"        self.items_list = []\n"
"        self.__update(iterable)\n"
"\n"
"    def update(self, iterable):\n"
"        for item in iterable:\n"
"            self.items_list.append(item)\n"
"\n"
"    __update = update   # private copy of original update() method\n"
"\n"
"class MappingSubclass(Mapping):\n"
"\n"
"    def update(self, keys, values):\n"
"        # provides new signature for update()\n"
"        # but does not break __init__()\n"
"        for item in zip(keys, values):\n"
"            self.items_list.append(item)"
msgstr ""
"class Mapping:\n"
"    def __init__(self, iterable):\n"
"        self.items_list = []\n"
"        self.__update(iterable)\n"
"\n"
"    def update(self, iterable):\n"
"        for item in iterable:\n"
"            self.items_list.append(item)\n"
"\n"
"    __update = update   # private Kopie der ursprünglichen Methode update()\n"
"\n"
"class MappingSubclass(Mapping):\n"
"\n"
"    def update(self, keys, values):\n"
"        # provides new signature for update()\n"
"        # but does not break __init__()\n"
"        for item in zip(keys, values):\n"
"            self.items_list.append(item)"

#: ../../tutorial/classes.rst:718
msgid ""
"The above example would work even if ``MappingSubclass`` were to introduce a "
"``__update`` identifier since it is replaced with ``_Mapping__update`` in "
"the ``Mapping`` class  and ``_MappingSubclass__update`` in the "
"``MappingSubclass`` class respectively."
msgstr ""
"Das obige Beispiel würde selbst dann funktionieren, wenn ``MappingSubclass`` "
"einen ``__update``-Bezeichner einführen würde, da dieser in der Klasse "
"``Mapping`` durch ``_Mapping__update`` bzw. in der Klasse "
"``MappingSubclass`` durch ``_MappingSubclass__update`` ersetzt wird."

#: ../../tutorial/classes.rst:723
msgid ""
"Note that the mangling rules are designed mostly to avoid accidents; it "
"still is possible to access or modify a variable that is considered "
"private.  This can even be useful in special circumstances, such as in the "
"debugger."
msgstr ""
"Beachte, dass die Regeln zur Namensumbenennung hauptsächlich dazu dienen, "
"unbeabsichtigte Kollisionen zu vermeiden. Es ist weiterhin möglich, auf eine "
"Variable zuzugreifen oder diese zu verändern, die als privat gilt. Dies kann "
"unter besonderen Umständen sogar nützlich sein, beispielsweise im Debugger."

#: ../../tutorial/classes.rst:727
msgid ""
"Notice that code passed to ``exec()`` or ``eval()`` does not consider the "
"classname of the invoking class to be the current class; this is similar to "
"the effect of the ``global`` statement, the effect of which is likewise "
"restricted to code that is byte-compiled together.  The same restriction "
"applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when "
"referencing ``__dict__`` directly."
msgstr ""
"Beachte, dass Code, der an ``exec()`` oder ``eval()`` übergeben wird, den "
"Klassennamen der aufrufenden Klasse nicht als die aktuelle Klasse ansieht. "
"Dies ähnelt der Wirkung der ``global``-Anweisung, deren Wirkung ebenfalls "
"auf Code beschränkt ist, der zusammen byte-kompiliert wird. Die gleiche "
"Einschränkung gilt für ``getattr()``, ``setattr()`` und ``delattr()`` sowie "
"für die direkte Referenzierung von ``__dict__``."

#: ../../tutorial/classes.rst:738
msgid "Odds and Ends"
msgstr "Dies und Das"

#: ../../tutorial/classes.rst:740
msgid ""
"Sometimes it is useful to have a data type similar to the Pascal \"record\" "
"or C \"struct\", bundling together a few named data items. The idiomatic "
"approach is to use :mod:`dataclasses` for this purpose::"
msgstr ""
"Manchmal ist ein Datentyp nützlich, der dem „record“ in Pascal oder der "
"„struct“ in C ähnelt und einige benannte Datenobjekte bündelt. Der "
"idiomatische Ansatz hierfür ist die Verwendung von :mod:`dataclasses`::"

#: ../../tutorial/classes.rst:744
msgid ""
"from dataclasses import dataclass\n"
"\n"
"@dataclass\n"
"class Employee:\n"
"    name: str\n"
"    dept: str\n"
"    salary: int"
msgstr ""
"from dataclasses import dataclass\n"
"\n"
"@dataclass\n"
"class Employee:\n"
"    name: str\n"
"    dept: str\n"
"    salary: int"

#: ../../tutorial/classes.rst:754
msgid ""
">>> john = Employee('john', 'computer lab', 1000)\n"
">>> john.dept\n"
"'computer lab'\n"
">>> john.salary\n"
"1000"
msgstr ""
">>> john = Employee('john', 'computer lab', 1000)\n"
">>> john.dept\n"
"'computer lab'\n"
">>> john.salary\n"
"1000"

#: ../../tutorial/classes.rst:760
msgid ""
"A piece of Python code that expects a particular abstract data type can "
"often be passed a class that emulates the methods of that data type "
"instead.  For instance, if you have a function that formats some data from a "
"file object, you can define a class with methods :meth:`~io.TextIOBase.read` "
"and :meth:`~io.TextIOBase.readline` that get the data from a string buffer "
"instead, and pass it as an argument."
msgstr ""
"Einem Stück Python-Code, das einen bestimmten abstrakten Datentyp erwartet, "
"kann oft stattdessen eine Klasse übergeben werden, die die Methoden dieses "
"Datentyps emuliert. Wenn du beispielsweise eine Funktion hast, die Daten aus "
"einem Dateiobjekt formatiert, kannst du eine Klasse mit den Methoden :meth:"
"`~io.TextIOBase.read` und :meth:`~io.TextIOBase.readline` definieren, die "
"die Daten stattdessen aus einem String-Puffer bezieht, und eine Instanz "
"davon als Argument übergeben."

#: ../../tutorial/classes.rst:772
msgid ""
":ref:`Instance method objects <instance-methods>` have attributes, too: :"
"attr:`m.__self__ <method.__self__>` is the instance object with the method :"
"meth:`!m`, and :attr:`m.__func__ <method.__func__>` is the :ref:`function "
"object <user-defined-funcs>` corresponding to the method."
msgstr ""
":ref:`Instanzmethoden-Objekte <instance-methods>` besitzen ebenfalls "
"Attribute: :attr:`m.__self__ <method.__self__>` ist das Instanzobjekt mit "
"der Methode :meth:`!m`, und :attr:`m.__func__ <method.__func__>` ist das der "
"Methode entsprechende :ref:`Funktionsobjekt <user-defined-funcs>`."

#: ../../tutorial/classes.rst:782
msgid "Iterators"
msgstr "Iteratoren"

#: ../../tutorial/classes.rst:784
msgid ""
"By now you have probably noticed that most container objects can be looped "
"over using a :keyword:`for` statement::"
msgstr ""
"Inzwischen hast du wahrscheinlich bemerkt, dass über die meisten Container-"
"Objekte mit einer :keyword:`for`-Anweisung iteriert werden kann::"

#: ../../tutorial/classes.rst:787
msgid ""
"for element in [1, 2, 3]:\n"
"    print(element)\n"
"for element in (1, 2, 3):\n"
"    print(element)\n"
"for key in {'one':1, 'two':2}:\n"
"    print(key)\n"
"for char in \"123\":\n"
"    print(char)\n"
"for line in open(\"myfile.txt\"):\n"
"    print(line, end='')"
msgstr ""
"for element in [1, 2, 3]:\n"
"    print(element)\n"
"for element in (1, 2, 3):\n"
"    print(element)\n"
"for key in {'one':1, 'two':2}:\n"
"    print(key)\n"
"for char in \"123\":\n"
"    print(char)\n"
"for line in open(\"myfile.txt\"):\n"
"    print(line, end='')"

#: ../../tutorial/classes.rst:798
msgid ""
"This style of access is clear, concise, and convenient.  The use of "
"iterators pervades and unifies Python.  Behind the scenes, the :keyword:"
"`for` statement calls :func:`iter` on the container object.  The function "
"returns an iterator object that defines the method :meth:`~iterator."
"__next__` which accesses elements in the container one at a time.  When "
"there are no more elements, :meth:`~iterator.__next__` raises a :exc:"
"`StopIteration` exception which tells the :keyword:`!for` loop to "
"terminate.  You can call the :meth:`~iterator.__next__` method using the :"
"func:`next` built-in function; this example shows how it all works::"
msgstr ""
"Diese Art des Zugriffs ist klar, prägnant und bequem. Die Verwendung von "
"Iteratoren durchzieht und vereinheitlicht Python. Hinter den Kulissen ruft "
"die :keyword:`for`-Anweisung :func:`iter` für das Container-Objekt auf. Die "
"Funktion gibt ein Iterator-Objekt zurück, das die Methode :meth:`~iterator."
"__next__` definiert, welche nacheinander auf die Elemente im Container "
"zugreift. Wenn keine Elemente mehr vorhanden sind, löst :meth:`~iterator."
"__next__` eine :exc:`StopIteration`-Ausnahme aus, die der :keyword:`!for`-"
"Schleife mitteilt, dass sie beendet werden soll. Du kannst die Methode :meth:"
"`~iterator.__next__` über die integrierte Funktion :func:`next` aufrufen. "
"Dieses Beispiel zeigt, wie das Ganze funktioniert::\""

#: ../../tutorial/classes.rst:807
msgid ""
">>> s = 'abc'\n"
">>> it = iter(s)\n"
">>> it\n"
"<str_iterator object at 0x10c90e650>\n"
">>> next(it)\n"
"'a'\n"
">>> next(it)\n"
"'b'\n"
">>> next(it)\n"
"'c'\n"
">>> next(it)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    next(it)\n"
"StopIteration"
msgstr ""
">>> s = 'abc'\n"
">>> it = iter(s)\n"
">>> it\n"
"<str_iterator object at 0x10c90e650>\n"
">>> next(it)\n"
"'a'\n"
">>> next(it)\n"
"'b'\n"
">>> next(it)\n"
"'c'\n"
">>> next(it)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    next(it)\n"
"StopIteration"

#: ../../tutorial/classes.rst:823
msgid ""
"Having seen the mechanics behind the iterator protocol, it is easy to add "
"iterator behavior to your classes.  Define an :meth:`~container.__iter__` "
"method which returns an object with a :meth:`~iterator.__next__` method.  If "
"the class defines :meth:`!__next__`, then :meth:`!__iter__` can just return "
"``self``::"
msgstr ""
"Nachdem du die Mechanik hinter dem Iterator-Protokoll gesehen hast, ist es "
"einfach, deinen Klassen Iterator-Verhalten hinzuzufügen. Definiere eine :"
"meth:`~container.__iter__`-Methode, die ein Objekt mit einer :meth:"
"`~iterator.__next__`-Methode zurückgibt. Wenn die Klasse :meth:`!__next__` "
"definiert, kann :meth:`!__iter__` einfach ``self`` zurückgeben::"

#: ../../tutorial/classes.rst:828
msgid ""
"class Reverse:\n"
"    \"\"\"Iterator for looping over a sequence backwards.\"\"\"\n"
"    def __init__(self, data):\n"
"        self.data = data\n"
"        self.index = len(data)\n"
"\n"
"    def __iter__(self):\n"
"        return self\n"
"\n"
"    def __next__(self):\n"
"        if self.index == 0:\n"
"            raise StopIteration\n"
"        self.index = self.index - 1\n"
"        return self.data[self.index]"
msgstr ""
"class Reverse:\n"
"    \"\"\"Iterator for looping over a sequence backwards.\"\"\"\n"
"    def __init__(self, data):\n"
"        self.data = data\n"
"        self.index = len(data)\n"
"\n"
"    def __iter__(self):\n"
"        return self\n"
"\n"
"    def __next__(self):\n"
"        if self.index == 0:\n"
"            raise StopIteration\n"
"        self.index = self.index - 1\n"
"        return self.data[self.index]"

#: ../../tutorial/classes.rst:845
msgid ""
">>> rev = Reverse('spam')\n"
">>> iter(rev)\n"
"<__main__.Reverse object at 0x00A1DB50>\n"
">>> for char in rev:\n"
"...     print(char)\n"
"...\n"
"m\n"
"a\n"
"p\n"
"s"
msgstr ""
">>> rev = Reverse('spam')\n"
">>> iter(rev)\n"
"<__main__.Reverse object at 0x00A1DB50>\n"
">>> for char in rev:\n"
"...     print(char)\n"
"...\n"
"m\n"
"a\n"
"p\n"
"s"

#: ../../tutorial/classes.rst:860
msgid "Generators"
msgstr "Generatoren"

#: ../../tutorial/classes.rst:862
msgid ""
":term:`Generators <generator>` are a simple and powerful tool for creating "
"iterators.  They are written like regular functions but use the :keyword:"
"`yield` statement whenever they want to return data.  Each time :func:`next` "
"is called on it, the generator resumes where it left off (it remembers all "
"the data values and which statement was last executed).  An example shows "
"that generators can be trivially easy to create::"
msgstr ""
":term:`Generatoren <generator>` sind ein einfaches und mächtiges Werkzeug "
"zum Erstellen von Iteratoren. Sie werden wie gewöhnliche Funktionen "
"geschrieben, verwenden aber die :keyword:`yield`-Anweisung, wann immer sie "
"Daten zurückgeben wollen. Jedes Mal, wenn :func:`next` darauf aufgerufen "
"wird, setzt der Generator an der Stelle fort, an der er aufgehört hat (er "
"merkt sich alle Datenwerte und welche Anweisung zuletzt ausgeführt wurde). "
"Ein Beispiel zeigt, dass Generatoren denkbar einfach zu erstellen sind::"

#: ../../tutorial/classes.rst:869
msgid ""
"def reverse(data):\n"
"    for index in range(len(data)-1, -1, -1):\n"
"        yield data[index]"
msgstr ""
"def reverse(data):\n"
"    for index in range(len(data)-1, -1, -1):\n"
"        yield data[index]"

#: ../../tutorial/classes.rst:875
msgid ""
">>> for char in reverse('golf'):\n"
"...     print(char)\n"
"...\n"
"f\n"
"l\n"
"o\n"
"g"
msgstr ""
">>> for char in reverse('golf'):\n"
"...     print(char)\n"
"...\n"
"f\n"
"l\n"
"o\n"
"g"

#: ../../tutorial/classes.rst:883
msgid ""
"Anything that can be done with generators can also be done with class-based "
"iterators as described in the previous section.  What makes generators so "
"compact is that the :meth:`~iterator.__iter__` and :meth:`~generator."
"__next__` methods are created automatically."
msgstr ""
"Alles, was mit Generatoren gemacht werden kann, lässt sich auch mit "
"klassenbasierten Iteratoren umsetzen, wie im vorherigen Abschnitt "
"beschrieben. Was Generatoren so kompakt macht, ist, dass die Methoden :meth:"
"`~iterator.__iter__` und :meth:`~generator.__next__` automatisch erstellt "
"werden."

#: ../../tutorial/classes.rst:888
msgid ""
"Another key feature is that the local variables and execution state are "
"automatically saved between calls.  This made the function easier to write "
"and much more clear than an approach using instance variables like ``self."
"index`` and ``self.data``."
msgstr ""
"Ein weiteres Schlüsselelement ist, dass die lokalen Variablen und der "
"Ausführungszustand zwischen den Aufrufen automatisch gespeichert werden. "
"Dadurch war die Funktion einfacher zu schreiben und viel übersichtlicher als "
"ein Ansatz mit Instanzvariablen wie ``self.index`` und ``self.data``."

#: ../../tutorial/classes.rst:893
msgid ""
"In addition to automatic method creation and saving program state, when "
"generators terminate, they automatically raise :exc:`StopIteration`. In "
"combination, these features make it easy to create iterators with no more "
"effort than writing a regular function."
msgstr ""
"Neben der automatischen Methodenerstellung und dem Speichern des "
"Programmzustands lösen Generatoren beim Beenden automatisch :exc:"
"`StopIteration` aus. In Kombination machen es diese Funktionen einfach, "
"Iteratoren mit nicht mehr Aufwand als beim Schreiben einer normalen Funktion "
"zu erstellen."

#: ../../tutorial/classes.rst:902
msgid "Generator Expressions"
msgstr "Generator-Ausdrücke"

#: ../../tutorial/classes.rst:904
msgid ""
"Some simple generators can be coded succinctly as expressions using a syntax "
"similar to list comprehensions but with parentheses instead of square "
"brackets. These expressions are designed for situations where the generator "
"is used right away by an enclosing function.  Generator expressions are more "
"compact but less versatile than full generator definitions and tend to be "
"more memory friendly than equivalent list comprehensions."
msgstr ""
"Einige einfache Generatoren können prägnant als Ausdrücke geschrieben "
"werden, wobei eine Syntax ähnlich der von List-Comprehensions verwendet "
"wird, jedoch mit runden statt eckigen Klammern. Diese Ausdrücke sind für "
"Situationen konzipiert, in denen der Generator direkt von einer umgebenden "
"Funktion verwendet wird. Generator-Ausdrücke sind kompakter, aber weniger "
"vielseitig als vollständige Generator-Definitionen und tendenziell "
"speicherschonender als entsprechende List-Comprehensions."

#: ../../tutorial/classes.rst:911
msgid "Examples::"
msgstr "Beispiele::"

#: ../../tutorial/classes.rst:913
msgid ""
">>> sum(i*i for i in range(10))                 # sum of squares\n"
"285\n"
"\n"
">>> xvec = [10, 20, 30]\n"
">>> yvec = [7, 5, 3]\n"
">>> sum(x*y for x,y in zip(xvec, yvec))         # dot product\n"
"260\n"
"\n"
">>> unique_words = set(word for line in page  for word in line.split())\n"
"\n"
">>> valedictorian = max((student.gpa, student.name) for student in "
"graduates)\n"
"\n"
">>> data = 'golf'\n"
">>> list(data[i] for i in range(len(data)-1, -1, -1))\n"
"['f', 'l', 'o', 'g']"
msgstr ""
">>> sum(i*i for i in range(10))                 # Summe der Quadrate\n"
"285\n"
"\n"
">>> xvec = [10, 20, 30]\n"
">>> yvec = [7, 5, 3]\n"
">>> sum(x*y for x,y in zip(xvec, yvec))         # Skalarprodukt\n"
"260\n"
"\n"
">>> unique_words = set(word for line in page  for word in line.split())\n"
"\n"
">>> valedictorian = max((student.gpa, student.name) for student in "
"graduates)\n"
"\n"
">>> data = 'golf'\n"
">>> list(data[i] for i in range(len(data)-1, -1, -1))\n"
"['f', 'l', 'o', 'g']"

#: ../../tutorial/classes.rst:932
msgid "Footnotes"
msgstr "Fußnoten"

#: ../../tutorial/classes.rst:933
msgid ""
"Except for one thing.  Module objects have a secret read-only attribute "
"called :attr:`~object.__dict__` which returns the dictionary used to "
"implement the module's namespace; the name ``__dict__`` is an attribute but "
"not a global name. Obviously, using this violates the abstraction of "
"namespace implementation, and should be restricted to things like post-"
"mortem debuggers."
msgstr ""
"Bis auf eine Sache. Modulobjekte haben ein geheimes schreibgeschütztes "
"Attribut namens :attr:`~object.__dict__`, welches das Dictionary zurückgibt, "
"das zur Implementierung des Namensraums des Moduls verwendet wird; der Name "
"``__dict__`` ist ein Attribut, aber kein globaler Name. Offensichtlich "
"verletzt die Verwendung dieses Attributs die Abstraktion der Namensraum-"
"Implementierung und sollte auf Dinge wie Post-Mortem-Debugger beschränkt "
"werden."

#: ../../tutorial/classes.rst:343
msgid "object"
msgstr "Objekt"

#: ../../tutorial/classes.rst:343
msgid "method"
msgstr "Methode"

#: ../../tutorial/classes.rst:679
msgid "name"
msgstr "Namen"

#: ../../tutorial/classes.rst:679
msgid "mangling"
msgstr "Umbenennung"

#~ msgid ""
#~ "As discussed in :ref:`tut-object`, shared data can have possibly "
#~ "surprising effects with involving :term:`mutable` objects such as lists "
#~ "and dictionaries. For example, the *tricks* list in the following code "
#~ "should not be used as a class variable because just a single list would "
#~ "be shared by all *Dog* instances::"
#~ msgstr ""
#~ "Wie in :ref:`tut-object` besprochen, können geteilte Daten in Verbindung "
#~ "mit :term:`veränderbaren <mutable>` Objekten wie Listen und Wörterbüchern "
#~ "überraschende Effekte haben. Die Liste *tricks* im folgenden Code sollte "
#~ "beispielsweise nicht als Klassenvariable verwendet werden, da nur eine "
#~ "einzige Liste von allen *Dog*-Instanzen geteilt würde::"