# 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 <[email protected]>, 2026.

#

# Translators:

# python-doc bot, 2025

#

msgid ""

msgstr ""

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

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

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

"PO-Revision-Date: 2026-08-10 00:02+0000\n"

"Last-Translator: Swen Bachmann <[email protected]>\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 eingebaute Typen als Basisklassen für Erweiterungen durch den "

"Benutzer verwendet werden. Zudem können, wie in C++, die meisten eingebauten "

"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 "

"eingebauten Namen (die Funktionen wie :func:`abs` und eingebaute 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 eingebauten 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 "

"eingebauten 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 eingebauten 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