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

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

"Rufe „ :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 findest du "

"unter :ref:`Buffer Object Structures <buffer-structs>`. Informationen zum "

"Abrufen eines Puffers findest du 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. Beachte, 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. Beachte, 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 ""

"Gib die *Ansicht* des Puffers frei und hebe die :term:`starke Referenz "

"<strong reference>` (d. h. verringere 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 "