# German translation of the Python documentation.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Rafael Fontenelle <rffontenelle@gmail.com>, 2026

# Jyst Breisgau, 2026

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-09-28 03:11+0000\n"

"PO-Revision-Date: 2026-05-08 17:16+0000\n"

"Last-Translator: Jyst Breisgau, 2026\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"

#: ../../c-api/arg.rst:6

msgid "Parsing arguments and building values"

msgstr "Argumente auswerten und Werte bilden"

#: ../../c-api/arg.rst:8

msgid ""

"These functions are useful when creating your own extension functions and "

"methods. Additional information and examples are available in :ref:"

"`extending-index`."

msgstr ""

"Diese Funktionen sind nützlich, wenn Sie eigene Erweiterungsfunktionen und -"

"methoden erstellen. Weitere Informationen und Beispiele finden Sie unter :"

"ref:`extending-index`."

#: ../../c-api/arg.rst:12

msgid ""

"The first three of these functions described, :c:func:`PyArg_ParseTuple`, :c:"

"func:`PyArg_ParseTupleAndKeywords`, and :c:func:`PyArg_Parse`, all use "

"*format strings* which are used to tell the function about the expected "

"arguments. The format strings use the same syntax for each of these "

"functions."

msgstr ""

"Die ersten drei der beschriebenen Funktionen – :c:func:`PyArg_ParseTuple`, :"

"c:func:`PyArg_ParseTupleAndKeywords` und :c:func:`PyArg_Parse` – verwenden "

"alle *Formatzeichenfolgen*, mit denen der Funktion die erwarteten Argumente "

"mitgeteilt werden. Die Formatzeichenfolgen haben bei allen diesen Funktionen "

"dieselbe Syntax."

#: ../../c-api/arg.rst:19

msgid "Parsing arguments"

msgstr "Argumente auswerten"

#: ../../c-api/arg.rst:21

msgid ""

"A format string consists of zero or more \"format units.\" A format unit "

"describes one Python object; it is usually a single character or a "

"parenthesized sequence of format units. With a few exceptions, a format "

"unit that is not a parenthesized sequence normally corresponds to a single "

"address argument to these functions. In the following description, the "

"quoted form is the format unit; the entry in (round) parentheses is the "

"Python object type that matches the format unit; and the entry in [square] "

"brackets is the type of the C variable(s) whose address should be passed."

msgstr ""

"Eine Formatzeichenfolge besteht aus null oder mehr „Formateinheiten“. Eine "

"Formateinheit beschreibt ein Python-Objekt; dabei handelt es sich in der "

"Regel um ein einzelnes Zeichen oder eine in Klammern gesetzte Folge von "

"Formateinheiten. Mit wenigen Ausnahmen entspricht eine Formateinheit, die "

"keine in Klammern gesetzte Folge ist, normalerweise einem einzelnen "

"Adressargument dieser Funktionen. In der folgenden Beschreibung ist die in "

"Anführungszeichen gesetzte Form die Formateinheit; der Eintrag in (runden) "

"Klammern ist der Python-Objekttyp, der der Formateinheit entspricht; und der "

"Eintrag in [eckigen] Klammern ist der Typ der C-Variablen, deren Adresse "

"übergeben werden soll."

#: ../../c-api/arg.rst:33

msgid "Strings and buffers"

msgstr "Zeichenketten und Puffer"

#: ../../c-api/arg.rst:37

msgid ""

"On Python 3.12 and older, the macro :c:macro:`!PY_SSIZE_T_CLEAN` must be "

"defined before including :file:`Python.h` to use all ``#`` variants of "

"formats (``s#``, ``y#``, etc.) explained below. This is not necessary on "

"Python 3.13 and later."

msgstr ""

"Unter Python 3.12 und älteren Versionen muss das Makro „ :c:macro:`!"

"PY_SSIZE_T_CLEAN` “ definiert werden, bevor „ :file:`Python.h` “ eingebunden "

"wird, um alle unten erläuterten „ ``#`` “-Varianten der Formate (``s#``, "

"``y#`` usw.) nutzen zu können. Unter Python 3.13 und späteren Versionen ist "

"dies nicht erforderlich."

#: ../../c-api/arg.rst:42

msgid ""

"These formats allow accessing an object as a contiguous chunk of memory. You "

"don't have to provide raw storage for the returned unicode or bytes area."

msgstr ""

"Diese Formate ermöglichen den Zugriff auf ein Objekt als zusammenhängenden "

"Speicherblock. Sie müssen keinen Rohspeicher für den zurückgegebenen "

"Unicode- oder Byte-Bereich bereitstellen."

#: ../../c-api/arg.rst:46

msgid "Unless otherwise stated, buffers are not NUL-terminated."

msgstr "So lange nicht anders festgelegt, sind Buffer nicht NUL-terminiert."

#: ../../c-api/arg.rst:48

msgid "There are three ways strings and buffers can be converted to C:"

msgstr ""

"Es gibt drei Möglichkeiten, Zeichenketten und Puffer in C zu konvertieren:"

#: ../../c-api/arg.rst:50

msgid ""

"Formats such as ``y*`` and ``s*`` fill a :c:type:`Py_buffer` structure. This "

"locks the underlying buffer so that the caller can subsequently use the "

"buffer even inside a :c:type:`Py_BEGIN_ALLOW_THREADS` block without the risk "

"of mutable data being resized or destroyed. As a result, **you have to "

"call** :c:func:`PyBuffer_Release` after you have finished processing the "

"data (or in any early abort case)."

msgstr ""

"Formate wie „ ``y*`` “ und „ ``s*`` “ füllen eine „ :c:type:`Py_buffer` “-"

"Struktur. Dadurch wird der zugrunde liegende Puffer gesperrt, sodass der "

"Aufrufer den Puffer anschließend sogar innerhalb eines „ :c:type:"

"`Py_BEGIN_ALLOW_THREADS` “-Blocks verwenden kann, ohne dass die Gefahr "

"besteht, dass veränderbare Daten in ihrer Größe angepasst oder zerstört "

"werden. Daher **müssen Sie** „ :c:func:`PyBuffer_Release` “ aufrufen, "

"nachdem Sie die Verarbeitung der Daten abgeschlossen haben (oder im Falle "

"eines vorzeitigen Abbruchs)."

#: ../../c-api/arg.rst:57

msgid ""

"The ``es``, ``es#``, ``et`` and ``et#`` formats allocate the result buffer. "

"**You have to call** :c:func:`PyMem_Free` after you have finished processing "

"the data (or in any early abort case)."

msgstr ""

"Die Formate „ ``es`` “, „ ``es#`` “, „ ``et`` “ und „ ``et#`` “ reservieren "

"den Ergebnispuffer. **Sie müssen** „ :c:func:`PyMem_Free` “ aufrufen, "

"nachdem Sie die Datenverarbeitung abgeschlossen haben (oder im Falle eines "

"vorzeitigen Abbruchs)."

#: ../../c-api/arg.rst:63

msgid ""

"Other formats take a :class:`str` or a read-only :term:`bytes-like object`, "

"such as :class:`bytes`, and provide a ``const char *`` pointer to its "

"buffer. In this case the buffer is \"borrowed\": it is managed by the "

"corresponding Python object, and shares the lifetime of this object. You "

"won't have to release any memory yourself."

msgstr ""

"Andere Formate nehmen ein :class:`str` oder ein schreibgeschütztes :term:"

"`bytes-ähnliches Objekt <bytes-like object>` entgegen, wie beispielsweise :"

"class:`bytes`, und stellen einen ``const char *``-Zeiger auf dessen Puffer "

"bereit. In diesem Fall wird der Puffer „ausgeliehen“: Er wird vom "

"entsprechenden Python-Objekt verwaltet und hat dieselbe Lebensdauer wie "

"dieses Objekt. Sie müssen selbst keinen Speicher freigeben."

#: ../../c-api/arg.rst:70

msgid ""

"To ensure that the underlying buffer may be safely borrowed, the object's :c:"

"member:`PyBufferProcs.bf_releasebuffer` field must be ``NULL``. This "

"disallows common mutable objects such as :class:`bytearray`, but also some "

"read-only objects such as :class:`memoryview` of :class:`bytes`."

msgstr ""

"Um sicherzustellen, dass der zugrunde liegende Puffer sicher ausgeliehen "

"werden kann, muss das Feld „ :c:member:`PyBufferProcs.bf_releasebuffer` “ "

"des Objekts auf „ ``NULL`` “ gesetzt sein. Dadurch werden gängige "

"veränderbare Objekte wie :class:`bytearray` ausgeschlossen, aber auch einige "

"schreibgeschützte Objekte wie :class:`memoryview` oder :class:`bytes`."

#: ../../c-api/arg.rst:76

msgid ""

"Besides this ``bf_releasebuffer`` requirement, there is no check to verify "

"whether the input object is immutable (e.g. whether it would honor a request "

"for a writable buffer, or whether another thread can mutate the data)."

msgstr ""

"Abgesehen von dieser Anforderung unter ``bf_releasebuffer`` gibt es keine "

"Überprüfung, ob das Eingabeobjekt unveränderlich ist (z. B. ob es eine "

"Anforderung nach einem beschreibbaren Puffer erfüllen würde oder ob ein "

"anderer Thread die Daten verändern kann)."

#: ../../c-api/arg.rst:80

msgid "``s`` (:class:`str`) [const char \\*]"

msgstr "``s`` (:class:`str`) [const char \\*]"

#: ../../c-api/arg.rst:81

msgid ""

"Convert a Unicode object to a C pointer to a character string. A pointer to "

"an existing string is stored in the character pointer variable whose address "

"you pass. The C string is NUL-terminated. The Python string must not "

"contain embedded null code points; if it does, a :exc:`ValueError` exception "

"is raised. Unicode objects are converted to C strings using ``'utf-8'`` "

"encoding. If this conversion fails, a :exc:`UnicodeError` is raised."

msgstr ""

"Konvertiert ein Unicode-Objekt in einen C-Zeiger auf eine Zeichenkette. Ein "

"Zeiger auf eine vorhandene Zeichenkette wird in der Zeichenzeiger-Variablen "

"gespeichert, deren Adresse Sie übergeben. Die C-Zeichenkette ist NUL-"

"terminiert. Die Python-Zeichenkette darf keine eingebetteten Null-Codepunkte "

"enthalten; ist dies der Fall, wird eine Ausnahme vom Typ „ :exc:`ValueError` "

"“ ausgelöst. Unicode-Objekte werden unter Verwendung der „ ``'utf-8'`` “-"

"Kodierung in C-Zeichenketten konvertiert. Wenn diese Konvertierung "

"fehlschlägt, wird eine Ausnahme vom Typ „ :exc:`UnicodeError` “ ausgelöst."

#: ../../c-api/arg.rst:90

msgid ""

"This format does not accept :term:`bytes-like objects <bytes-like object>`. "

"If you want to accept filesystem paths and convert them to C character "

"strings, it is preferable to use the ``O&`` format with :c:func:"

"`PyUnicode_FSConverter` as *converter*."

msgstr ""

"Dieses Format akzeptiert keine :term:`bytes-ähnlichen Objekte <bytes-like "

"object>`. Wenn Sie Dateisystempfade akzeptieren und diese in C-"

"Zeichenketten konvertieren möchten, sollten Sie vorzugsweise das Format "

"„ ``O&`` “ mit „ :c:func:`PyUnicode_FSConverter` “ als *Konverter* verwenden."

#: ../../c-api/arg.rst:96

msgid ""

"Previously, :exc:`TypeError` was raised when embedded null code points were "

"encountered in the Python string."

msgstr ""

"Bisher wurde ein „ :exc:`TypeError` “-Fehler ausgelöst, wenn in der Python-"

"Zeichenkette eingebettete Null-Codepunkte auftraten."

#: ../../c-api/arg.rst:100

msgid "``s*`` (:class:`str` or :term:`bytes-like object`) [Py_buffer]"

msgstr ""

"``s*`` (:class:`str` oder :term:`bytes-ähnliches Objekt <bytes-like "

"object>`) [Py_buffer]"

#: ../../c-api/arg.rst:101

msgid ""

"This format accepts Unicode objects as well as bytes-like objects. It fills "

"a :c:type:`Py_buffer` structure provided by the caller. In this case the "

"resulting C string may contain embedded NUL bytes. Unicode objects are "

"converted to C strings using ``'utf-8'`` encoding."

msgstr ""

"Dieses Format akzeptiert sowohl Unicode-Objekte als auch byteähnliche "

"Objekte. Es füllt eine vom Aufrufer bereitgestellte „ :c:type:`Py_buffer` “-"

"Struktur. In diesem Fall kann die resultierende C-Zeichenkette eingebettete "

"NUL-Bytes enthalten. Unicode-Objekte werden unter Verwendung der "

"„ ``'utf-8'`` “-Kodierung in C-Zeichenketten konvertiert."

#: ../../c-api/arg.rst:106

msgid ""

"``s#`` (:class:`str`, read-only :term:`bytes-like object`) [const char \\*, :"

"c:type:`Py_ssize_t`]"

msgstr ""

"``s#`` (:class:`str`, schreibgeschützt: :term:`bytes-ähnliches Objekt <bytes-"

"like object>`) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:107

msgid ""

"Like ``s*``, except that it provides a :ref:`borrowed buffer <c-arg-borrowed-"

"buffer>`. The result is stored into two C variables, the first one a pointer "

"to a C string, the second one its length. The string may contain embedded "

"null bytes. Unicode objects are converted to C strings using ``'utf-8'`` "

"encoding."

msgstr ""

"Ähnlich wie ``s*``, mit dem Unterschied, dass hier ein :ref:`geliehener "

"Puffer <c-arg-borrowed-buffer>` bereitgestellt wird. Das Ergebnis wird in "

"zwei C-Variablen gespeichert, wobei die erste ein Zeiger auf eine C-"

"Zeichenkette und die zweite deren Länge ist. Die Zeichenkette darf "

"eingebettete Null-Bytes enthalten. Unicode-Objekte werden mithilfe der "

"``'utf-8'``-Kodierung in C-Zeichenketten konvertiert."

#: ../../c-api/arg.rst:113 ../../c-api/arg.rst:619

msgid "``z`` (:class:`str` or ``None``) [const char \\*]"

msgstr "``z`` (:class:`str` oder ``None``) [const char \\*]"

#: ../../c-api/arg.rst:114

msgid ""

"Like ``s``, but the Python object may also be ``None``, in which case the C "

"pointer is set to ``NULL``."

msgstr ""

"Ähnlich wie bei ``s``, allerdings kann das Python-Objekt auch ``None`` sein; "

"in diesem Fall wird der C-Zeiger auf ``NULL`` gesetzt."

#: ../../c-api/arg.rst:117

msgid ""

"``z*`` (:class:`str`, :term:`bytes-like object` or ``None``) [Py_buffer]"

msgstr ""

"``z*`` (:class:`str`, :term:`bytes-ähnliches Objekt <bytes-like object>` "

"oder ``None``) [Py_buffer]"

#: ../../c-api/arg.rst:118

msgid ""

"Like ``s*``, but the Python object may also be ``None``, in which case the "

"``buf`` member of the :c:type:`Py_buffer` structure is set to ``NULL``."

msgstr ""

"Ähnlich wie bei ``s*``, wobei das Python-Objekt auch ``None`` sein kann; in "

"diesem Fall wird das Element ``buf`` der Struktur :c:type:`Py_buffer` auf "

"``NULL`` gesetzt."

#: ../../c-api/arg.rst:121

msgid ""

"``z#`` (:class:`str`, read-only :term:`bytes-like object` or ``None``) "

"[const char \\*, :c:type:`Py_ssize_t`]"

msgstr ""

"``z#`` (:class:`str`, schreibgeschützt: :term:`bytes-ähnliches Objekt <bytes-"

"like object>` oder ``None``) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:122

msgid ""

"Like ``s#``, but the Python object may also be ``None``, in which case the C "

"pointer is set to ``NULL``."

msgstr ""

"Ähnlich wie bei ``s#``, allerdings kann das Python-Objekt auch ``None`` "

"sein; in diesem Fall wird der C-Zeiger auf ``NULL`` gesetzt."

#: ../../c-api/arg.rst:125

msgid "``y`` (read-only :term:`bytes-like object`) [const char \\*]"

msgstr ""

"``y`` (schreibgeschützt :term:`bytes-ähnliches Objekt <bytes-like object>`) "

"[const char \\*]"

#: ../../c-api/arg.rst:126

msgid ""

"This format converts a bytes-like object to a C pointer to a :ref:`borrowed "

"<c-arg-borrowed-buffer>` character string; it does not accept Unicode "

"objects. The bytes buffer must not contain embedded null bytes; if it does, "

"a :exc:`ValueError` exception is raised."

msgstr ""

"Dieses Format konvertiert ein bytes-ähnliches Objekt in einen C-Zeiger auf "

"eine :ref:`borrowed <c-arg-borrowed-buffer>` Zeichenkette; Unicode-Objekte "

"werden nicht akzeptiert. Der Byte-Puffer darf keine eingebetteten Null-Bytes "

"enthalten; ist dies der Fall, wird eine Ausnahme vom Typ „ :exc:`ValueError` "

"“ ausgelöst."

#: ../../c-api/arg.rst:132

msgid ""

"Previously, :exc:`TypeError` was raised when embedded null bytes were "

"encountered in the bytes buffer."

msgstr ""

"Bisher wurde die Ausnahme „ :exc:`TypeError` “ ausgelöst, wenn im Byte-"

"Puffer eingebettete Null-Bytes gefunden wurden."

#: ../../c-api/arg.rst:136

msgid "``y*`` (:term:`bytes-like object`) [Py_buffer]"

msgstr "``y*`` (:term:`Byte-ähnliches Objekt <bytes-like object>`) [Py_buffer]"

#: ../../c-api/arg.rst:137

msgid ""

"This variant on ``s*`` doesn't accept Unicode objects, only bytes-like "

"objects. **This is the recommended way to accept binary data.**"

msgstr ""

"Diese Variante von ``s*`` akzeptiert keine Unicode-Objekte, sondern nur "

"byteähnliche Objekte. **Dies ist die empfohlene Vorgehensweise zum "

"Akzeptieren von Binärdaten.**"

#: ../../c-api/arg.rst:141

msgid ""

"``y#`` (read-only :term:`bytes-like object`) [const char \\*, :c:type:"

"`Py_ssize_t`]"

msgstr ""

"``y#`` (schreibgeschützt: :term:`bytes-ähnliches Objekt <bytes-like "

"object>`) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:142

msgid ""

"This variant on ``s#`` doesn't accept Unicode objects, only bytes-like "

"objects."

msgstr ""

"Diese Variante von ``s#`` akzeptiert keine Unicode-Objekte, sondern nur "

"byteähnliche Objekte."

#: ../../c-api/arg.rst:145

msgid "``S`` (:class:`bytes`) [PyBytesObject \\*]"

msgstr "``S`` (:class:`bytes`) [PyBytesObject \\*]"

#: ../../c-api/arg.rst:146

msgid ""

"Requires that the Python object is a :class:`bytes` object, without "

"attempting any conversion. Raises :exc:`TypeError` if the object is not a "

"bytes object. The C variable may also be declared as :c:expr:`PyObject*`."

msgstr ""

"Erfordert, dass das Python-Objekt ein „ :class:`bytes` “-Objekt ist, ohne "

"dass eine Konvertierung versucht wird. Löst eine „ :exc:`TypeError` “-"

"Ausnahme aus, wenn das Objekt kein „bytes“-Objekt ist. Die C-Variable kann "

"auch als „ :c:expr:`PyObject*` “ deklariert werden."

#: ../../c-api/arg.rst:150

msgid "``Y`` (:class:`bytearray`) [PyByteArrayObject \\*]"

msgstr "``Y`` (:class:`bytearray`) [PyByteArrayObject \\*]"

#: ../../c-api/arg.rst:151

msgid ""

"Requires that the Python object is a :class:`bytearray` object, without "

"attempting any conversion. Raises :exc:`TypeError` if the object is not a :"

"class:`bytearray` object. The C variable may also be declared as :c:expr:"

"`PyObject*`."

msgstr ""

"Erfordert, dass das Python-Objekt ein „ :class:`bytearray` “-Objekt ist, "

"ohne dass eine Konvertierung versucht wird. Löst „ :exc:`TypeError` “ aus, "

"wenn das Objekt kein „ :class:`bytearray` “-Objekt ist. Die C-Variable kann "

"auch als „ :c:expr:`PyObject*` “ deklariert werden."

#: ../../c-api/arg.rst:155

msgid "``U`` (:class:`str`) [PyObject \\*]"

msgstr "``U`` (:class:`str`) [PyObject \\*]"

#: ../../c-api/arg.rst:156

msgid ""

"Requires that the Python object is a Unicode object, without attempting any "

"conversion. Raises :exc:`TypeError` if the object is not a Unicode object. "

"The C variable may also be declared as :c:expr:`PyObject*`."

msgstr ""

"Setzt voraus, dass das Python-Objekt ein Unicode-Objekt ist, ohne dass eine "

"Konvertierung versucht wird. Löst eine „ :exc:`TypeError` “-Ausnahme aus, "

"wenn das Objekt kein Unicode-Objekt ist. Die C-Variable kann auch als „ :c:"

"expr:`PyObject*` “ deklariert werden."

#: ../../c-api/arg.rst:160

msgid "``w*`` (read-write :term:`bytes-like object`) [Py_buffer]"

msgstr ""

"``w*`` (Lese-/Schreibzugriff: :term:`byteähnliches Objekt <bytes-like "

"object>`) [Py_buffer]"

#: ../../c-api/arg.rst:161

msgid ""

"This format accepts any object which implements the read-write buffer "

"interface. It fills a :c:type:`Py_buffer` structure provided by the caller. "

"The buffer may contain embedded null bytes. The caller has to call :c:func:"

"`PyBuffer_Release` when it is done with the buffer."

msgstr ""

"Dieses Format akzeptiert jedes Objekt, das die Lese-/Schreib-Puffer-"

"Schnittstelle implementiert. Es füllt eine vom Aufrufer bereitgestellte „ :c:"

"type:`Py_buffer` “-Struktur. Der Puffer kann eingebettete Null-Bytes "

"enthalten. Der Aufrufer muss „ :c:func:`PyBuffer_Release` “ aufrufen, sobald "

"er den Puffer nicht mehr benötigt."

#: ../../c-api/arg.rst:166

msgid "``es`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer]"

msgstr "``es`` (:class:`str`) [const char \\*encoding, char \\*\\**buffer]"

#: ../../c-api/arg.rst:167

msgid ""

"This variant on ``s`` is used for encoding Unicode into a character buffer. "

"It only works for encoded data without embedded NUL bytes."

msgstr ""

"Diese Variante von ``s`` dient dazu, Unicode in einen Zeichenpuffer zu "

"kodieren. Sie funktioniert nur bei kodierten Daten ohne eingebettete NUL-"

"Bytes."

#: ../../c-api/arg.rst:170

msgid ""

"This format requires two arguments. The first is only used as input, and "

"must be a :c:expr:`const char*` which points to the name of an encoding as a "

"NUL-terminated string, or ``NULL``, in which case ``'utf-8'`` encoding is "

"used. An exception is raised if the named encoding is not known to Python. "

"The second argument must be a :c:expr:`char**`; the value of the pointer it "

"references will be set to a buffer with the contents of the argument text. "

"The text will be encoded in the encoding specified by the first argument."

msgstr ""

"Dieses Format erfordert zwei Argumente. Das erste wird nur als Eingabe "

"verwendet und muss ein :c:expr:`const char*` sein, der auf den Namen einer "

"Kodierung als NUL-terminierte Zeichenkette zeigt, oder ``NULL``; in diesem "

"Fall wird die Kodierung ``'utf-8'`` verwendet. Ist die angegebene Kodierung "

"in Python nicht bekannt, wird eine Ausnahme ausgelöst. Das zweite Argument "

"muss ein :c:expr:`char**` sein; der Wert des Zeigers, auf den es verweist, "

"wird auf einen Puffer mit dem Inhalt des Argumenttexts gesetzt. Der Text "

"wird in der Kodierung abgelegt, die durch das erste Argument angegeben wird."

#: ../../c-api/arg.rst:178

msgid ""

":c:func:`PyArg_ParseTuple` will allocate a buffer of the needed size, copy "

"the encoded data into this buffer and adjust *\\*buffer* to reference the "

"newly allocated storage. The caller is responsible for calling :c:func:"

"`PyMem_Free` to free the allocated buffer after use."

msgstr ""

":c:func:`PyArg_ParseTuple` wird einen Puffer der erforderlichen Größe "

"zuweisen, die kodierten Daten in diesen Puffer kopieren und *\\*buffer* so "

"anpassen, dass er auf den neu zugewiesenen Speicher verweist. Der Aufrufer "

"ist dafür verantwortlich, nach der Verwendung die Funktion :c:func:"

"`PyMem_Free` aufzurufen, um den zugewiesenen Puffer freizugeben."

#: ../../c-api/arg.rst:183

msgid ""

"``et`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "

"\\*encoding, char \\*\\*buffer]"

msgstr ""

"``et`` (:class:`str`, :class:`bytes` oder :class:`bytearray`) [const char "

"\\*encoding, char \\*\\*buffer]"

#: ../../c-api/arg.rst:184

msgid ""

"Same as ``es`` except that byte string objects are passed through without "

"recoding them. Instead, the implementation assumes that the byte string "

"object uses the encoding passed in as parameter."

msgstr ""

"Entspricht der Funktion „ ``es`` “, mit dem Unterschied, dass Byte-String-"

"Objekte ohne Umkodierung weitergereicht werden. Stattdessen geht die "

"Implementierung davon aus, dass das Byte-String-Objekt die als Parameter "

"übergebene Kodierung verwendet."

#: ../../c-api/arg.rst:188

msgid ""

"``es#`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer, :c:type:"

"`Py_ssize_t` \\*buffer_length]"

msgstr ""

"``es#`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer, :c:type:"

"`Py_ssize_t` \\*buffer_length]"

#: ../../c-api/arg.rst:189

msgid ""

"This variant on ``s#`` is used for encoding Unicode into a character buffer. "

"Unlike the ``es`` format, this variant allows input data which contains NUL "

"characters."

msgstr ""

"Diese Variante von „ ``s#`` “ dient zur Kodierung von Unicode in einen "

"Zeichenpuffer. Im Gegensatz zum Format „ ``es`` “ erlaubt diese Variante "

"Eingabedaten, die NUL-Zeichen enthalten."

#: ../../c-api/arg.rst:193

msgid ""

"It requires three arguments. The first is only used as input, and must be "

"a :c:expr:`const char*` which points to the name of an encoding as a NUL-"

"terminated string, or ``NULL``, in which case ``'utf-8'`` encoding is used. "

"An exception is raised if the named encoding is not known to Python. The "

"second argument must be a :c:expr:`char**`; the value of the pointer it "

"references will be set to a buffer with the contents of the argument text. "

"The text will be encoded in the encoding specified by the first argument. "

"The third argument must be a pointer to an integer; the referenced integer "

"will be set to the number of bytes in the output buffer."

msgstr ""

"Die Funktion benötigt drei Argumente. Das erste dient lediglich als Eingabe "

"und muss ein :c:expr:`const char*` sein, das auf den Namen einer Kodierung "

"als NUL-terminierte Zeichenkette verweist, oder ``NULL`` – in diesem Fall "

"wird die Kodierung ``'utf-8'`` verwendet. Wenn die angegebene Kodierung "

"Python nicht bekannt ist, wird eine Ausnahme ausgelöst. Das zweite Argument "

"muss ein :c:expr:`char**` sein. Der Wert des Zeigers, auf den es verweist, "

"wird auf einen Puffer mit dem Inhalt des Textarguments gesetzt. Der Text "

"wird in der durch das erste Argument angegebenen Kodierung kodiert. Das "

"dritte Argument muss ein Zeiger auf eine Ganzzahl sein; die Ganzzahl, auf "

"die verwiesen wird, wird auf die Anzahl der Bytes im Ausgabepuffer gesetzt."

#: ../../c-api/arg.rst:203

msgid "There are two modes of operation:"

msgstr "Es gibt zwei Betriebsmodi:"

#: ../../c-api/arg.rst:205

msgid ""

"If *\\*buffer* points a ``NULL`` pointer, the function will allocate a "

"buffer of the needed size, copy the encoded data into this buffer and set "

"*\\*buffer* to reference the newly allocated storage. The caller is "

"responsible for calling :c:func:`PyMem_Free` to free the allocated buffer "

"after usage."

msgstr ""

"Wenn *\\*buffer* auf einen Zeiger vom Typ „ ``NULL`` “ verweist, reserviert "

"die Funktion einen Puffer der erforderlichen Größe, kopiert die kodierten "

"Daten in diesen Puffer und setzt *\\*buffer* so, dass er auf den neu "

"reservierten Speicher verweist. Der Aufrufer ist dafür verantwortlich, nach "

"der Nutzung die Funktion „ :c:func:`PyMem_Free` “ aufzurufen, um den "

"reservierten Puffer freizugeben."

#: ../../c-api/arg.rst:210

msgid ""

"If *\\*buffer* points to a non-``NULL`` pointer (an already allocated "

"buffer), :c:func:`PyArg_ParseTuple` will use this location as the buffer and "

"interpret the initial value of *\\*buffer_length* as the buffer size. It "

"will then copy the encoded data into the buffer and NUL-terminate it. If "

"the buffer is not large enough, a :exc:`ValueError` will be set."

msgstr ""

"Wenn *\\*buffer* auf einen nicht-``NULL`` en Zeiger (einen bereits "

"zugewiesenen Puffer) verweist, verwendet :c:func:`PyArg_ParseTuple` diesen "

"Speicherort als Puffer und interpretiert den Anfangswert von "

"*\\*buffer_length* als Puffergröße. Anschließend kopiert die Funktion die "

"kodierten Daten in den Puffer und fügt am Ende ein NUL-Zeichen ein. Ist der "

"Puffer nicht groß genug, wird ein Fehlercode „ :exc:`ValueError` “ gesetzt."

#: ../../c-api/arg.rst:216

msgid ""

"In both cases, *\\*buffer_length* is set to the length of the encoded data "

"without the trailing NUL byte."

msgstr ""

"In beiden Fällen wird *\\*buffer_length* auf die Länge der kodierten Daten "

"ohne das abschließende NUL-Byte gesetzt."

#: ../../c-api/arg.rst:219

msgid ""

"``et#`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "

"\\*encoding, char \\*\\*buffer, :c:type:`Py_ssize_t` \\*buffer_length]"

msgstr ""

"``et#`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "

"\\*encoding, char \\*\\*buffer, :c:type:`Py_ssize_t` \\*buffer_length]"

#: ../../c-api/arg.rst:220

msgid ""

"Same as ``es#`` except that byte string objects are passed through without "

"recoding them. Instead, the implementation assumes that the byte string "

"object uses the encoding passed in as parameter."

msgstr ""

"Entspricht der Funktion „ ``es#`` “, mit dem Unterschied, dass Byte-String-"

"Objekte ohne Umkodierung weitergeleitet werden. Stattdessen geht die "

"Implementierung davon aus, dass das Byte-String-Objekt die als Parameter "

"übergebene Kodierung verwendet."

#: ../../c-api/arg.rst:224

msgid ""

"``u``, ``u#``, ``Z``, and ``Z#`` are removed because they used a legacy "

"``Py_UNICODE*`` representation."

msgstr ""

"``u``, ``u#``, ``Z`` und ``Z#`` wurden entfernt, da sie eine veraltete "

"Darstellung von „ ``Py_UNICODE*`` “ verwendeten."

#: ../../c-api/arg.rst:230

msgid "Numbers"

msgstr "Zahlen"

#: ../../c-api/arg.rst:232

msgid ""

"These formats allow representing Python numbers or single characters as C "

"numbers. Formats that require :class:`int`, :class:`float` or :class:"

"`complex` can also use the corresponding special methods :meth:`~object."

"__index__`, :meth:`~object.__float__` or :meth:`~object.__complex__` to "

"convert the Python object to the required type."

msgstr ""

"Mit diesen Formaten lassen sich Python-Zahlen oder einzelne Zeichen als C-"

"Zahlen darstellen. Formate, die „ :class:`int` “, „ :class:`float` “ oder „ :"

"class:`complex` “ erfordern, können auch die entsprechenden speziellen "

"Methoden „ :meth:`~object.__index__` “, „ :meth:`~object.__float__` “ oder "

"„ :meth:`~object.__complex__` “ verwenden, um das Python-Objekt in den "

"erforderlichen Typ zu konvertieren."

#: ../../c-api/arg.rst:238

msgid ""

"For signed integer formats, :exc:`OverflowError` is raised if the value is "

"out of range for the C type. For unsigned integer formats, no range checking "

"is done --- the most significant bits are silently truncated when the "

"receiving field is too small to receive the value."

msgstr ""

"Bei Formaten für vorzeichenbehaftete Ganzzahlen wird ein „ :exc:"

"`OverflowError` “ ausgelöst, wenn der Wert außerhalb des für den C-Typ "

"zulässigen Bereichs liegt. Bei Formaten für vorzeichenlose Ganzzahlen "

"erfolgt keine Bereichsprüfung – die höchstwertigen Bits werden "

"stillschweigend abgeschnitten, wenn das Empfängerfeld zu klein ist, um den "

"Wert aufzunehmen."

#: ../../c-api/arg.rst:244

msgid "``b`` (:class:`int`) [unsigned char]"

msgstr "``b`` (:class:`int`) [unsigned char]"

#: ../../c-api/arg.rst:245

msgid ""

"Convert a nonnegative Python integer to an unsigned tiny integer, stored in "

"a C :c:expr:`unsigned char`."

msgstr ""

"Konvertiert eine nicht-negative Python-Ganzzahl in eine vorzeichenlose "

"kleine Ganzzahl, die in einem C :c:expr:`unsigned char` gespeichert wird."

#: ../../c-api/arg.rst:248 ../../c-api/arg.rst:653

msgid "``B`` (:class:`int`) [unsigned char]"

msgstr "``B`` (:class:`int`) [unsigned char]"

#: ../../c-api/arg.rst:249

msgid ""

"Convert a Python integer to a tiny integer without overflow checking, stored "

"in a C :c:expr:`unsigned char`."

msgstr ""

"Konvertiert eine Python-Ganzzahl ohne Überlaufprüfung in eine kleine "

"Ganzzahl, die in einem C :c:expr:`unsigned char` gespeichert wird."

#: ../../c-api/arg.rst:252 ../../c-api/arg.rst:647

msgid "``h`` (:class:`int`) [short int]"

msgstr "``h`` (:class:`int`) [short int]"

#: ../../c-api/arg.rst:253

msgid "Convert a Python integer to a C :c:expr:`short int`."

msgstr "Konvertiere eine Python-Ganzzahl in einen C :c:expr:`short int`."

#: ../../c-api/arg.rst:255 ../../c-api/arg.rst:656

msgid "``H`` (:class:`int`) [unsigned short int]"

msgstr "``H`` (:class:`int`) [unsigned short int]"

#: ../../c-api/arg.rst:256

msgid ""

"Convert a Python integer to a C :c:expr:`unsigned short int`, without "

"overflow checking."

msgstr ""

"Konvertiere eine Python-Ganzzahl in einen C :c:expr:`unsigned short int`, "

"ohne Überlaufprüfung."

#: ../../c-api/arg.rst:259 ../../c-api/arg.rst:641

msgid "``i`` (:class:`int`) [int]"

msgstr "``i`` (:class:`int`) [int]"

#: ../../c-api/arg.rst:260

msgid "Convert a Python integer to a plain C :c:expr:`int`."

msgstr ""

"Konvertieren Sie eine Python-Ganzzahl in eine einfache C- :c:expr:`int`."

#: ../../c-api/arg.rst:262 ../../c-api/arg.rst:659

msgid "``I`` (:class:`int`) [unsigned int]"

msgstr "``I`` (:class:`int`) [unsigned int]"

#: ../../c-api/arg.rst:263

msgid ""

"Convert a Python integer to a C :c:expr:`unsigned int`, without overflow "

"checking."

msgstr ""

"Konvertiere eine Python-Ganzzahl in einen C :c:expr:`unsigned int`, ohne "

"Überlaufprüfung."

#: ../../c-api/arg.rst:266 ../../c-api/arg.rst:650

msgid "``l`` (:class:`int`) [long int]"

msgstr "``l`` (:class:`int`) [long int]"

#: ../../c-api/arg.rst:267

msgid "Convert a Python integer to a C :c:expr:`long int`."

msgstr "Konvertiere eine Python-Ganzzahl in einen C :c:expr:`long int`."

#: ../../c-api/arg.rst:269 ../../c-api/arg.rst:662

msgid "``k`` (:class:`int`) [unsigned long]"

msgstr "``k`` (:class:`int`) [unsigned long]"

#: ../../c-api/arg.rst:270

msgid ""

"Convert a Python integer to a C :c:expr:`unsigned long` without overflow "

"checking."

msgstr ""

"Konvertiere eine Python-Ganzzahl in einen C :c:expr:`unsigned long` ohne "

"Überlaufprüfung."

#: ../../c-api/arg.rst:273 ../../c-api/arg.rst:283

msgid "Use :meth:`~object.__index__` if available."

msgstr "Verwenden Sie „ :meth:`~object.__index__` “, falls verfügbar."

#: ../../c-api/arg.rst:276 ../../c-api/arg.rst:665

msgid "``L`` (:class:`int`) [long long]"

msgstr "``L`` (:class:`int`) [long long]"

#: ../../c-api/arg.rst:277

msgid "Convert a Python integer to a C :c:expr:`long long`."

msgstr "Konvertiere eine Python-Ganzzahl in einen C :c:expr:`long long`."

#: ../../c-api/arg.rst:279 ../../c-api/arg.rst:670

msgid "``K`` (:class:`int`) [unsigned long long]"

msgstr "``K`` (:class:`int`) [unsigned long long]"

#: ../../c-api/arg.rst:280

msgid ""

"Convert a Python integer to a C :c:expr:`unsigned long long` without "

"overflow checking."

msgstr ""

"Konvertiere eine Python-Ganzzahl in einen C :c:expr:`unsigned long long` "

"ohne Überlaufprüfung."

#: ../../c-api/arg.rst:286 ../../c-api/arg.rst:673

msgid "``n`` (:class:`int`) [:c:type:`Py_ssize_t`]"

msgstr "``n`` (:class:`int`) [:c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:287

msgid "Convert a Python integer to a C :c:type:`Py_ssize_t`."

msgstr ""

"Konvertieren Sie eine Python-Ganzzahl in einen C- :c:type:`Py_ssize_t`."

#: ../../c-api/arg.rst:289

msgid "``c`` (:class:`bytes` or :class:`bytearray` of length 1) [char]"

msgstr "``c`` (:class:`bytes` oder :class:`bytearray` der Länge 1) [char]"

#: ../../c-api/arg.rst:290

msgid ""

"Convert a Python byte, represented as a :class:`bytes` or :class:`bytearray` "

"object of length 1, to a C :c:expr:`char`."

msgstr ""

"Konvertiere ein Python-Byte, das als Objekt vom Typ „ :class:`bytes` “ oder "

"„ :class:`bytearray` “ mit der Länge 1 dargestellt wird, in ein C- :c:expr:"

"`char`."

#: ../../c-api/arg.rst:293

msgid "Allow :class:`bytearray` objects."

msgstr ":class:`bytearray`-Objekte zulassen."

#: ../../c-api/arg.rst:296 ../../c-api/arg.rst:691

msgid "``C`` (:class:`str` of length 1) [int]"

msgstr "``C`` (:class:`str`, Länge 1) [int]"

#: ../../c-api/arg.rst:297

msgid ""

"Convert a Python character, represented as a :class:`str` object of length "

"1, to a C :c:expr:`int`."

msgstr ""

"Konvertiere ein Python-Zeichen, das als „ :class:`str` “-Objekt der Länge 1 "

"dargestellt wird, in ein C- :c:expr:`int`."

#: ../../c-api/arg.rst:300 ../../c-api/arg.rst:698

msgid "``f`` (:class:`float`) [float]"

msgstr "``f`` (:class:`float`) [float]"

#: ../../c-api/arg.rst:301

msgid "Convert a Python floating-point number to a C :c:expr:`float`."

msgstr ""

"Konvertieren Sie eine Python-Gleitkommazahl in einen C- :c:expr:`float`."

#: ../../c-api/arg.rst:303 ../../c-api/arg.rst:695

msgid "``d`` (:class:`float`) [double]"

msgstr "``d`` (:class:`float`) [doppelt]"

#: ../../c-api/arg.rst:304

msgid "Convert a Python floating-point number to a C :c:expr:`double`."

msgstr ""

"Konvertieren Sie eine Python-Gleitkommazahl in einen C- :c:expr:`double`."

#: ../../c-api/arg.rst:306

msgid "``D`` (:class:`complex`) [Py_complex]"

msgstr "``D`` (:class:`complex`) [Py_complex]"

#: ../../c-api/arg.rst:307

msgid "Convert a Python complex number to a C :c:type:`Py_complex` structure."

msgstr ""

"Konvertieren Sie eine komplexe Zahl aus Python in eine C- :c:type:"

"`Py_complex`-Struktur."

#: ../../c-api/arg.rst:310

msgid "Other objects"

msgstr "Sonstige Objekte"

#: ../../c-api/arg.rst:312 ../../c-api/arg.rst:704

msgid "``O`` (object) [PyObject \\*]"

msgstr "``O`` (Objekt) [PyObject \\*]"

#: ../../c-api/arg.rst:313

msgid ""

"Store a Python object (without any conversion) in a C object pointer. The C "

"program thus receives the actual object that was passed. A new :term:"

"`strong reference` to the object is not created (i.e. its reference count is "

"not increased). The pointer stored is not ``NULL``."

msgstr ""

"Speichert ein Python-Objekt (ohne jegliche Konvertierung) in einem C-"

"Objektzeiger. Das C-Programm erhält somit das tatsächlich übergebene Objekt. "

"Es wird keine neue :term:`starke Referenz <strong reference>` auf das Objekt "

"erstellt (d.h., dessen Referenzzähler wird nicht erhöht). Der gespeicherte "

"Zeiger ist kein ``NULL``."

#: ../../c-api/arg.rst:319

msgid "``O!`` (object) [*typeobject*, PyObject \\*]"

msgstr "``O!`` (Objekt) [*typeobject*, PyObject \\*]"

#: ../../c-api/arg.rst:320

msgid ""

"Store a Python object in a C object pointer. This is similar to ``O``, but "

"takes two C arguments: the first is the address of a Python type object, the "

"second is the address of the C variable (of type :c:expr:`PyObject*`) into "

"which the object pointer is stored. If the Python object does not have the "

"required type, :exc:`TypeError` is raised."

msgstr ""

"Speichert ein Python-Objekt in einem C-Objektzeiger. Dies ähnelt der "

"Funktion ``O``, nimmt jedoch zwei C-Argumente entgegen: Das erste ist die "

"Adresse eines Objekts vom Python-Typ, das zweite ist die Adresse der C-"

"Variablen (vom Typ :c:expr:`PyObject*`), in der der Objektzeiger gespeichert "

"wird. Wenn das Python-Objekt nicht den erforderlichen Typ aufweist, wird "

"ein :exc:`TypeError` ausgelöst."

#: ../../c-api/arg.rst:328

msgid "``O&`` (object) [*converter*, *address*]"

msgstr "``O&`` (Objekt) [*Konverter*, *Adresse*]"

#: ../../c-api/arg.rst:329

msgid ""

"Convert a Python object to a C variable through a *converter* function. "

"This takes two arguments: the first is a function, the second is the address "

"of a C variable (of arbitrary type), converted to :c:expr:`void *`. The "

"*converter* function in turn is called as follows::"

msgstr ""

"Konvertieren Sie ein Python-Objekt mithilfe einer *converter*-Funktion in "

"eine C-Variable. Diese Funktion benötigt zwei Argumente: Das erste ist eine "

"Funktion, das zweite ist die Adresse einer C-Variablen (beliebigen Typs), "

"die in :c:expr:`void *` konvertiert wurde. Die *converter*-Funktion wird "

"wiederum wie folgt aufgerufen::"

#: ../../c-api/arg.rst:334

msgid "status = converter(object, address);"

msgstr "status = converter(object, address);"

#: ../../c-api/arg.rst:336

msgid ""

"where *object* is the Python object to be converted and *address* is the :c:"

"expr:`void*` argument that was passed to the ``PyArg_Parse*`` function. The "

"returned *status* should be ``1`` for a successful conversion and ``0`` if "

"the conversion has failed. When the conversion fails, the *converter* "

"function should raise an exception and leave the content of *address* "

"unmodified."

msgstr ""

"Dabei ist *object* das zu konvertierende Python-Objekt und *address* das "

"Argument „ :c:expr:`void*` “, das an die Funktion „ ``PyArg_Parse*`` “ "

"übergeben wurde. Der zurückgegebene Wert *status* sollte bei erfolgreicher "

"Konvertierung „ ``1`` “ lauten und bei fehlgeschlagener Konvertierung "

"„ ``0`` “. Wenn die Konvertierung fehlschlägt, sollte die Funktion "

"*converter* eine Ausnahme auslösen und den Inhalt von *address* unverändert "

"lassen."

#: ../../c-api/arg.rst:345

msgid ""

"If the *converter* returns :c:macro:`!Py_CLEANUP_SUPPORTED`, it may get "

"called a second time if the argument parsing eventually fails, giving the "

"converter a chance to release any memory that it had already allocated. In "

"this second call, the *object* parameter will be ``NULL``; *address* will "

"have the same value as in the original call."

msgstr ""

"Wenn der *Konverter* „ :c:macro:`!Py_CLEANUP_SUPPORTED` “ zurückgibt, wird "

"er möglicherweise ein zweites Mal aufgerufen, falls die Analyse des "

"Arguments letztendlich fehlschlägt. Dadurch erhält der Konverter die "

"Möglichkeit, bereits zugewiesenen Speicher wieder freizugeben. Bei diesem "

"zweiten Aufruf ist der Parameter *object* gleich „ ``NULL`` “; *address* hat "

"denselben Wert wie beim ursprünglichen Aufruf."

#: ../../c-api/arg.rst:351

msgid ""

"Examples of converters: :c:func:`PyUnicode_FSConverter` and :c:func:"

"`PyUnicode_FSDecoder`."

msgstr ""

"Beispiele für Umrechner: :c:func:`PyUnicode_FSConverter` und :c:func:"

"`PyUnicode_FSDecoder`."

#: ../../c-api/arg.rst:354

msgid ":c:macro:`!Py_CLEANUP_SUPPORTED` was added."

msgstr ":c:macro:`!Py_CLEANUP_SUPPORTED` wurde hinzugefügt."

#: ../../c-api/arg.rst:357 ../../c-api/arg.rst:676

msgid "``p`` (:class:`bool`) [int]"

msgstr "``p`` (:class:`bool`) [int]"

#: ../../c-api/arg.rst:358

msgid ""

"Tests the value passed in for truth (a boolean **p**\\ redicate) and "

"converts the result to its equivalent C true/false integer value. Sets the "

"int to ``1`` if the expression was true and ``0`` if it was false. This "

"accepts any valid Python value. See :ref:`truth` for more information about "

"how Python tests values for truth."

msgstr ""

"Prüft den übergebenen Wert auf Wahrheitswert (ein boolesches **p**\\ "

"Prädikat) und wandelt das Ergebnis in den entsprechenden C-Ganzzahlwert für "

"„true“ bzw. „false“ um. Setzt den int-Wert auf „ ``1`` “, wenn der Ausdruck "

"wahr war, und auf „ ``0`` “, wenn er falsch war. Hierfür sind alle gültigen "

"Python-Werte zulässig. Weitere Informationen dazu, wie Python Werte auf "

"ihren Wahrheitswert prüft, finden Sie unter :ref:`truth`."

#: ../../c-api/arg.rst:366

msgid "``(items)`` (sequence) [*matching-items*]"

msgstr "``(items)`` (Sequenz) [*übereinstimmende Elemente*]"

#: ../../c-api/arg.rst:367

msgid ""

"The object must be a Python sequence (except :class:`str`, :class:`bytes` "

"or :class:`bytearray`) whose length is the number of format units in "

"*items*. The C arguments must correspond to the individual format units in "

"*items*. Format units for sequences may be nested."

msgstr ""

"Das Objekt muss eine Python-Sequenz sein (mit Ausnahme von :class:`str`, :"

"class:`bytes` oder :class:`bytearray`), deren Länge der Anzahl der "

"Formateinheiten in *items* entspricht. Die C-Argumente müssen den einzelnen "

"Formateinheiten in *items* entsprechen. Formateinheiten für Sequenzen können "

"verschachtelt sein."

#: ../../c-api/arg.rst:372

msgid ""

"If *items* contains format units which store a :ref:`borrowed buffer <c-arg-"

"borrowed-buffer>` (``s``, ``s#``, ``z``, ``z#``, ``y``, or ``y#``) or a :"

"term:`borrowed reference` (``S``, ``Y``, ``U``, ``O``, or ``O!``), the "

"object must be a Python tuple. The *converter* for the ``O&`` format unit in "

"*items* must not store a borrowed buffer or a borrowed reference."

msgstr ""

"Wenn *items* Formateinheiten enthält, die einen :ref:`ausgeliehenen Puffer "

"<c-arg-borrowed-buffer>` (``s``, ``s#``, ``z``, ``z#``, ``y`` oder ``y#``) "

"oder eine :term:`ausgeliehene Referenz <borrowed reference>` (``S``, ``Y``, "

"``U``, ``O`` oder ``O!``) speichern, muss das Objekt ein Python-Tupel sein. "

"Der *Konverter* für die Einheit im Format „ ``O&`` “ in *items* darf keinen "

"ausgeliehenen Puffer oder eine ausgeliehene Referenz speichern."

#: ../../c-api/arg.rst:379

msgid ""

":class:`str` and :class:`bytearray` objects no longer accepted as a sequence."

msgstr ""

":class:`str` und Objekte vom Typ „ :class:`bytearray` “ werden nicht mehr "

"als Sequenz akzeptiert."

#: ../../c-api/arg.rst:382

msgid ""

"Non-tuple sequences are deprecated if *items* contains format units which "

"store a borrowed buffer or a borrowed reference."

msgstr ""

"Nicht-Tupel-Sequenzen sind veraltet, wenn *items* Format-Einheiten enthält, "

"die einen ausgeliehenen Puffer oder eine ausgeliehene Referenz speichern."

#: ../../c-api/arg.rst:386

msgid ""

"A few other characters have a meaning in a format string. These may not "

"occur inside nested parentheses. They are:"

msgstr ""

"Einige weitere Zeichen haben in einer Formatzeichenfolge eine bestimmte "

"Bedeutung. Diese dürfen nicht innerhalb verschachtelter Klammern vorkommen. "

"Es handelt sich dabei um folgende Zeichen:"

#: ../../c-api/arg.rst:389

msgid "``|``"

msgstr "``|``"

#: ../../c-api/arg.rst:390

msgid ""

"Indicates that the remaining arguments in the Python argument list are "

"optional. The C variables corresponding to optional arguments should be "

"initialized to their default value --- when an optional argument is not "