buffer.po

# 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-09-23 06:17+0000\n"
"PO-Revision-Date: 2026-09-23 08:00+0200\n"
"Last-Translator: Swen Bachmann\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"

#: ../../c-api/buffer.rst:11
msgid "Buffer Protocol"
msgstr "Buffer-Protokoll"

#: ../../c-api/buffer.rst:13
msgid ""
"Certain objects available in Python wrap access to an underlying memory "
"array or *buffer*.  Such objects include the built-in :class:`bytes` and :"
"class:`bytearray`, and some extension types like :class:`array.array`. Third-"
"party libraries may define their own types for special purposes, such as "
"image processing or numeric analysis."
msgstr ""
"Bestimmte in Python verfügbare Objekte verpacken den Zugriff auf ein "
"zugrunde liegendes Speicherarray oder einen *Puffer*. Zu diesen Objekten "
"gehören die integrierten Typen „ :class:`bytes` “ und „ :class:`bytearray` “ "
"sowie einige Erweiterungstypen wie „ :class:`array.array` “. Bibliotheken "
"von Drittanbietern können eigene Typen für spezielle Zwecke definieren, "
"beispielsweise für die Bildverarbeitung oder die numerische Analyse."

#: ../../c-api/buffer.rst:19
msgid ""
"While each of these types have their own semantics, they share the common "
"characteristic of being backed by a possibly large memory buffer.  It is "
"then desirable, in some situations, to access that buffer directly and "
"without intermediate copying."
msgstr ""
"Zwar hat jeder dieser Typen seine eigene Semantik, doch haben sie alle "
"gemeinsam, dass sie auf einem möglicherweise großen Speicherpuffer basieren. "
"In manchen Situationen ist es daher wünschenswert, direkt und ohne "
"zwischengeschaltete Kopiervorgänge auf diesen Puffer zuzugreifen."

#: ../../c-api/buffer.rst:24
msgid ""
"Python provides such a facility at the C and Python level in the form of "
"the :ref:`buffer protocol <bufferobjects>`.  This protocol has two sides:"
msgstr ""
"Python bietet eine solche Funktion auf C- und Python-Ebene in Form des :ref:"
"`Buffer-Protokolls <bufferobjects>`. Dieses Protokoll hat zwei Seiten:"

#: ../../c-api/buffer.rst:29
msgid ""
"on the producer side, a type can export a \"buffer interface\" which allows "
"objects of that type to expose information about their underlying buffer. "
"This interface is described in the section :ref:`buffer-structs`; for Python "
"see :ref:`python-buffer-protocol`."
msgstr ""
"Auf der Produzentenseite kann ein Typ eine „Puffer-Schnittstelle“ "
"exportieren, die es Objekten dieses Typs ermöglicht, Informationen über "
"ihren zugrunde liegenden Puffer bereitzustellen. Diese Schnittstelle wird im "
"Abschnitt „ :ref:`buffer-structs` “ beschrieben; Informationen zu Python "
"finden Sie unter :ref:`python-buffer-protocol`."

#: ../../c-api/buffer.rst:34
msgid ""
"on the consumer side, several means are available to obtain a pointer to the "
"raw underlying data of an object (for example a method parameter). For "
"Python see :class:`memoryview`."
msgstr ""
"Auf der Verbraucherseite stehen verschiedene Möglichkeiten zur Verfügung, um "
"einen Zeiger auf die zugrunde liegenden Rohdaten eines Objekts "
"(beispielsweise einen Methodenparameter) zu erhalten. Für Python siehe :"
"class:`memoryview`."

#: ../../c-api/buffer.rst:38
msgid ""
"Simple objects such as :class:`bytes` and :class:`bytearray` expose their "
"underlying buffer in byte-oriented form.  Other forms are possible; for "
"example, the elements exposed by an :class:`array.array` can be multi-byte "
"values."
msgstr ""
"Einfache Objekte wie „ :class:`bytes` “ und „ :class:`bytearray` “ stellen "
"ihren zugrunde liegenden Puffer in byteorientierter Form bereit. Andere "
"Formen sind möglich; beispielsweise können die von einem „ :class:`array."
"array` “ bereitgestellten Elemente Mehrbyte-Werte sein."

#: ../../c-api/buffer.rst:42
msgid ""
"An example consumer of the buffer interface is the :meth:`~io.BufferedIOBase."
"write` method of file objects: any object that can export a series of bytes "
"through the buffer interface can be written to a file.  While :meth:`!write` "
"only needs read-only access to the internal contents of the object passed to "
"it, other methods such as :meth:`~io.BufferedIOBase.readinto` need write "
"access to the contents of their argument.  The buffer interface allows "
"objects to selectively allow or reject exporting of read-write and read-only "
"buffers."
msgstr ""
"Ein Beispiel für die Nutzung der Puffer-Schnittstelle ist die Methode „ :"
"meth:`~io.BufferedIOBase.write` “ von Datei-Objekten: Jedes Objekt, das eine "
"Reihe von Bytes über die Puffer-Schnittstelle exportieren kann, lässt sich "
"in eine Datei schreiben. Während „ :meth:`!write` “ lediglich Lesezugriff "
"auf den internen Inhalt des übergebenen Objekts benötigt, benötigen andere "
"Methoden wie „ :meth:`~io.BufferedIOBase.readinto` “ Schreibzugriff auf den "
"Inhalt ihres Arguments.  Die Puffer-Schnittstelle ermöglicht es Objekten, "
"den Export von Lese-/Schreib- und Nur-Lese-Puffern selektiv zuzulassen oder "
"abzulehnen."

#: ../../c-api/buffer.rst:50
msgid ""
"There are two ways for a consumer of the buffer interface to acquire a "
"buffer over a target object:"
msgstr ""
"Es gibt zwei Möglichkeiten für einen Nutzer der Puffer-Schnittstelle, einen "
"Puffer über ein Zielobjekt zu beziehen:"

#: ../../c-api/buffer.rst:53
msgid "call :c:func:`PyObject_GetBuffer` with the right parameters;"
msgstr ""
"Rufen Sie „ :c:func:`PyObject_GetBuffer` “ mit den richtigen Parametern auf;"

#: ../../c-api/buffer.rst:55
msgid ""
"call :c:func:`PyArg_ParseTuple` (or one of its siblings) with one of the "
"``y*``, ``w*`` or ``s*`` :ref:`format codes <arg-parsing>`."
msgstr ""
"rufe :c:func:`PyArg_ParseTuple` (oder eine der verwandten Funktionen) mit "
"einem der :ref:`Formatcodes <arg-parsing>` ``y*``, ``w*`` oder ``s*`` auf."

#: ../../c-api/buffer.rst:58
msgid ""
"In both cases, :c:func:`PyBuffer_Release` must be called when the buffer "
"isn't needed anymore.  Failure to do so could lead to various issues such as "
"resource leaks."
msgstr ""
"In beiden Fällen muss „ :c:func:`PyBuffer_Release` “ aufgerufen werden, "
"sobald der Puffer nicht mehr benötigt wird.  Wird dies versäumt, kann dies "
"zu verschiedenen Problemen wie beispielsweise Ressourcenlecks führen."

#: ../../c-api/buffer.rst:64
msgid ""
"The buffer protocol is now accessible in Python, see :ref:`python-buffer-"
"protocol` and :class:`memoryview`."
msgstr ""
"Das Buffer-Protokoll ist nun in Python verfügbar, siehe :ref:`python-buffer-"
"protocol` und :class:`memoryview`."

#: ../../c-api/buffer.rst:70
msgid "Buffer structure"
msgstr "Pufferstruktur"

#: ../../c-api/buffer.rst:72
msgid ""
"Buffer structures (or simply \"buffers\") are useful as a way to expose the "
"binary data from another object to the Python programmer.  They can also be "
"used as a zero-copy slicing mechanism.  Using their ability to reference a "
"block of memory, it is possible to expose any data to the Python programmer "
"quite easily.  The memory could be a large, constant array in a C extension, "
"it could be a raw block of memory for manipulation before passing to an "
"operating system library, or it could be used to pass around structured data "
"in its native, in-memory format."
msgstr ""
"Pufferstrukturen (oder einfach „Puffer“) sind nützlich, um dem Python-"
"Programmierer die Binärdaten eines anderen Objekts zugänglich zu machen. Sie "
"können auch als Zero-Copy-Slicing-Mechanismus verwendet werden. Dank ihrer "
"Fähigkeit, auf einen Speicherblock zu verweisen, ist es möglich, dem Python-"
"Programmierer beliebige Daten ganz einfach zugänglich zu machen.  Bei dem "
"Speicher könnte es sich um ein großes, konstantes Array in einer C-"
"Erweiterung handeln, um einen rohen Speicherblock, der vor der Übergabe an "
"eine Betriebssystembibliothek bearbeitet werden soll, oder um strukturierte "
"Daten, die in ihrem nativen Speicherformat weitergegeben werden sollen."

#: ../../c-api/buffer.rst:81
msgid ""
"Contrary to most data types exposed by the Python interpreter, buffers are "
"not :c:type:`PyObject` pointers but rather simple C structures.  This allows "
"them to be created and copied very simply.  When a generic wrapper around a "
"buffer is needed, a :ref:`memoryview <memoryview-objects>` object can be "
"created."
msgstr ""
"Im Gegensatz zu den meisten vom Python-Interpreter bereitgestellten "
"Datentypen sind Puffer keine Zeiger vom Typ „ :c:type:`PyObject` “, sondern "
"einfache C-Strukturen. Dadurch lassen sie sich sehr einfach erstellen und "
"kopieren. Wenn ein generischer Wrapper um einen Puffer benötigt wird, kann "
"ein :ref:`memoryview- <memoryview-objects>`-Objekt erstellt werden."

#: ../../c-api/buffer.rst:87
msgid ""
"For short instructions how to write an exporting object, see :ref:`Buffer "
"Object Structures <buffer-structs>`. For obtaining a buffer, see :c:func:"
"`PyObject_GetBuffer`."
msgstr ""
"Eine kurze Anleitung zum Erstellen eines Exportobjekts finden Sie unter :ref:"
"`Buffer Object Structures <buffer-structs>`. Informationen zum Abrufen eines "
"Puffers finden Sie unter :c:func:`PyObject_GetBuffer`."

#: ../../c-api/buffer.rst:95
msgid ""
"A pointer to the start of the logical structure described by the buffer "
"fields. This can be any location within the underlying physical memory block "
"of the exporter. For example, with negative :c:member:`~Py_buffer.strides` "
"the value may point to the end of the memory block."
msgstr ""
"Ein Zeiger auf den Anfang der durch die Pufferfelder beschriebenen logischen "
"Struktur. Dies kann eine beliebige Stelle innerhalb des zugrunde liegenden "
"physischen Speicherblocks des Exporteurs sein. Bei negativen Werten von :c:"
"member:`~Py_buffer.strides` kann der Zeiger beispielsweise auf das Ende des "
"Speicherblocks verweisen."

#: ../../c-api/buffer.rst:100
msgid ""
"For :term:`contiguous` arrays, the value points to the beginning of the "
"memory block."
msgstr ""
"Bei :term:`zusammenhängenden <contiguous>` Arrays verweist der Wert auf den "
"Anfang des Speicherblocks."

#: ../../c-api/buffer.rst:105
msgid ""
"A new reference to the exporting object. The reference is owned by the "
"consumer and automatically released (i.e. reference count decremented) and "
"set to ``NULL`` by :c:func:`PyBuffer_Release`. The field is the equivalent "
"of the return value of any standard C-API function."
msgstr ""
"Eine neue Referenz auf das exportierende Objekt. Die Referenz befindet sich "
"im Besitz des Verbrauchers und wird automatisch freigegeben (d.h., die "
"Referenzzählung wird verringert) und von :c:func:`PyBuffer_Release` auf "
"``NULL`` gesetzt. Das Feld entspricht dem Rückgabewert einer beliebigen "
"Standard-C-API-Funktion."

#: ../../c-api/buffer.rst:112
msgid ""
"As a special case, for *temporary* buffers that are wrapped by :c:func:"
"`PyMemoryView_FromBuffer` or :c:func:`PyBuffer_FillInfo` this field is "
"``NULL``. In general, exporting objects MUST NOT use this scheme."
msgstr ""
"Als Sonderfall gilt für *temporäre* Puffer, die von :c:func:"
"`PyMemoryView_FromBuffer` oder :c:func:`PyBuffer_FillInfo` umschlossen sind, "
"dass dieses Feld ``NULL`` lautet. Im Allgemeinen DÜRFEN exportierende "
"Objekte dieses Schema NICHT verwenden."

#: ../../c-api/buffer.rst:119
msgid ""
"``product(shape) * itemsize``. For contiguous arrays, this is the length of "
"the underlying memory block. For non-contiguous arrays, it is the length "
"that the logical structure would have if it were copied to a contiguous "
"representation."
msgstr ""
"``product(shape) * itemsize``. Bei zusammenhängenden Arrays entspricht dies "
"der Länge des zugrunde liegenden Speicherblocks. Bei nicht zusammenhängenden "
"Arrays entspricht dies der Länge, die die logische Struktur hätte, wenn sie "
"in eine zusammenhängende Darstellung kopiert würde."

#: ../../c-api/buffer.rst:124
msgid ""
"Accessing ``((char *)buf)[0] up to ((char *)buf)[len-1]`` is only valid if "
"the buffer has been obtained by a request that guarantees contiguity. In "
"most cases such a request will be :c:macro:`PyBUF_SIMPLE` or :c:macro:"
"`PyBUF_WRITABLE`."
msgstr ""
"Der Zugriff auf ``((char *)buf)[0] up to ((char *)buf)[len-1]`` ist nur "
"zulässig, wenn der Puffer durch eine Anfrage abgerufen wurde, die "
"zusammenhängende Daten garantiert. In den meisten Fällen handelt es sich bei "
"einer solchen Anfrage um :c:macro:`PyBUF_SIMPLE` oder :c:macro:"
"`PyBUF_WRITABLE`."

#: ../../c-api/buffer.rst:130
msgid ""
"An indicator of whether the buffer is read-only. This field is controlled by "
"the :c:macro:`PyBUF_WRITABLE` flag."
msgstr ""
"Ein Indikator dafür, ob der Puffer schreibgeschützt ist. Dieses Feld wird "
"durch das Flag „ :c:macro:`PyBUF_WRITABLE` “ gesteuert."

#: ../../c-api/buffer.rst:135
msgid ""
"Item size in bytes of a single element. Same as the value of :func:`struct."
"calcsize` called on non-``NULL`` :c:member:`~Py_buffer.format` values."
msgstr ""
"Größe eines einzelnen Elements in Byte. Entspricht dem Wert von „ :func:"
"`struct.calcsize` “, der für Werte aufgerufen wird, die nicht „``NULL`` “ :c:"
"member:`~Py_buffer.format` sind."

#: ../../c-api/buffer.rst:138
msgid ""
"Important exception: If a consumer requests a buffer without the :c:macro:"
"`PyBUF_FORMAT` flag, :c:member:`~Py_buffer.format` will be set to  "
"``NULL``,  but :c:member:`~Py_buffer.itemsize` still has the value for the "
"original format."
msgstr ""
"Wichtige Ausnahme: Wenn ein Verbraucher einen Puffer ohne das Flag „ :c:"
"macro:`PyBUF_FORMAT` “ anfordert, wird „ :c:member:`~Py_buffer.format` “ auf "
"„ ``NULL`` “ gesetzt, „ :c:member:`~Py_buffer.itemsize` “ behält jedoch "
"weiterhin den Wert des ursprünglichen Formats bei."

#: ../../c-api/buffer.rst:143
msgid ""
"If :c:member:`~Py_buffer.shape` is present, the equality ``product(shape) * "
"itemsize == len`` still holds and the consumer can use :c:member:`~Py_buffer."
"itemsize` to navigate the buffer."
msgstr ""
"Wenn „ :c:member:`~Py_buffer.shape` “ vorhanden ist, gilt weiterhin die "
"Gleichung „ ``product(shape) * itemsize == len`` “, und der Verbraucher kann "
"„ :c:member:`~Py_buffer.itemsize` “ verwenden, um durch den Puffer zu "
"navigieren."

#: ../../c-api/buffer.rst:147
msgid ""
"If :c:member:`~Py_buffer.shape` is ``NULL`` as a result of a :c:macro:"
"`PyBUF_SIMPLE` or a :c:macro:`PyBUF_WRITABLE` request, the consumer must "
"disregard :c:member:`~Py_buffer.itemsize` and assume ``itemsize == 1``."
msgstr ""
"Wenn „ :c:member:`~Py_buffer.shape` “ infolge einer Anfrage an „ :c:macro:"
"`PyBUF_SIMPLE` “ oder „ :c:macro:`PyBUF_WRITABLE` “ zu „ ``NULL`` “ führt, "
"muss der Verbraucher „ :c:member:`~Py_buffer.itemsize` “ ignorieren und von "
"„ ``itemsize == 1`` “ ausgehen."

#: ../../c-api/buffer.rst:153
msgid ""
"A *NULL* terminated string in :mod:`struct` module style syntax describing "
"the contents of a single item. If this is ``NULL``, ``\"B\"`` (unsigned "
"bytes) is assumed."
msgstr ""
"Eine mit *NULL* abgeschlossene Zeichenkette im Syntaxstil des Moduls „ :mod:"
"`struct` “, die den Inhalt eines einzelnen Elements beschreibt. Handelt es "
"sich dabei um „ ``NULL`` “, wird „ ``\"B\"`` “ (vorzeichenlose Bytes) "
"angenommen."

#: ../../c-api/buffer.rst:157
msgid "This field is controlled by the :c:macro:`PyBUF_FORMAT` flag."
msgstr "Dieses Feld wird durch das Flag „ :c:macro:`PyBUF_FORMAT` “ gesteuert."

#: ../../c-api/buffer.rst:161
msgid ""
"The number of dimensions the memory represents as an n-dimensional array. If "
"it is ``0``, :c:member:`~Py_buffer.buf` points to a single item representing "
"a scalar. In this case, :c:member:`~Py_buffer.shape`, :c:member:`~Py_buffer."
"strides` and :c:member:`~Py_buffer.suboffsets` MUST be ``NULL``. The maximum "
"number of dimensions is given by :c:macro:`PyBUF_MAX_NDIM`."
msgstr ""
"Die Anzahl der Dimensionen, die der Speicher als n-dimensionales Array "
"darstellt. Wenn diese Zahl ``0`` ist, verweist :c:member:`~Py_buffer.buf` "
"auf ein einzelnes Element, das einen Skalar darstellt. In diesem Fall "
"MÜSSEN :c:member:`~Py_buffer.shape`, :c:member:`~Py_buffer.strides` und :c:"
"member:`~Py_buffer.suboffsets` ``NULL`` sein. Die maximale Anzahl der "
"Dimensionen ist durch :c:macro:`PyBUF_MAX_NDIM` gegeben."

#: ../../c-api/buffer.rst:169
msgid ""
"An array of :c:type:`Py_ssize_t` of length :c:member:`~Py_buffer.ndim` "
"indicating the shape of the memory as an n-dimensional array. Note that "
"``shape[0] * ... * shape[ndim-1] * itemsize`` MUST be equal to :c:member:"
"`~Py_buffer.len`."
msgstr ""
"Ein Array von Typ „ :c:type:`Py_ssize_t` “ der Länge „ :c:member:`~Py_buffer."
"ndim` “, das die Form des Speichers als n-dimensionales Array angibt. "
"Beachten Sie, dass „ ``shape[0] * ... * shape[ndim-1] * itemsize`` “ "
"unbedingt gleich „ :c:member:`~Py_buffer.len` “ sein MUSS."

#: ../../c-api/buffer.rst:174
msgid ""
"Shape values are restricted to ``shape[n] >= 0``. The case ``shape[n] == 0`` "
"requires special attention. See `complex arrays`_ for further information."
msgstr ""
"Shape-Werte sind auf ``shape[n] >= 0`` beschränkt. Der Fall ``shape[n] == "
"0`` erfordert besondere Beachtung. Weitere Informationen findest du unter "
"`complex arrays`_."

#: ../../c-api/buffer.rst:178
msgid "The shape array is read-only for the consumer."
msgstr "Das Shape-Array ist für den Verbraucher schreibgeschützt."

#: ../../c-api/buffer.rst:182
msgid ""
"An array of :c:type:`Py_ssize_t` of length :c:member:`~Py_buffer.ndim` "
"giving the number of bytes to skip to get to a new element in each dimension."
msgstr ""
"Ein Array mit dem Namen „ :c:type:`Py_ssize_t` “ der Länge „ :c:member:"
"`~Py_buffer.ndim` “, das die Anzahl der Bytes angibt, die übersprungen "
"werden müssen, um in jeder Dimension zu einem neuen Element zu gelangen."

#: ../../c-api/buffer.rst:186
msgid ""
"Stride values can be any integer. For regular arrays, strides are usually "
"positive, but a consumer MUST be able to handle the case ``strides[n] <= "
"0``. See `complex arrays`_ for further information."
msgstr ""
"Stride-Werte können beliebige ganze Zahlen sein. Bei regulären Arrays sind "
"Strides in der Regel positiv, aber ein Verbraucher MUSS in der Lage sein, "
"den Fall ``strides[n] <= 0`` zu verarbeiten. Weitere Informationen findest "
"du unter `complex arrays`_."

#: ../../c-api/buffer.rst:190
msgid "The strides array is read-only for the consumer."
msgstr "Das „strides“-Array ist für den Verbraucher schreibgeschützt."

#: ../../c-api/buffer.rst:194
msgid ""
"An array of :c:type:`Py_ssize_t` of length :c:member:`~Py_buffer.ndim`. If "
"``suboffsets[n] >= 0``, the values stored along the nth dimension are "
"pointers and the suboffset value dictates how many bytes to add to each "
"pointer after de-referencing. A suboffset value that is negative indicates "
"that no de-referencing should occur (striding in a contiguous memory block)."
msgstr ""
"Ein Array von :c:type:`Py_ssize_t` der Länge :c:member:`~Py_buffer.ndim`. "
"Wenn ``suboffsets[n] >= 0``, sind die in der n-ten Dimension gespeicherten "
"Werte Zeiger, und der Suboffset-Wert gibt an, wie viele Bytes nach der "
"Dereferenzierung zu jedem Zeiger addiert werden sollen. Ein negativer "
"Suboffset-Wert bedeutet, dass keine Dereferenzierung erfolgen soll (Striding "
"in einem zusammenhängenden Speicherblock)."

#: ../../c-api/buffer.rst:201
msgid ""
"If all suboffsets are negative (i.e. no de-referencing is needed), then this "
"field must be ``NULL`` (the default value)."
msgstr ""
"Sind alle Teilversätze negativ (d. h., es ist keine Dereferenzierung "
"erforderlich), muss dieses Feld den Wert „ ``NULL`` “ annehmen "
"(Standardwert)."

#: ../../c-api/buffer.rst:204
msgid ""
"This type of array representation is used by the Python Imaging Library "
"(PIL). See `complex arrays`_ for further information how to access elements "
"of such an array."
msgstr ""
"Diese Art der Array-Darstellung wird von der Python Imaging Library (PIL) "
"verwendet. Weitere Informationen zum Zugriff auf Elemente eines solchen "
"Arrays findest du unter `complex arrays`_."

#: ../../c-api/buffer.rst:208
msgid "The suboffsets array is read-only for the consumer."
msgstr "Das „suboffsets“-Array ist für den Verbraucher schreibgeschützt."

#: ../../c-api/buffer.rst:212
msgid ""
"This is for use internally by the exporting object. For example, this might "
"be re-cast as an integer by the exporter and used to store flags about "
"whether or not the shape, strides, and suboffsets arrays must be freed when "
"the buffer is released. The consumer MUST NOT alter this value."
msgstr ""
"Dieser Wert ist für die interne Verwendung durch das exportierende Objekt "
"bestimmt. Er kann beispielsweise vom Exporter in einen Ganzzahlwert "
"umgewandelt und dazu verwendet werden, Flags zu speichern, die angeben, ob "
"die Arrays „shape“, „strides“ und „suboffsets“ freigegeben werden müssen, "
"wenn der Puffer freigegeben wird. Der Verbraucher DARF diesen Wert NICHT "
"ändern."

#: ../../c-api/buffer.rst:219
msgid "Constants:"
msgstr "Konstanten:"

#: ../../c-api/buffer.rst:223
msgid ""
"The maximum number of dimensions the memory represents. Exporters MUST "
"respect this limit, consumers of multi-dimensional buffers SHOULD be able to "
"handle up to :c:macro:`!PyBUF_MAX_NDIM` dimensions. Currently set to 64."
msgstr ""
"Die maximale Anzahl an Dimensionen, die der Speicher darstellt. Exporteure "
"MÜSSEN diese Grenze einhalten; Nutzer mehrdimensionaler Puffer SOLLTEN in "
"der Lage sein, bis zu :c:macro:`!PyBUF_MAX_NDIM` Dimensionen zu verarbeiten. "
"Derzeit auf 64 festgelegt."

#: ../../c-api/buffer.rst:232
msgid "Buffer request types"
msgstr "Arten von Pufferanforderungen"

#: ../../c-api/buffer.rst:234
msgid ""
"Buffers are usually obtained by sending a buffer request to an exporting "
"object via :c:func:`PyObject_GetBuffer`. Since the complexity of the logical "
"structure of the memory can vary drastically, the consumer uses the *flags* "
"argument to specify the exact buffer type it can handle."
msgstr ""
"Puffer werden in der Regel dadurch abgerufen, dass eine Pufferanforderung "
"über :c:func:`PyObject_GetBuffer` an ein exportierendes Objekt gesendet "
"wird. Da die Komplexität der logischen Struktur des Speichers stark "
"variieren kann, gibt der Verbraucher über das Argument *flags* den genauen "
"Puffertyp an, den er verarbeiten kann."

#: ../../c-api/buffer.rst:239
msgid ""
"All :c:type:`Py_buffer` fields are unambiguously defined by the request type."
msgstr ""
"Alle „ :c:type:`Py_buffer` “-Felder werden durch den Anfragetyp eindeutig "
"definiert."

#: ../../c-api/buffer.rst:243
msgid "request-independent fields"
msgstr "anfrageunabhängige Felder"

#: ../../c-api/buffer.rst:244
msgid ""
"The following fields are not influenced by *flags* and must always be filled "
"in with the correct values: :c:member:`~Py_buffer.obj`, :c:member:"
"`~Py_buffer.buf`, :c:member:`~Py_buffer.len`, :c:member:`~Py_buffer."
"itemsize`, :c:member:`~Py_buffer.ndim`."
msgstr ""
"Die folgenden Felder werden von *Flags* nicht beeinflusst und müssen stets "
"mit den richtigen Werten ausgefüllt werden: :c:member:`~Py_buffer.obj`, :c:"
"member:`~Py_buffer.buf`, :c:member:`~Py_buffer.len`, :c:member:`~Py_buffer."
"itemsize`, :c:member:`~Py_buffer.ndim`."

#: ../../c-api/buffer.rst:249
msgid "readonly, format"
msgstr "schreibgeschützt, Format"

#: ../../c-api/buffer.rst:253
msgid ""
"Controls the :c:member:`~Py_buffer.readonly` field. If set, the exporter "
"MUST provide a writable buffer or else report failure. Otherwise, the "
"exporter MAY provide either a read-only or writable buffer, but the choice "
"MUST be consistent for all consumers. For example, :c:expr:`PyBUF_SIMPLE | "
"PyBUF_WRITABLE` can be used to request a simple writable buffer."
msgstr ""
"Steuert das Feld „ :c:member:`~Py_buffer.readonly` “. Ist dieses gesetzt, "
"MUSS der Exporter einen beschreibbaren Puffer bereitstellen oder andernfalls "
"einen Fehler melden. Andernfalls DARF der Exporter entweder einen "
"schreibgeschützten oder einen beschreibbaren Puffer bereitstellen, die Wahl "
"MUSS jedoch für alle Verbraucher einheitlich sein. Beispielsweise kann :c:"
"expr:`PyBUF_SIMPLE | PyBUF_WRITABLE` verwendet werden, um einen einfachen "
"beschreibbaren Puffer anzufordern."

#: ../../c-api/buffer.rst:261
msgid "This is an alias to :c:macro:`PyBUF_WRITABLE`."
msgstr "Dies ist ein Alias für :c:macro:`PyBUF_WRITABLE`."

#: ../../c-api/buffer.rst:267
msgid ""
"Controls the :c:member:`~Py_buffer.format` field. If set, this field MUST be "
"filled in correctly. Otherwise, this field MUST be ``NULL``."
msgstr ""
"Steuert das Feld „ :c:member:`~Py_buffer.format` “. Wenn diese Option "
"aktiviert ist, MUSS dieses Feld korrekt ausgefüllt werden. Andernfalls MUSS "
"dieses Feld auf „ ``NULL`` “ gesetzt sein."

#: ../../c-api/buffer.rst:271
msgid ""
":c:macro:`PyBUF_WRITABLE` can be \\|'d to any of the flags in the next "
"section. Since :c:macro:`PyBUF_SIMPLE` is defined as 0, :c:macro:"
"`PyBUF_WRITABLE` can be used as a stand-alone flag to request a simple "
"writable buffer."
msgstr ""
":c:macro:`PyBUF_WRITABLE` kann mit \\| an jedes der Flags im nächsten "
"Abschnitt angehängt werden. Da „ :c:macro:`PyBUF_SIMPLE` “ auf 0 gesetzt "
"ist, kann „ :c:macro:`PyBUF_WRITABLE` “ als eigenständiges Flag verwendet "
"werden, um einen einfachen beschreibbaren Puffer anzufordern."

#: ../../c-api/buffer.rst:275
msgid ""
":c:macro:`PyBUF_FORMAT` must be \\|'d to any of the flags except :c:macro:"
"`PyBUF_SIMPLE`, because the latter already implies format ``B`` (unsigned "
"bytes). :c:macro:`!PyBUF_FORMAT` cannot be used on its own."
msgstr ""
":c:macro:`PyBUF_FORMAT` muss mit einem der Flags außer „ :c:macro:"
"`PyBUF_SIMPLE` “ kombiniert werden, da letzteres bereits das Format „ ``B`` "
"“ (vorzeichenlose Bytes) impliziert. „ :c:macro:`!PyBUF_FORMAT` “ kann nicht "
"eigenständig verwendet werden."

#: ../../c-api/buffer.rst:281
msgid "shape, strides, suboffsets"
msgstr "Form, Schrittlängen, Teilversätze"

#: ../../c-api/buffer.rst:283
msgid ""
"The flags that control the logical structure of the memory are listed in "
"decreasing order of complexity. Note that each flag contains all bits of the "
"flags below it."
msgstr ""
"Die Flags, die die logische Struktur des Speichers steuern, sind in "
"absteigender Reihenfolge ihrer Komplexität aufgeführt. Beachten Sie, dass "
"jedes Flag alle Bits der darunter liegenden Flags enthält."

#: ../../c-api/buffer.rst:290 ../../c-api/buffer.rst:314
#: ../../c-api/buffer.rst:339
msgid "Request"
msgstr "Anfrage"

#: ../../c-api/buffer.rst:290 ../../c-api/buffer.rst:314
#: ../../c-api/buffer.rst:339
msgid "shape"
msgstr "Form"

#: ../../c-api/buffer.rst:290 ../../c-api/buffer.rst:314
#: ../../c-api/buffer.rst:339
msgid "strides"
msgstr "Schritte"

#: ../../c-api/buffer.rst:290 ../../c-api/buffer.rst:314
#: ../../c-api/buffer.rst:339
msgid "suboffsets"
msgstr "Teilversätze"

#: ../../c-api/buffer.rst:292 ../../c-api/buffer.rst:294
#: ../../c-api/buffer.rst:296 ../../c-api/buffer.rst:316
#: ../../c-api/buffer.rst:318 ../../c-api/buffer.rst:320
#: ../../c-api/buffer.rst:322 ../../c-api/buffer.rst:341
#: ../../c-api/buffer.rst:343 ../../c-api/buffer.rst:345
#: ../../c-api/buffer.rst:347 ../../c-api/buffer.rst:349
#: ../../c-api/buffer.rst:351 ../../c-api/buffer.rst:353
#: ../../c-api/buffer.rst:355
msgid "yes"
msgstr "ja"

#: ../../c-api/buffer.rst:292 ../../c-api/buffer.rst:341
#: ../../c-api/buffer.rst:343
msgid "if needed"
msgstr "falls nötig"

#: ../../c-api/buffer.rst:294 ../../c-api/buffer.rst:296
#: ../../c-api/buffer.rst:298 ../../c-api/buffer.rst:316
#: ../../c-api/buffer.rst:318 ../../c-api/buffer.rst:320
#: ../../c-api/buffer.rst:322 ../../c-api/buffer.rst:345
#: ../../c-api/buffer.rst:347 ../../c-api/buffer.rst:349
#: ../../c-api/buffer.rst:351 ../../c-api/buffer.rst:353
#: ../../c-api/buffer.rst:355
msgid "NULL"
msgstr "NULL"

#: ../../c-api/buffer.rst:305
msgid "contiguity requests"
msgstr "Anträge auf zusammenhängende Grundstücke"

#: ../../c-api/buffer.rst:307
msgid ""
"C or Fortran :term:`contiguity <contiguous>` can be explicitly requested, "
"with and without stride information. Without stride information, the buffer "
"must be C-contiguous."
msgstr ""
"Ein :term:`Zusammenhang <contiguous>` nach C- oder Fortran-Ordnung kann "
"ausdrücklich angefordert werden, mit oder ohne Stride-Angabe. Ohne Stride-"
"Angabe muss der Puffer C-zusammenhängend sein."

#: ../../c-api/buffer.rst:314 ../../c-api/buffer.rst:339
msgid "contig"
msgstr "Contig"

#: ../../c-api/buffer.rst:316 ../../c-api/buffer.rst:322
#: ../../c-api/buffer.rst:353 ../../c-api/buffer.rst:355
msgid "C"
msgstr "C"

#: ../../c-api/buffer.rst:318
msgid "F"
msgstr "F"

#: ../../c-api/buffer.rst:320
msgid "C or F"
msgstr "C oder F"

#: ../../c-api/buffer.rst:322
msgid ":c:macro:`PyBUF_ND`"
msgstr ":c:macro:`PyBUF_ND`"

#: ../../c-api/buffer.rst:327
msgid "compound requests"
msgstr "zusammengesetzte Anfragen"

#: ../../c-api/buffer.rst:329
msgid ""
"All possible requests are fully defined by some combination of the flags in "
"the previous section. For convenience, the buffer protocol provides "
"frequently used combinations as single flags."
msgstr ""
"Alle möglichen Anfragen werden vollständig durch eine Kombination der im "
"vorigen Abschnitt genannten Flags definiert. Der Einfachheit halber stellt "
"das Pufferprotokoll häufig verwendete Kombinationen als einzelne Flags zur "
"Verfügung."

#: ../../c-api/buffer.rst:333
msgid ""
"In the following table *U* stands for undefined contiguity. The consumer "
"would have to call :c:func:`PyBuffer_IsContiguous` to determine contiguity."
msgstr ""
"In der folgenden Tabelle steht *U* für eine undefinierte Kontiguität. Der "
"Verbraucher müsste die Funktion „ :c:func:`PyBuffer_IsContiguous` “ "
"aufrufen, um die Kontiguität zu ermitteln."

#: ../../c-api/buffer.rst:339
msgid "readonly"
msgstr "schreibgeschützt"

#: ../../c-api/buffer.rst:339
msgid "format"
msgstr "Format"

#: ../../c-api/buffer.rst:341 ../../c-api/buffer.rst:343
#: ../../c-api/buffer.rst:345 ../../c-api/buffer.rst:347
#: ../../c-api/buffer.rst:349 ../../c-api/buffer.rst:351
msgid "U"
msgstr "U"

#: ../../c-api/buffer.rst:341 ../../c-api/buffer.rst:345
#: ../../c-api/buffer.rst:349 ../../c-api/buffer.rst:353
msgid "0"
msgstr "0"

#: ../../c-api/buffer.rst:343 ../../c-api/buffer.rst:347
#: ../../c-api/buffer.rst:351 ../../c-api/buffer.rst:355
msgid "1 or 0"
msgstr "1 oder 0"

#: ../../c-api/buffer.rst:360
msgid "Complex arrays"
msgstr "Komplexe Arrays"

#: ../../c-api/buffer.rst:363
msgid "NumPy-style: shape and strides"
msgstr "NumPy-Stil: Form und Schritte"

#: ../../c-api/buffer.rst:365
msgid ""
"The logical structure of NumPy-style arrays is defined by :c:member:"
"`~Py_buffer.itemsize`, :c:member:`~Py_buffer.ndim`, :c:member:`~Py_buffer."
"shape` and :c:member:`~Py_buffer.strides`."
msgstr ""
"Die logische Struktur von Arrays im NumPy-Stil wird durch :c:member:"
"`~Py_buffer.itemsize`, :c:member:`~Py_buffer.ndim`, :c:member:`~Py_buffer."
"shape` und :c:member:`~Py_buffer.strides` definiert."

#: ../../c-api/buffer.rst:368
msgid ""
"If ``ndim == 0``, the memory location pointed to by :c:member:`~Py_buffer."
"buf` is interpreted as a scalar of size :c:member:`~Py_buffer.itemsize`. In "
"that case, both :c:member:`~Py_buffer.shape` and :c:member:`~Py_buffer."
"strides` are ``NULL``."
msgstr ""
"Wenn ``ndim == 0`` gilt, wird die Speicheradresse, auf die :c:member:"
"`~Py_buffer.buf` verweist, als Skalar der Größe :c:member:`~Py_buffer."
"itemsize` interpretiert. In diesem Fall sind sowohl :c:member:`~Py_buffer."
"shape` als auch :c:member:`~Py_buffer.strides` ``NULL`` ."

#: ../../c-api/buffer.rst:372
msgid ""
"If :c:member:`~Py_buffer.strides` is ``NULL``, the array is interpreted as a "
"standard n-dimensional C-array. Otherwise, the consumer must access an n-"
"dimensional array as follows:"
msgstr ""
"Wenn „ :c:member:`~Py_buffer.strides` “ auf „ ``NULL`` “ gesetzt ist, wird "
"das Array als standardmäßiges n-dimensionales C-Array interpretiert. "
"Andernfalls muss der Verbraucher wie folgt auf ein n-dimensionales Array "
"zugreifen:"

#: ../../c-api/buffer.rst:376
msgid ""
"ptr = (char *)buf + indices[0] * strides[0] + ... + indices[n-1] * "
"strides[n-1];\n"
"item = *((typeof(item) *)ptr);"
msgstr ""
"ptr = (char *)buf + indices[0] * strides[0] + ... + indices[n-1] * "
"strides[n-1];\n"
"item = *((typeof(item) *)ptr);"

#: ../../c-api/buffer.rst:382
msgid ""
"As noted above, :c:member:`~Py_buffer.buf` can point to any location within "
"the actual memory block. An exporter can check the validity of a buffer with "
"this function:"
msgstr ""
"Wie oben bereits erwähnt, kann :c:member:`~Py_buffer.buf` auf eine beliebige "
"Stelle innerhalb des eigentlichen Speicherblocks verweisen. Ein Exporter "
"kann die Gültigkeit eines Puffers mit dieser Funktion überprüfen:"

#: ../../c-api/buffer.rst:386
msgid ""
"def verify_structure(memlen, itemsize, ndim, shape, strides, offset):\n"
"    \"\"\"Verify that the parameters represent a valid array within\n"
"       the bounds of the allocated memory:\n"
"           char *mem: start of the physical memory block\n"
"           memlen: length of the physical memory block\n"
"           offset: (char *)buf - mem\n"
"    \"\"\"\n"
"    if offset % itemsize:\n"
"        return False\n"
"    if offset < 0 or offset+itemsize > memlen:\n"
"        return False\n"
"    if any(v % itemsize for v in strides):\n"
"        return False\n"
"\n"
"    if ndim <= 0:\n"
"        return ndim == 0 and not shape and not strides\n"
"    if 0 in shape:\n"
"        return True\n"
"\n"
"    imin = sum(strides[j]*(shape[j]-1) for j in range(ndim)\n"
"               if strides[j] <= 0)\n"
"    imax = sum(strides[j]*(shape[j]-1) for j in range(ndim)\n"
"               if strides[j] > 0)\n"
"\n"
"    return 0 <= offset+imin and offset+imax+itemsize <= memlen"
msgstr ""
"def verify_structure(memlen, itemsize, ndim, shape, strides, offset):\n"
"    \"\"\"Verify that the parameters represent a valid array within\n"
"       the bounds of the allocated memory:\n"
"           char *mem: start of the physical memory block\n"
"           memlen: length of the physical memory block\n"
"           offset: (char *)buf - mem\n"
"    \"\"\"\n"
"    if offset % itemsize:\n"
"        return False\n"
"    if offset < 0 or offset+itemsize > memlen:\n"
"        return False\n"
"    if any(v % itemsize for v in strides):\n"
"        return False\n"
"\n"
"    if ndim <= 0:\n"
"        return ndim == 0 and not shape and not strides\n"
"    if 0 in shape:\n"
"        return True\n"
"\n"
"    imin = sum(strides[j]*(shape[j]-1) for j in range(ndim)\n"
"               if strides[j] <= 0)\n"
"    imax = sum(strides[j]*(shape[j]-1) for j in range(ndim)\n"
"               if strides[j] > 0)\n"
"\n"
"    return 0 <= offset+imin and offset+imax+itemsize <= memlen"

#: ../../c-api/buffer.rst:416
msgid "PIL-style: shape, strides and suboffsets"
msgstr "PIL-Stil: Form, Schritte und Teilversätze"

#: ../../c-api/buffer.rst:418
msgid ""
"In addition to the regular items, PIL-style arrays can contain pointers that "
"must be followed in order to get to the next element in a dimension. For "
"example, the regular three-dimensional C-array ``char v[2][2][3]`` can also "
"be viewed as an array of 2 pointers to 2 two-dimensional arrays: ``char "
"(*v[2])[2][3]``. In suboffsets representation, those two pointers can be "
"embedded at the start of :c:member:`~Py_buffer.buf`, pointing to two ``char "
"x[2][3]`` arrays that can be located anywhere in memory."
msgstr ""
"Zusätzlich zu den regulären Elementen können Arrays im PIL-Stil Zeiger "
"enthalten, denen man folgen muss, um zum nächsten Element einer Dimension zu "
"gelangen. Beispielsweise lässt sich das reguläre dreidimensionale C-Array "
"``char v[2][2][3]`` auch als Array aus 2 Zeigern auf 2 zweidimensionale "
"Arrays betrachten: ``char (*v[2])[2][3]``. In der Suboffset-Darstellung "
"können diese beiden Zeiger am Anfang von :c:member:`~Py_buffer.buf` "
"eingebettet werden und auf zwei Arrays vom Typ ``char x[2][3]`` verweisen, "
"die sich an beliebiger Stelle im Speicher befinden können."

#: ../../c-api/buffer.rst:427
msgid ""
"Here is a function that returns a pointer to the element in an N-D array "
"pointed to by an N-dimensional index when there are both non-``NULL`` "
"strides and suboffsets::"
msgstr ""
"Hier ist eine Funktion, die einen Zeiger auf das Element in einem N-"
"dimensionalen Array zurückgibt, auf das ein N-dimensionaler Index verweist, "
"wenn sowohl nicht-``NULL`` e Schritte als auch Teilversätze vorhanden sind::"

#: ../../c-api/buffer.rst:431
msgid ""
"void *get_item_pointer(int ndim, void *buf, Py_ssize_t *strides,\n"
"                       Py_ssize_t *suboffsets, Py_ssize_t *indices) {\n"
"    char *pointer = (char*)buf;\n"
"    int i;\n"
"    for (i = 0; i < ndim; i++) {\n"
"        pointer += strides[i] * indices[i];\n"
"        if (suboffsets[i] >=0 ) {\n"
"            pointer = *((char**)pointer) + suboffsets[i];\n"
"        }\n"
"    }\n"
"    return (void*)pointer;\n"
"}"
msgstr ""
"void *get_item_pointer(int ndim, void *buf, Py_ssize_t *strides,\n"
"                       Py_ssize_t *suboffsets, Py_ssize_t *indices) {\n"
"    char *pointer = (char*)buf;\n"
"    int i;\n"
"    for (i = 0; i < ndim; i++) {\n"
"        pointer += strides[i] * indices[i];\n"
"        if (suboffsets[i] >= 0) {\n"
"            pointer = *((char**)pointer) + suboffsets[i];\n"
"        }\n"
"    }\n"
"    return (void*)pointer;\n"
"}"

#: ../../c-api/buffer.rst:446
msgid "Buffer-related functions"
msgstr "Funktionen im Zusammenhang mit Puffern"

#: ../../c-api/buffer.rst:450
msgid ""
"Return ``1`` if *obj* supports the buffer interface otherwise ``0``.  When "
"``1`` is returned, it doesn't guarantee that :c:func:`PyObject_GetBuffer` "
"will succeed.  This function always succeeds."
msgstr ""
"Gibt „ ``1`` “ zurück, wenn *obj* die Puffer-Schnittstelle unterstützt, "
"andernfalls „ ``0`` “. Wenn „ ``1`` “ zurückgegeben wird, ist nicht "
"garantiert, dass „ :c:func:`PyObject_GetBuffer` “ erfolgreich ist. Diese "
"Funktion ist immer erfolgreich."

#: ../../c-api/buffer.rst:457
msgid ""
"Send a request to *exporter* to fill in *view* as specified by  *flags*. If "
"the exporter cannot provide a buffer of the exact type, it MUST raise :exc:"
"`BufferError`, set ``view->obj`` to ``NULL`` and return ``-1``."
msgstr ""
"Sende eine Anfrage an *exporter*, um *view* gemäß den Angaben in *flags* "
"auszufüllen. Wenn der Exporter keinen Puffer des genau angegebenen Typs "
"bereitstellen kann, MUSS er eine Ausnahme vom Typ „ :exc:`BufferError` “ "
"auslösen, ``view->obj`` auf „ ``NULL`` “ setzen und „ ``-1`` “ zurückgeben."

#: ../../c-api/buffer.rst:462
msgid ""
"On success, fill in *view*, set ``view->obj`` to a new reference to "
"*exporter* and return 0. In the case of chained buffer providers that "
"redirect requests to a single object, ``view->obj`` MAY refer to this object "
"instead of *exporter* (See :ref:`Buffer Object Structures <buffer-structs>`)."
msgstr ""
"Bei Erfolg *view* ausfüllen, ``view->obj`` auf einen neuen Verweis auf "
"*exporter* setzen und 0 zurückgeben. Bei verketteten Puffer-Providern, die "
"Anfragen an ein einzelnes Objekt umleiten, KANN ``view->obj`` statt auf "
"*exporter* auf dieses Objekt verweisen (siehe :ref:`Buffer Object Structures "
"<buffer-structs>`)."

#: ../../c-api/buffer.rst:467
msgid ""
"Successful calls to :c:func:`PyObject_GetBuffer` must be paired with calls "
"to :c:func:`PyBuffer_Release`, similar to :c:func:`malloc` and :c:func:"
"`free`. Thus, after the consumer is done with the buffer, :c:func:"
"`PyBuffer_Release` must be called exactly once."
msgstr ""
"Erfolgreiche Aufrufe von „ :c:func:`PyObject_GetBuffer` “ müssen mit "
"Aufrufen von „ :c:func:`PyBuffer_Release` “ gepaart werden, ähnlich wie bei "
"„ :c:func:`malloc` “ und „ :c:func:`free` “. Nachdem der Verbraucher den "
"Puffer verarbeitet hat, muss daher „ :c:func:`PyBuffer_Release` “ genau "
"einmal aufgerufen werden."

#: ../../c-api/buffer.rst:475
msgid ""
"Release the buffer *view* and release the :term:`strong reference` (i.e. "
"decrement the reference count) to the view's supporting object, ``view-"
">obj``. This function MUST be called when the buffer is no longer being "
"used, otherwise reference leaks may occur."
msgstr ""
"Geben Sie die *Ansicht* des Puffers frei und heben Sie die :term:`starke "
"Referenz <strong reference>` (d. h. verringern Sie die Referenzanzahl) auf "
"das zugehörige Objekt der Ansicht, ``view->obj``, auf. Diese Funktion MUSS "
"aufgerufen werden, wenn der Puffer nicht mehr verwendet wird, da es "
"andernfalls zu Referenzlecks kommen kann."

#: ../../c-api/buffer.rst:480
msgid ""
"It is an error to call this function on a buffer that was not obtained via :"
"c:func:`PyObject_GetBuffer`."
msgstr ""
"Es ist ein Fehler, diese Funktion für einen Puffer aufzurufen, der nicht "
"über „ :c:func:`PyObject_GetBuffer` “ abgerufen wurde."

#: ../../c-api/buffer.rst:486
msgid ""
"Return the implied :c:member:`~Py_buffer.itemsize` from :c:member:"
"`~Py_buffer.format`. On error, raise an exception and return -1."
msgstr ""
"Gibt den impliziten „ :c:member:`~Py_buffer.itemsize` “ aus „ :c:member:"
"`~Py_buffer.format` “ zurück. Bei einem Fehler wird eine Ausnahme ausgelöst "
"und -1 zurückgegeben."

#: ../../c-api/buffer.rst:494
msgid ""
"Return ``1`` if the memory defined by the *view* is C-style (*order* is "
"``'C'``) or Fortran-style (*order* is ``'F'``) :term:`contiguous` or either "
"one (*order* is ``'A'``).  Return ``0`` otherwise.  This function always "
"succeeds."
msgstr ""
"Gibt „ ``1`` “ zurück, wenn der durch *view* definierte Speicher im C-Stil "
"(*order* ist „ ``'C'`` “) oder im Fortran-Stil (*order* ist „ ``'F'`` “) :"
"term:`contiguous` ist oder beides (*order* ist „ ``'A'`` “). Andernfalls "
"gibt die Funktion „ ``0`` “ zurück. Diese Funktion läuft immer erfolgreich "
"ab."

#: ../../c-api/buffer.rst:501
msgid ""
"Get the memory area pointed to by the *indices* inside the given *view*. "
"*indices* must point to an array of ``view->ndim`` indices."
msgstr ""
"Rufe den Speicherbereich ab, auf den die *indices* innerhalb der angegebenen "
"*view* verweisen. *indices* muss auf ein Array von ``view->ndim``-Indizes "
"verweisen."

#: ../../c-api/buffer.rst:507
msgid ""
"Copy contiguous *len* bytes from *buf* to *view*. *order* can be ``'C'`` or "
"``'F'`` or ``'A'`` (for C-style or Fortran-style ordering or either one). "
"``0`` is returned on success, ``-1`` on error."
msgstr ""
"Kopiert *len* zusammenhängende Bytes von *buf* nach *view*. *order* kann "
"``'C'``, ``'F'`` oder ``'A'`` sein (für eine Anordnung im C-Stil, im "
"Fortran-Stil oder für eine von beiden). Bei Erfolg wird ``0`` zurückgegeben, "