GitHub Viewer

# 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 , 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 \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" " \n" " .\n" " .\n" " .\n" " " msgstr "" "class ClassName:\n" " \n" " .\n" " .\n" " .\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 ` 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" " \n" " .\n" " .\n" " .\n" " " msgstr "" "class DerivedClassName(BaseClassName):\n" " \n" " .\n" " .\n" " .\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" " \n" " .\n" " .\n" " .\n" " " msgstr "" "class DerivedClassName(Base1, Base2, Base3):\n" " \n" " .\n" " .\n" " .\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 ` for " "details and special cases." msgstr "" "Die :ref:`Spezifikationen zur Namensumbenennung privater Elemente ` 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 ` have attributes, too: :" "attr:`m.__self__ ` is the instance object with the method :" "meth:`!m`, and :attr:`m.__func__ ` is the :ref:`function " "object ` corresponding to the method." msgstr "" ":ref:`Instanzmethoden-Objekte ` besitzen ebenfalls " "Attribute: :attr:`m.__self__ ` ist das Instanzobjekt mit " "der Methode :meth:`!m`, und :attr:`m.__func__ ` ist das der " "Methode entsprechende :ref:`Funktionsobjekt `." #: ../../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" "\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 \"\", line 1, in \n" " next(it)\n" "StopIteration" msgstr "" ">>> s = 'abc'\n" ">>> it = iter(s)\n" ">>> it\n" "\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 \"\", line 1, in \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" "\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" "\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 ` 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 ` 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 ` 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::"