# German translation of the Python documentation.

# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

# Swen Bachmann, 2026

#

msgid ""

msgstr ""

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

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

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

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

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

"Language-Team: German (https://github.com/python/python-docs-de)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

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

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

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

#: ../../howto/sorting.rst:4

msgid "Sorting Techniques"

msgstr "Sortiertechniken"

#: ../../howto/sorting.rst:6

msgid ""

"Python lists have a built-in :meth:`list.sort` method that modifies the list "

"in-place. There is also a :func:`sorted` built-in function that builds a "

"new sorted list from an iterable."

msgstr ""

"Python-Listen haben eine integrierte Methode :meth:`list.sort`, die die "

"Liste an ihrem Platz verändert. Es gibt außerdem die integrierte Funktion :"

"func:`sorted`, die aus einem iterierbaren Objekt eine neue sortierte Liste "

"baut."

#: ../../howto/sorting.rst:10

msgid ""

"In this document, we explore the various techniques for sorting data using "

"Python."

msgstr ""

"In diesem Dokument betrachten wir die verschiedenen Techniken, mit denen "

"sich Daten in Python sortieren lassen."

#: ../../howto/sorting.rst:14

msgid "Sorting Basics"

msgstr "Grundlagen des Sortierens"

#: ../../howto/sorting.rst:16

msgid ""

"A simple ascending sort is very easy: just call the :func:`sorted` function. "

"It returns a new sorted list:"

msgstr ""

"Einfach aufsteigend zu sortieren ist sehr leicht: Rufe einfach die Funktion :"

"func:`sorted` auf. Sie gibt eine neue sortierte Liste zurück:"

#: ../../howto/sorting.rst:19

msgid ""

">>> sorted([5, 2, 3, 1, 4])\n"

"[1, 2, 3, 4, 5]"

msgstr ""

">>> sorted([5, 2, 3, 1, 4])\n"

"[1, 2, 3, 4, 5]"

#: ../../howto/sorting.rst:24

msgid ""

"You can also use the :meth:`list.sort` method. It modifies the list in-place "

"(and returns ``None`` to avoid confusion). Usually it's less convenient "

"than :func:`sorted` - but if you don't need the original list, it's slightly "

"more efficient."

msgstr ""

"Du kannst auch die Methode :meth:`list.sort` verwenden. Sie verändert die "

"Liste an ihrem Platz (und gibt ``None`` zurück, um Verwirrung zu vermeiden). "

"Üblicherweise ist sie weniger bequem als :func:`sorted` – wenn du die "

"ursprüngliche Liste aber nicht mehr brauchst, ist sie etwas effizienter."

#: ../../howto/sorting.rst:29

msgid ""

">>> a = [5, 2, 3, 1, 4]\n"

">>> a.sort()\n"

">>> a\n"

"[1, 2, 3, 4, 5]"

msgstr ""

">>> a = [5, 2, 3, 1, 4]\n"

">>> a.sort()\n"

">>> a\n"

"[1, 2, 3, 4, 5]"

#: ../../howto/sorting.rst:36

msgid ""

"Another difference is that the :meth:`list.sort` method is only defined for "

"lists. In contrast, the :func:`sorted` function accepts any iterable."

msgstr ""

"Ein weiterer Unterschied ist, dass die Methode :meth:`list.sort` nur für "

"Listen definiert ist. Die Funktion :func:`sorted` nimmt dagegen jedes "

"iterierbare Objekt an."

#: ../../howto/sorting.rst:39

msgid ""

">>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})\n"

"[1, 2, 3, 4, 5]"

msgstr ""

">>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})\n"

"[1, 2, 3, 4, 5]"

#: ../../howto/sorting.rst:45

msgid "Key Functions"

msgstr "Schlüsselfunktionen"

#: ../../howto/sorting.rst:47

msgid ""

"The :meth:`list.sort` method and the functions :func:`sorted`, :func:`min`, :"

"func:`max`, :func:`heapq.nsmallest`, and :func:`heapq.nlargest` have a *key* "

"parameter to specify a function (or other callable) to be called on each "

"list element prior to making comparisons."

msgstr ""

"Die Methode :meth:`list.sort` und die Funktionen :func:`sorted`, :func:"

"`min`, :func:`max`, :func:`heapq.nsmallest` und :func:`heapq.nlargest` haben "

"einen Parameter *key*, mit dem sich eine Funktion (oder ein anderes "

"aufrufbares Objekt) angeben lässt, die vor den Vergleichen auf jedes "

"Listenelement angewendet wird."

#: ../../howto/sorting.rst:53

msgid ""

"For example, here's a case-insensitive string comparison using :meth:`str."

"casefold`:"

msgstr ""

"Hier zum Beispiel ein Zeichenkettenvergleich ohne Beachtung der Groß- und "

"Kleinschreibung mit :meth:`str.casefold`:"

#: ../../howto/sorting.rst:56

msgid ""

">>> sorted(\"This is a test string from Andrew\".split(), key=str.casefold)\n"

"['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']"

msgstr ""

">>> sorted(\"This is a test string from Andrew\".split(), key=str.casefold)\n"

"['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']"

#: ../../howto/sorting.rst:61

msgid ""

"The value of the *key* parameter should be a function (or other callable) "

"that takes a single argument and returns a key to use for sorting purposes. "

"This technique is fast because the key function is called exactly once for "

"each input record."

msgstr ""

"Der Wert des Parameters *key* sollte eine Funktion (oder ein anderes "

"aufrufbares Objekt) sein, die ein einzelnes Argument nimmt und einen "

"Schlüssel für die Zwecke des Sortierens zurückgibt. Diese Technik ist "

"schnell, weil die Schlüsselfunktion für jeden Eingabedatensatz genau einmal "

"aufgerufen wird."

#: ../../howto/sorting.rst:66

msgid ""

"A common pattern is to sort complex objects using some of the object's "

"indices as keys. For example:"

msgstr ""

"Ein häufiges Muster ist, zusammengesetzte Objekte anhand einiger ihrer "

"Indizes als Schlüssel zu sortieren. Zum Beispiel:"

#: ../../howto/sorting.rst:69

msgid ""

">>> student_tuples = [\n"

"... ('john', 'A', 15),\n"

"... ('jane', 'B', 12),\n"

"... ('dave', 'B', 10),\n"

"... ]\n"

">>> sorted(student_tuples, key=lambda student: student[2]) # sort by age\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

msgstr ""

">>> student_tuples = [\n"

"... ('john', 'A', 15),\n"

"... ('jane', 'B', 12),\n"

"... ('dave', 'B', 10),\n"

"... ]\n"

">>> sorted(student_tuples, key=lambda student: student[2]) # sort by age\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

#: ../../howto/sorting.rst:79

msgid ""

"The same technique works for objects with named attributes. For example:"

msgstr ""

"Dieselbe Technik funktioniert für Objekte mit benannten Attributen. Zum "

"Beispiel:"

#: ../../howto/sorting.rst:81

msgid ""

">>> class Student:\n"

"... def __init__(self, name, grade, age):\n"

"... self.name = name\n"

"... self.grade = grade\n"

"... self.age = age\n"

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

"... return repr((self.name, self.grade, self.age))\n"

"\n"

">>> student_objects = [\n"

"... Student('john', 'A', 15),\n"

"... Student('jane', 'B', 12),\n"

"... Student('dave', 'B', 10),\n"

"... ]\n"

">>> sorted(student_objects, key=lambda student: student.age) # sort by "

"age\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

msgstr ""

">>> class Student:\n"

"... def __init__(self, name, grade, age):\n"

"... self.name = name\n"

"... self.grade = grade\n"

"... self.age = age\n"

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

"... return repr((self.name, self.grade, self.age))\n"

"\n"

">>> student_objects = [\n"

"... Student('john', 'A', 15),\n"

"... Student('jane', 'B', 12),\n"

"... Student('dave', 'B', 10),\n"

"... ]\n"

">>> sorted(student_objects, key=lambda student: student.age) # sort by "

"age\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

#: ../../howto/sorting.rst:99

msgid ""

"Objects with named attributes can be made by a regular class as shown above, "

"or they can be instances of :class:`~dataclasses.dataclass` or a :term:"

"`named tuple`."

msgstr ""

"Objekte mit benannten Attributen lassen sich mit einer gewöhnlichen Klasse "

"erzeugen, wie oben gezeigt, oder sie können Instanzen einer :class:"

"`~dataclasses.dataclass` oder eines :term:`benannten Tupels <named tuple>` "

"sein."

#: ../../howto/sorting.rst:104

msgid "Operator Module Functions and Partial Function Evaluation"

msgstr "Funktionen des operator-Moduls und teilweise Funktionsauswertung"

#: ../../howto/sorting.rst:106

msgid ""

"The :term:`key function` patterns shown above are very common, so Python "

"provides convenience functions to make accessor functions easier and faster. "

"The :mod:`operator` module has :func:`~operator.itemgetter`, :func:"

"`~operator.attrgetter`, and a :func:`~operator.methodcaller` function."

msgstr ""

"Die oben gezeigten Muster für :term:`Schlüsselfunktionen <key function>` "

"sind sehr verbreitet, daher bietet Python Hilfsfunktionen, die "

"Zugriffsfunktionen einfacher und schneller machen. Das Modul :mod:`operator` "

"enthält :func:`~operator.itemgetter`, :func:`~operator.attrgetter` und eine "

"Funktion :func:`~operator.methodcaller`."

#: ../../howto/sorting.rst:111

msgid "Using those functions, the above examples become simpler and faster:"

msgstr ""

"Mit diesen Funktionen werden die obigen Beispiele einfacher und schneller:"

#: ../../howto/sorting.rst:113

msgid ""

">>> from operator import itemgetter, attrgetter\n"

"\n"

">>> sorted(student_tuples, key=itemgetter(2))\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]\n"

"\n"

">>> sorted(student_objects, key=attrgetter('age'))\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

msgstr ""

">>> from operator import itemgetter, attrgetter\n"

"\n"

">>> sorted(student_tuples, key=itemgetter(2))\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]\n"

"\n"

">>> sorted(student_objects, key=attrgetter('age'))\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

#: ../../howto/sorting.rst:123

msgid ""

"The operator module functions allow multiple levels of sorting. For example, "

"to sort by *grade* then by *age*:"

msgstr ""

"Die Funktionen des operator-Moduls erlauben mehrere Sortierebenen. Um zum "

"Beispiel nach *grade* und dann nach *age* zu sortieren:"

#: ../../howto/sorting.rst:126

msgid ""

">>> sorted(student_tuples, key=itemgetter(1,2))\n"

"[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]\n"

"\n"

">>> sorted(student_objects, key=attrgetter('grade', 'age'))\n"

"[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]"

msgstr ""

">>> sorted(student_tuples, key=itemgetter(1,2))\n"

"[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]\n"

"\n"

">>> sorted(student_objects, key=attrgetter('grade', 'age'))\n"

"[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]"

#: ../../howto/sorting.rst:134

msgid ""

"The :mod:`functools` module provides another helpful tool for making key-"

"functions. The :func:`~functools.partial` function can reduce the `arity "

"<https://en.wikipedia.org/wiki/Arity>`_ of a multi-argument function making "

"it suitable for use as a key-function."

msgstr ""

"Das Modul :mod:`functools` bietet ein weiteres hilfreiches Werkzeug, um "

"Schlüsselfunktionen zu bauen. Die Funktion :func:`~functools.partial` kann "

"die `Stelligkeit <https://en.wikipedia.org/wiki/Arity>`_ einer Funktion mit "

"mehreren Argumenten verringern und sie damit als Schlüsselfunktion "

"verwendbar machen."

#: ../../howto/sorting.rst:139

msgid ""

">>> from functools import partial\n"

">>> from unicodedata import normalize\n"

"\n"

">>> names = 'Zoë Åbjørn Núñez Élana Zeke Abe Nubia Eloise'.split()\n"

"\n"

">>> sorted(names, key=partial(normalize, 'NFD'))\n"

"['Abe', 'Åbjørn', 'Eloise', 'Élana', 'Nubia', 'Núñez', 'Zeke', 'Zoë']\n"

"\n"

">>> sorted(names, key=partial(normalize, 'NFC'))\n"

"['Abe', 'Eloise', 'Nubia', 'Núñez', 'Zeke', 'Zoë', 'Åbjørn', 'Élana']"

msgstr ""

">>> from functools import partial\n"

">>> from unicodedata import normalize\n"

"\n"

">>> names = 'Zoë Åbjørn Núñez Élana Zeke Abe Nubia Eloise'.split()\n"

"\n"

">>> sorted(names, key=partial(normalize, 'NFD'))\n"

"['Abe', 'Åbjørn', 'Eloise', 'Élana', 'Nubia', 'Núñez', 'Zeke', 'Zoë']\n"

"\n"

">>> sorted(names, key=partial(normalize, 'NFC'))\n"

"['Abe', 'Eloise', 'Nubia', 'Núñez', 'Zeke', 'Zoë', 'Åbjørn', 'Élana']"

#: ../../howto/sorting.rst:153

msgid "Ascending and Descending"

msgstr "Aufsteigend und absteigend"

#: ../../howto/sorting.rst:155

msgid ""

"Both :meth:`list.sort` and :func:`sorted` accept a *reverse* parameter with "

"a boolean value. This is used to flag descending sorts. For example, to get "

"the student data in reverse *age* order:"

msgstr ""

"Sowohl :meth:`list.sort` als auch :func:`sorted` nehmen einen Parameter "

"*reverse* mit einem booleschen Wert an. Damit wird absteigendes Sortieren "

"gekennzeichnet. Um zum Beispiel die Studentendaten in umgekehrter *age*-"

"Reihenfolge zu bekommen:"

#: ../../howto/sorting.rst:159

msgid ""

">>> sorted(student_tuples, key=itemgetter(2), reverse=True)\n"

"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]\n"

"\n"

">>> sorted(student_objects, key=attrgetter('age'), reverse=True)\n"

"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]"

msgstr ""

">>> sorted(student_tuples, key=itemgetter(2), reverse=True)\n"

"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]\n"

"\n"

">>> sorted(student_objects, key=attrgetter('age'), reverse=True)\n"

"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]"

#: ../../howto/sorting.rst:168

msgid "Sort Stability and Complex Sorts"

msgstr "Sortierstabilität und zusammengesetzte Sortierungen"

#: ../../howto/sorting.rst:170

msgid ""

"Sorts are guaranteed to be `stable <https://en.wikipedia.org/wiki/"

"Sorting_algorithm#Stability>`_\\. That means that when multiple records have "

"the same key, their original order is preserved."

msgstr ""

"Sortierungen sind garantiert `stabil <https://en.wikipedia.org/wiki/"

"Sorting_algorithm#Stability>`_\\. Das heißt, dass die ursprüngliche "

"Reihenfolge erhalten bleibt, wenn mehrere Datensätze denselben Schlüssel "

"haben."

#: ../../howto/sorting.rst:174

msgid ""

">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"

">>> sorted(data, key=itemgetter(0))\n"

"[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]"

msgstr ""

">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"

">>> sorted(data, key=itemgetter(0))\n"

"[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]"

#: ../../howto/sorting.rst:180

msgid ""

"Notice how the two records for *blue* retain their original order so that "

"``('blue', 1)`` is guaranteed to precede ``('blue', 2)``."

msgstr ""

"Beachte, wie die beiden Datensätze für *blue* ihre ursprüngliche Reihenfolge "

"behalten, sodass ``('blue', 1)`` garantiert vor ``('blue', 2)`` steht."

#: ../../howto/sorting.rst:183

msgid ""

"This wonderful property lets you build complex sorts in a series of sorting "

"steps. For example, to sort the student data by descending *grade* and then "

"ascending *age*, do the *age* sort first and then sort again using *grade*:"

msgstr ""

"Diese wunderbare Eigenschaft erlaubt es dir, zusammengesetzte Sortierungen "

"in einer Folge von Sortierschritten aufzubauen. Um zum Beispiel die "

"Studentendaten nach absteigendem *grade* und dann nach aufsteigendem *age* "

"zu sortieren, sortiere zuerst nach *age* und dann erneut nach *grade*:"

#: ../../howto/sorting.rst:187

msgid ""

">>> s = sorted(student_objects, key=attrgetter('age')) # sort on "

"secondary key\n"

">>> sorted(s, key=attrgetter('grade'), reverse=True) # now sort on "

"primary key, descending\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

msgstr ""

">>> s = sorted(student_objects, key=attrgetter('age')) # sort on "

"secondary key\n"

">>> sorted(s, key=attrgetter('grade'), reverse=True) # now sort on "

"primary key, descending\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

#: ../../howto/sorting.rst:193

msgid ""

"This can be abstracted out into a wrapper function that can take a list and "

"tuples of field and order to sort them on multiple passes."

msgstr ""

"Das lässt sich in eine Hüllfunktion abstrahieren, die eine Liste und Tupel "

"aus Feld und Richtung annimmt, um in mehreren Durchgängen danach zu "

"sortieren."

#: ../../howto/sorting.rst:196

msgid ""

">>> def multisort(xs, specs):\n"

"... for key, reverse in reversed(specs):\n"

"... xs.sort(key=attrgetter(key), reverse=reverse)\n"

"... return xs\n"

"\n"

">>> multisort(list(student_objects), (('grade', True), ('age', False)))\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

msgstr ""

">>> def multisort(xs, specs):\n"

"... for key, reverse in reversed(specs):\n"

"... xs.sort(key=attrgetter(key), reverse=reverse)\n"

"... return xs\n"

"\n"

">>> multisort(list(student_objects), (('grade', True), ('age', False)))\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

#: ../../howto/sorting.rst:206

msgid ""

"The `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ algorithm used in "

"Python does multiple sorts efficiently because it can take advantage of any "

"ordering already present in a dataset."

msgstr ""

"Der in Python verwendete Algorithmus `Timsort <https://en.wikipedia.org/wiki/"

"Timsort>`_ führt mehrere Sortierungen effizient aus, weil er jede in einem "

"Datensatz bereits vorhandene Ordnung ausnutzen kann."

#: ../../howto/sorting.rst:211

msgid "Decorate-Sort-Undecorate"

msgstr "Decorate-Sort-Undecorate"

#: ../../howto/sorting.rst:213

msgid "This idiom is called Decorate-Sort-Undecorate after its three steps:"

msgstr ""

"Dieses Idiom heißt nach seinen drei Schritten Decorate-Sort-Undecorate:"

#: ../../howto/sorting.rst:215

msgid ""

"First, the initial list is decorated with new values that control the sort "

"order."

msgstr ""

"Zuerst wird die Ausgangsliste mit neuen Werten dekoriert, die die "

"Sortierreihenfolge bestimmen."

#: ../../howto/sorting.rst:217

msgid "Second, the decorated list is sorted."

msgstr "Danach wird die dekorierte Liste sortiert."

#: ../../howto/sorting.rst:219

msgid ""

"Finally, the decorations are removed, creating a list that contains only the "

"initial values in the new order."

msgstr ""

"Zuletzt werden die Dekorationen entfernt. So entsteht eine Liste, die nur "

"die Ausgangswerte in der neuen Reihenfolge enthält."

#: ../../howto/sorting.rst:222

msgid ""

"For example, to sort the student data by *grade* using the DSU approach:"

msgstr ""

"Um zum Beispiel die Studentendaten mit dem DSU-Ansatz nach *grade* zu "

"sortieren:"

#: ../../howto/sorting.rst:224

msgid ""

">>> decorated = [(student.grade, i, student) for i, student in "

"enumerate(student_objects)]\n"

">>> decorated.sort()\n"

">>> [student for grade, i, student in decorated] # undecorate\n"

"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]"

msgstr ""

">>> decorated = [(student.grade, i, student) for i, student in "

"enumerate(student_objects)]\n"

">>> decorated.sort()\n"

">>> [student for grade, i, student in decorated] # undecorate\n"

"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]"

#: ../../howto/sorting.rst:231

msgid ""

"This idiom works because tuples are compared lexicographically; the first "

"items are compared; if they are the same then the second items are compared, "

"and so on."

msgstr ""

"Dieses Idiom funktioniert, weil Tupel lexikografisch verglichen werden: "

"Zuerst werden die ersten Elemente verglichen. Sind sie gleich, werden die "

"zweiten Elemente verglichen, und so weiter."

#: ../../howto/sorting.rst:235

msgid ""

"It is not strictly necessary in all cases to include the index *i* in the "

"decorated list, but including it gives two benefits:"

msgstr ""

"Es ist nicht in allen Fällen zwingend nötig, den Index *i* in die dekorierte "

"Liste aufzunehmen, aber es bringt zwei Vorteile:"

#: ../../howto/sorting.rst:238

msgid ""

"The sort is stable -- if two items have the same key, their order will be "

"preserved in the sorted list."

msgstr ""

"Die Sortierung ist stabil – haben zwei Elemente denselben Schlüssel, bleibt "

"ihre Reihenfolge in der sortierten Liste erhalten."

#: ../../howto/sorting.rst:241

msgid ""

"The original items do not have to be comparable because the ordering of the "

"decorated tuples will be determined by at most the first two items. So for "

"example the original list could contain complex numbers which cannot be "

"sorted directly."

msgstr ""

"Die ursprünglichen Elemente müssen nicht vergleichbar sein, weil die "

"Reihenfolge der dekorierten Tupel von höchstens den ersten zwei Elementen "

"bestimmt wird. So könnte die ursprüngliche Liste zum Beispiel komplexe "

"Zahlen enthalten, die sich nicht direkt sortieren lassen."

#: ../../howto/sorting.rst:246

msgid ""

"Another name for this idiom is `Schwartzian transform <https://en.wikipedia."

"org/wiki/Schwartzian_transform>`_\\, after Randal L. Schwartz, who "

"popularized it among Perl programmers."

msgstr ""

"Ein anderer Name für dieses Idiom ist `Schwartzian transform <https://en."

"wikipedia.org/wiki/Schwartzian_transform>`_\\, nach Randal L. Schwartz, der "

"es unter Perl-Programmierern bekannt gemacht hat."

#: ../../howto/sorting.rst:250

msgid ""

"Now that Python sorting provides key-functions, this technique is not often "

"needed."

msgstr ""

"Da Python beim Sortieren inzwischen Schlüsselfunktionen bietet, braucht man "

"diese Technik nicht mehr oft."

#: ../../howto/sorting.rst:253

msgid "Comparison Functions"

msgstr "Vergleichsfunktionen"

#: ../../howto/sorting.rst:255

msgid ""

"Unlike key functions that return an absolute value for sorting, a comparison "

"function computes the relative ordering for two inputs."

msgstr ""

"Anders als Schlüsselfunktionen, die zum Sortieren einen absoluten Wert "

"zurückgeben, berechnet eine Vergleichsfunktion die relative Ordnung zweier "

"Eingaben."

#: ../../howto/sorting.rst:258

msgid ""

"For example, a `balance scale <https://upload.wikimedia.org/wikipedia/"

"commons/1/17/Balance_à_tabac_1850.JPG>`_ compares two samples giving a "

"relative ordering: lighter, equal, or heavier. Likewise, a comparison "

"function such as ``cmp(a, b)`` will return a negative value for less-than, "

"zero if the inputs are equal, or a positive value for greater-than."

msgstr ""

"Eine `Balkenwaage <https://upload.wikimedia.org/wikipedia/commons/1/17/"

"Balance_à_tabac_1850.JPG>`_ vergleicht zum Beispiel zwei Proben und liefert "

"eine relative Ordnung: leichter, gleich oder schwerer. Ebenso gibt eine "

"Vergleichsfunktion wie ``cmp(a, b)`` einen negativen Wert für „kleiner als“, "

"null bei gleichen Eingaben oder einen positiven Wert für „größer als“ zurück."

#: ../../howto/sorting.rst:265

msgid ""

"It is common to encounter comparison functions when translating algorithms "

"from other languages. Also, some libraries provide comparison functions as "

"part of their API. For example, :func:`locale.strcoll` is a comparison "

"function."

msgstr ""

"Vergleichsfunktionen trifft man häufig, wenn man Algorithmen aus anderen "

"Sprachen überträgt. Außerdem bieten manche Bibliotheken Vergleichsfunktionen "

"als Teil ihrer API an. :func:`locale.strcoll` ist zum Beispiel eine "

"Vergleichsfunktion."

#: ../../howto/sorting.rst:269

msgid ""

"To accommodate those situations, Python provides :class:`functools."

"cmp_to_key` to wrap the comparison function to make it usable as a key "

"function::"

msgstr ""

"Für diese Fälle bietet Python :class:`functools.cmp_to_key`, um die "

"Vergleichsfunktion so zu umhüllen, dass sie als Schlüsselfunktion verwendbar "

"wird::"

#: ../../howto/sorting.rst:273

msgid "sorted(words, key=cmp_to_key(strcoll)) # locale-aware sort order"

msgstr "sorted(words, key=cmp_to_key(strcoll)) # locale-aware sort order"

#: ../../howto/sorting.rst:276

msgid "Strategies For Unorderable Types and Values"

msgstr "Strategien für nicht ordenbare Typen und Werte"

#: ../../howto/sorting.rst:278

msgid ""

"A number of type and value issues can arise when sorting. Here are some "

"strategies that can help:"

msgstr ""

"Beim Sortieren kann es zu einer Reihe von Typ- und Wertproblemen kommen. "

"Hier einige Strategien, die helfen können:"

#: ../../howto/sorting.rst:281

msgid "Convert non-comparable input types to strings prior to sorting:"

msgstr ""

"Wandle nicht vergleichbare Eingabetypen vor dem Sortieren in Zeichenketten "

"um:"

#: ../../howto/sorting.rst:283

msgid ""

">>> data = ['twelve', '11', 10]\n"

">>> sorted(map(str, data))\n"

"['10', '11', 'twelve']"

msgstr ""

">>> data = ['twelve', '11', 10]\n"

">>> sorted(map(str, data))\n"

"['10', '11', 'twelve']"

#: ../../howto/sorting.rst:289

msgid ""

"This is needed because most cross-type comparisons raise a :exc:`TypeError`."

msgstr ""

"Das ist nötig, weil die meisten Vergleiche über Typgrenzen hinweg einen :exc:"

"`TypeError` auslösen."

#: ../../howto/sorting.rst:292

msgid "Remove special values prior to sorting:"

msgstr "Entferne besondere Werte vor dem Sortieren:"

#: ../../howto/sorting.rst:294

msgid ""

">>> from math import isnan\n"

">>> from itertools import filterfalse\n"

">>> data = [3.3, float('nan'), 1.1, 2.2]\n"

">>> sorted(filterfalse(isnan, data))\n"

"[1.1, 2.2, 3.3]"

msgstr ""

">>> from math import isnan\n"

">>> from itertools import filterfalse\n"

">>> data = [3.3, float('nan'), 1.1, 2.2]\n"

">>> sorted(filterfalse(isnan, data))\n"

"[1.1, 2.2, 3.3]"

#: ../../howto/sorting.rst:302

msgid ""

"This is needed because the `IEEE-754 standard <https://en.wikipedia.org/wiki/"

"IEEE_754>`_ specifies that, \"Every NaN shall compare unordered with "

"everything, including itself.\""

msgstr ""

"Das ist nötig, weil der `IEEE-754-Standard <https://en.wikipedia.org/wiki/"

"IEEE_754>`_ festlegt: „Every NaN shall compare unordered with everything, "

"including itself.“"

#: ../../howto/sorting.rst:306

msgid "Likewise, ``None`` can be stripped from datasets as well:"

msgstr "Ebenso lässt sich ``None`` aus Datensätzen entfernen:"

#: ../../howto/sorting.rst:308

msgid ""

">>> data = [3.3, None, 1.1, 2.2]\n"

">>> sorted(x for x in data if x is not None)\n"

"[1.1, 2.2, 3.3]"

msgstr ""

">>> data = [3.3, None, 1.1, 2.2]\n"

">>> sorted(x for x in data if x is not None)\n"

"[1.1, 2.2, 3.3]"

#: ../../howto/sorting.rst:314

msgid "This is needed because ``None`` is not comparable to other types."

msgstr "Das ist nötig, weil ``None`` nicht mit anderen Typen vergleichbar ist."

#: ../../howto/sorting.rst:316

msgid "Convert mapping types into sorted item lists before sorting:"

msgstr ""

"Wandle Abbildungstypen vor dem Sortieren in sortierte Elementlisten um:"

#: ../../howto/sorting.rst:318

msgid ""

">>> data = [{'a': 1}, {'b': 2}]\n"

">>> sorted(data, key=lambda d: sorted(d.items()))\n"

"[{'a': 1}, {'b': 2}]"

msgstr ""

">>> data = [{'a': 1}, {'b': 2}]\n"

">>> sorted(data, key=lambda d: sorted(d.items()))\n"

"[{'a': 1}, {'b': 2}]"

#: ../../howto/sorting.rst:324

msgid ""

"This is needed because dict-to-dict comparisons raise a :exc:`TypeError`."

msgstr ""

"Das ist nötig, weil Vergleiche zwischen Dicts einen :exc:`TypeError` "

"auslösen."

#: ../../howto/sorting.rst:327

msgid "Convert set types into sorted lists before sorting:"

msgstr "Wandle Mengentypen vor dem Sortieren in sortierte Listen um:"

#: ../../howto/sorting.rst:329

msgid ""

">>> data = [{'a', 'b', 'c'}, {'b', 'c', 'd'}]\n"

">>> sorted(map(sorted, data))\n"

"[['a', 'b', 'c'], ['b', 'c', 'd']]"

msgstr ""

">>> data = [{'a', 'b', 'c'}, {'b', 'c', 'd'}]\n"

">>> sorted(map(sorted, data))\n"

"[['a', 'b', 'c'], ['b', 'c', 'd']]"

#: ../../howto/sorting.rst:335

msgid ""

"This is needed because the elements contained in set types do not have a "

"deterministic order. For example, ``list({'a', 'b'})`` may produce either "

"``['a', 'b']`` or ``['b', 'a']``."

msgstr ""

"Das ist nötig, weil die in Mengentypen enthaltenen Elemente keine "

"festgelegte Reihenfolge haben. So kann ``list({'a', 'b'})`` zum Beispiel "

"entweder ``['a', 'b']`` oder ``['b', 'a']`` ergeben."

#: ../../howto/sorting.rst:340

msgid "Odds and Ends"

msgstr "Verschiedenes"

#: ../../howto/sorting.rst:342

msgid ""

"For locale aware sorting, use :func:`locale.strxfrm` for a key function or :"

"func:`locale.strcoll` for a comparison function. This is necessary because "

"\"alphabetical\" sort orderings can vary across cultures even if the "

"underlying alphabet is the same."

msgstr ""

"Für ein Sortieren, das das Gebietsschema beachtet, verwende :func:`locale."

"strxfrm` als Schlüsselfunktion oder :func:`locale.strcoll` als "

"Vergleichsfunktion. Das ist nötig, weil „alphabetische“ Sortierreihenfolgen "

"sich zwischen Kulturen unterscheiden können, selbst wenn das zugrunde "

"liegende Alphabet dasselbe ist."

#: ../../howto/sorting.rst:347

msgid ""

"The *reverse* parameter still maintains sort stability (so that records with "

"equal keys retain the original order). Interestingly, that effect can be "

"simulated without the parameter by using the builtin :func:`reversed` "

"function twice:"

msgstr ""

"Der Parameter *reverse* erhält die Sortierstabilität (sodass Datensätze mit "

"gleichen Schlüsseln ihre ursprüngliche Reihenfolge behalten). "

"Interessanterweise lässt sich dieser Effekt auch ohne den Parameter "

"nachbilden, indem man die integrierte Funktion :func:`reversed` zweimal "

"verwendet:"

#: ../../howto/sorting.rst:352

msgid ""

">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"

">>> standard_way = sorted(data, key=itemgetter(0), reverse=True)\n"

">>> double_reversed = list(reversed(sorted(reversed(data), "

"key=itemgetter(0))))\n"

">>> assert standard_way == double_reversed\n"

">>> standard_way\n"

"[('red', 1), ('red', 2), ('blue', 1), ('blue', 2)]"

msgstr ""

">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"

">>> standard_way = sorted(data, key=itemgetter(0), reverse=True)\n"

">>> double_reversed = list(reversed(sorted(reversed(data), "

"key=itemgetter(0))))\n"

">>> assert standard_way == double_reversed\n"

">>> standard_way\n"

"[('red', 1), ('red', 2), ('blue', 1), ('blue', 2)]"

#: ../../howto/sorting.rst:361

msgid ""

"The sort routines use ``<`` when making comparisons between two objects. So, "

"it is easy to add a standard sort order to a class by defining an :meth:"

"`~object.__lt__` method:"

msgstr ""

"Die Sortierroutinen verwenden beim Vergleich zweier Objekte ``<``. Eine "

"Standard-Sortierreihenfolge lässt sich einer Klasse daher leicht hinzufügen, "

"indem man eine Methode :meth:`~object.__lt__` definiert:"

#: ../../howto/sorting.rst:365

msgid ""

">>> Student.__lt__ = lambda self, other: self.age < other.age\n"

">>> sorted(student_objects)\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

msgstr ""

">>> Student.__lt__ = lambda self, other: self.age < other.age\n"

">>> sorted(student_objects)\n"

"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"

#: ../../howto/sorting.rst:371

msgid ""

"However, note that ``<`` can fall back to using :meth:`~object.__gt__` if :"

"meth:`~object.__lt__` is not implemented (see :func:`object.__lt__` for "

"details on the mechanics). To avoid surprises, :pep:`8` recommends that all "

"six comparison methods be implemented. The :deco:`~functools.total_ordering` "

"decorator is provided to make that task easier."

msgstr ""

"Beachte aber, dass ``<`` auf :meth:`~object.__gt__` zurückfallen kann, wenn :"

"meth:`~object.__lt__` nicht implementiert ist (Einzelheiten zur Mechanik "

"stehen bei :func:`object.__lt__`). Um Überraschungen zu vermeiden, "

"empfiehlt :pep:`8`, alle sechs Vergleichsmethoden zu implementieren. Der "

"Decorator :deco:`~functools.total_ordering` ist dafür da, diese Aufgabe zu "

"erleichtern."

#: ../../howto/sorting.rst:378

msgid ""

"Key functions need not depend directly on the objects being sorted. A key "

"function can also access external resources. For instance, if the student "

"grades are stored in a dictionary, they can be used to sort a separate list "

"of student names:"

msgstr ""

"Schlüsselfunktionen müssen nicht unmittelbar von den sortierten Objekten "

"abhängen. Eine Schlüsselfunktion kann auch auf äußere Quellen zugreifen. "

"Sind die Noten der Studenten zum Beispiel in einem Wörterbuch gespeichert, "

"lassen sie sich verwenden, um eine separate Liste von Studentennamen zu "

"sortieren:"

#: ../../howto/sorting.rst:383

msgid ""

">>> students = ['dave', 'john', 'jane']\n"

">>> newgrades = {'john': 'F', 'jane':'A', 'dave': 'C'}\n"

">>> sorted(students, key=newgrades.__getitem__)\n"

"['jane', 'dave', 'john']"

msgstr ""

">>> students = ['dave', 'john', 'jane']\n"

">>> newgrades = {'john': 'F', 'jane':'A', 'dave': 'C'}\n"

">>> sorted(students, key=newgrades.__getitem__)\n"

"['jane', 'dave', 'john']"

#: ../../howto/sorting.rst:391

msgid "Partial Sorts"

msgstr "Teilweises Sortieren"

#: ../../howto/sorting.rst:393

msgid ""

"Some applications require only some of the data to be ordered. The standard "

"library provides several tools that do less work than a full sort:"

msgstr ""

"Manche Anwendungen brauchen nur einen Teil der Daten geordnet. Die "

"Standardbibliothek bietet mehrere Werkzeuge, die weniger Arbeit leisten als "

"eine vollständige Sortierung:"

#: ../../howto/sorting.rst:396

msgid ""

":func:`min` and :func:`max` return the smallest and largest values, "

"respectively. These functions make a single pass over the input data and "

"require almost no auxiliary memory."

msgstr ""

":func:`min` und :func:`max` geben den kleinsten beziehungsweise den größten "

"Wert zurück. Diese Funktionen gehen die Eingabedaten in einem einzigen "

"Durchgang durch und brauchen so gut wie keinen Hilfsspeicher."

#: ../../howto/sorting.rst:400

msgid ""

":func:`heapq.nsmallest` and :func:`heapq.nlargest` return the *n* smallest "

"and largest values, respectively. These functions make a single pass over "

"the data keeping only *n* elements in memory at a time. For values of *n* "

"that are small relative to the number of inputs, these functions make far "

"fewer comparisons than a full sort."

msgstr ""

":func:`heapq.nsmallest` und :func:`heapq.nlargest` geben die *n* kleinsten "

"beziehungsweise die *n* größten Werte zurück. Diese Funktionen gehen die "

"Daten in einem einzigen Durchgang durch und halten dabei immer nur *n* "

"Elemente im Speicher. Für Werte von *n*, die im Verhältnis zur Anzahl der "

"Eingaben klein sind, führen diese Funktionen weit weniger Vergleiche durch "

"als eine vollständige Sortierung."

#: ../../howto/sorting.rst:406

msgid ""

":func:`heapq.heappush` and :func:`heapq.heappop` create and maintain a "

"partially sorted arrangement of data that keeps the smallest element at "

"position ``0``. These functions are suitable for implementing priority "

"queues which are commonly used for task scheduling."

msgstr ""

":func:`heapq.heappush` und :func:`heapq.heappop` erzeugen und pflegen eine "

"teilweise sortierte Anordnung der Daten, die das kleinste Element an "

"Position ``0`` hält. Diese Funktionen eignen sich dafür, "

"Prioritätswarteschlangen umzusetzen, wie sie häufig für die Ablaufplanung "

"von Aufgaben verwendet werden."