# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-11-11 14:15+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\n"

"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"

"teams/5390/pt_BR/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: pt_BR\n"

"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "

"1000000 == 0 ? 1 : 2;\n"

#: ../../c-api/buffer.rst:11

msgid "Buffer Protocol"

msgstr "Protocolo de buffer"

#: ../../c-api/buffer.rst:18

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

"Certos objetos disponíveis no Python envolvem o acesso a um vetor ou "

"*buffer* de memória subjacente. Esses objetos incluem as classes :class:"

"`bytes` e :class:`bytearray` embutidas, e alguns tipos de extensão como :"

"class:`array.array`. As bibliotecas de terceiros podem definir seus próprios "

"tipos para fins especiais, como processamento de imagem ou análise numérica."

#: ../../c-api/buffer.rst:24

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

"Embora cada um desses tipos tenha sua própria semântica, eles compartilham a "

"característica comum de serem suportados por um buffer de memória "

"possivelmente grande. É desejável, em algumas situações, acessar esse buffer "

"diretamente e sem cópia intermediária."

#: ../../c-api/buffer.rst:29

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 fornece essa facilidade no nível C e Python sob a forma de :ref:"

"`protocolo de buffer <bufferobjects>`. Este protocolo tem dois lados:"

#: ../../c-api/buffer.rst:34

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

"do lado do produtor, um tipo pode exportar uma \"interface de buffer\" que "

"permite que objetos desse tipo exponham informações sobre o buffer "

"subjacente. Esta interface é descrita na seção :ref:`buffer-structs`; para "

"Python, consulte :ref:`python-buffer-protocol`."

#: ../../c-api/buffer.rst:39

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

"do lado do consumidor, vários meios estão disponíveis para obter o ponteiro "

"para os dados subjacentes de um objeto (por exemplo, um parâmetro de "

"método). Para Python, consulte :ref:`python-buffer-protocol`."

#: ../../c-api/buffer.rst:43

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

"Objetos simples como :class:`bytes` e :class:`bytearray` expõem seu buffer "

"subjacente em uma forma orientada a byte. Outras formas são possíveis; por "

"exemplo, os elementos expostos por uma :class:`array.array` podem ser "

"valores de vários bytes."

#: ../../c-api/buffer.rst:47

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

"Um exemplo de interface de um consumidor de buffer é o método :meth:`~io."

"BufferedIOBase.write` de objetos arquivo: qualquer objeto que possa exportar "

"uma série de bytes por meio da interface de buffer pode ser gravado em um "

"arquivo. Enquanto o :meth:`!write` precisa apenas de acesso somente de "

"leitura ao conteúdo interno do objeto passado, outros métodos, como :meth:"

"`~io.BufferedIOBase.readinto`, precisam de acesso somente de escrita ao "

"conteúdo interno. A interface de buffer permite que os objetos possam "

"permitir ou rejeitar a exportação para buffers de leitura e escrita ou "

"somente leitura."

#: ../../c-api/buffer.rst:55

msgid ""

"There are two ways for a consumer of the buffer interface to acquire a "

"buffer over a target object:"

msgstr ""

"Existem duas maneiras para um consumidor da interface de buffer adquirir um "

"buffer em um objeto alvo:"

#: ../../c-api/buffer.rst:58

msgid "call :c:func:`PyObject_GetBuffer` with the right parameters;"

msgstr "chamar :c:func:`PyObject_GetBuffer` com os parâmetros certos;"

#: ../../c-api/buffer.rst:60

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

"chamar :c:func:`PyArg_ParseTuple` (ou um dos seus irmãos) com um dos :ref:"

"`códigos de formatação <arg-parsing>` ``y*``, ``w*`` ou ``s*``."

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

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

"Em ambos os casos, :c:func:`PyBuffer_Release` deve ser chamado quando o "

"buffer não é mais necessário. A falta de tal pode levar a vários problemas, "

"tais como vazamentos de recursos."

#: ../../c-api/buffer.rst:69

msgid ""

"The buffer protocol is now accessible in Python, see :ref:`python-buffer-"

"protocol` and :class:`memoryview`."

msgstr ""

"O protocolo de buffer agora está acessível em Python, veja :ref:`python-"

"buffer-protocol` e :class:`memoryview`."

#: ../../c-api/buffer.rst:75

msgid "Buffer structure"

msgstr "Estrutura de Buffer"

#: ../../c-api/buffer.rst:77

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

"As estruturas de buffer (ou simplesmente \"buffers\") são úteis como uma "

"maneira de expor os dados binários de outro objeto para o programador "

"Python. Eles também podem ser usados como um mecanismo de cópia silenciosa. "

"Usando sua capacidade de fazer referência a um bloco de memória, é possível "

"expor facilmente qualquer dado ao programador Python. A memória pode ser uma "

"matriz grande e constante em uma extensão C, pode ser um bloco bruto de "

"memória para manipulação antes de passar para uma biblioteca do sistema "

"operacional, ou pode ser usado para transmitir dados estruturados no formato "

"nativo e formato de memória."

#: ../../c-api/buffer.rst:86

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

"Ao contrário da maioria dos tipos de dados expostos pelo interpretador "

"Python, os buffers não são ponteiros :c:type:`PyObject` mas sim estruturas C "

"simples. Isso permite que eles sejam criados e copiados de forma muito "

"simples. Quando um invólucro genérico em torno de um buffer é necessário, um "

"objeto :ref:`memoryview <memoryview-objects>` pode ser criado."

#: ../../c-api/buffer.rst:92

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

"Para obter instruções curtas sobre como escrever um objeto exportador, "

"consulte :ref:`Buffer Object Structures <buffer-structs>`. Para obter um "

"buffer, veja :c:func:`PyObject_GetBuffer`."

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

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

"Um ponteiro para o início da estrutura lógica descrita pelos campos do "

"buffer. Este pode ser qualquer local dentro do bloco de memória física "

"subjacente do exportador. Por exemplo, com negativo :c:member:`~Py_buffer."

"strides` o valor pode apontar para o final do bloco de memória."

#: ../../c-api/buffer.rst:105

msgid ""

"For :term:`contiguous` arrays, the value points to the beginning of the "

"memory block."

msgstr ""

"Para vetores :term:`contíguos <contiguous>`, o valor aponta para o início do "

"bloco de memória."

#: ../../c-api/buffer.rst:110

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

"Uma nova referência ao objeto sendo exporta. A referência pertence ao "

"consumidor e é automaticamente liberada (por exemplo, a contagem de "

"referências é decrementada) e é atribuída para ``NULL`` por :c:func:"

"`PyBuffer_Release`. O campo equivale ao valor de retorno de qualquer função "

"padrão da API C."

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

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

"Como um caso especial, para buffers *temporários* que são encapsulados por :"

"c:func:`PyMemoryView_FromBuffer` ou :c:func:`PyBuffer_FillInfo` esse campo é "

"``NULL``. Em geral, objetos exportadores NÃO DEVEM usar esse esquema."

#: ../../c-api/buffer.rst:124

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``. Para matrizes contíguas, este é o comprimento "

"do bloco de memória subjacente. Para matrizes não contíguas, é o comprimento "

"que a estrutura lógica teria se fosse copiado para uma representação "

"contígua."

#: ../../c-api/buffer.rst:129

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

"Acessando ``((char *)buf)[0] up to ((char *)buf)[len-1]`` só é válido se o "

"buffer tiver sido obtido por uma solicitação que garanta a contiguidade. Na "

"maioria dos casos, esse pedido será :c:macro:`PyBUF_SIMPLE` ou :c:macro:"

"`PyBUF_WRITABLE`."

#: ../../c-api/buffer.rst:135

msgid ""

"An indicator of whether the buffer is read-only. This field is controlled by "

"the :c:macro:`PyBUF_WRITABLE` flag."

msgstr ""

"Um indicador de se o buffer é somente leitura. Este campo é controlado pelo "

"sinalizador :c:macro:`PyBUF_WRITABLE`."

#: ../../c-api/buffer.rst:140

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

"O tamanho do item em bytes de um único elemento. O mesmo que o valor de :"

"func:`struct.calcsize` chamado em valores não ``NULL`` de :c:member:"

"`~Py_buffer.format`."

#: ../../c-api/buffer.rst:143

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

"Exceção importante: Se um consumidor requisita um buffer sem sinalizador :c:"

"macro:`PyBUF_FORMAT`, :c:member:`~Py_buffer.format` será definido como "

"``NULL``, mas :c:member:`~Py_buffer.itemsize` ainda terá seu valor para o "

"formato original."

#: ../../c-api/buffer.rst:148

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

"Se :c:member:`~Py_buffer.shape` está presente, a igualdade ``product(shape) "

"* itemsize == len`` ainda é válida e o usuário pode usar :c:member:"

"`~Py_buffer.itemsize` para navegar o buffer."

#: ../../c-api/buffer.rst:152

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

"Se :c:member:`~Py_buffer.shape` é ``NULL`` como resultado de uma :c:macro:"

"`PyBUF_SIMPLE` ou uma requisição :c:macro:`PyBUF_WRITABLE`, o consumidor "

"deve ignorar :c:member:`~Py_buffer.itemsize` e presumir ``itemsize == 1``."

#: ../../c-api/buffer.rst:158

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

"Uma string terminada por *NULL* no estilo de sintaxe de módulo :mod:`struct` "

"descrevendo os conteúdos de um único item. Se isso é ``NULL``, ``\"B\"`` "

"(unsigned bytes) é presumido."

#: ../../c-api/buffer.rst:162

msgid "This field is controlled by the :c:macro:`PyBUF_FORMAT` flag."

msgstr "Este campo é controlado pelo sinalizador :c:macro:`PyBUF_FORMAT`."

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

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

"O número de dimensões de memória representado como um array n-dimensional. "

"Se for ``0``, :c:member:`~Py_buffer.buf` aponta para um único elemento "

"representando um escalar. Neste caso, :c:member:`~Py_buffer.shape`, :c:"

"member:`~Py_buffer.strides` e :c:member:`~Py_buffer.suboffsets` DEVEM ser "

"``NULL``. O número máximo de dimensões é dado por :c:macro:`PyBUF_MAX_NDIM`."

#: ../../c-api/buffer.rst:174

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

"Uma matriz de :c:type:`Py_ssize_t` do comprimento :c:member:`~Py_buffer."

"ndim` indicando a forma da memória como uma matriz n-dimensional. Observe "

"que a forma ``shape[0] * ... * shape[ndim-1] * itemsize`` DEVE ser igual a :"

"c:member:`~Py_buffer.len`."

#: ../../c-api/buffer.rst:179

msgid ""

"Shape values are restricted to ``shape[n] >= 0``. The case ``shape[n] == 0`` "

"requires special attention. See `complex arrays`_ for further information."

msgstr ""

"Os valores da forma são restritos a ``shape[n] >= 0``. The case ``shape[n] "

"== 0`` requer atenção especial. Veja `complex arrays`_ para mais informações."

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

msgid "The shape array is read-only for the consumer."

msgstr "A forma de acesso a matriz é de somente leitura para o usuário."

#: ../../c-api/buffer.rst:187

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

"Um vetor de :c:type:`Py_ssize_t` de comprimento :c:member:`~Py_buffer.ndim` "

"dando o número de bytes para saltar para obter um novo elemento em cada "

"dimensão."

#: ../../c-api/buffer.rst:191

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

"Os valores de Stride podem ser qualquer número inteiro. Para arrays "

"regulares, os passos são geralmente positivos, mas um consumidor DEVE ser "

"capaz de lidar com o caso ``strides[n] <= 0``. Veja `complex arrays`_ para "

"mais informações."

#: ../../c-api/buffer.rst:195

msgid "The strides array is read-only for the consumer."

msgstr "A matriz de passos é somente leitura para o consumidor."

#: ../../c-api/buffer.rst:199

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

"Uma matriz de :c:type:`Py_ssize_t` de comprimento :c:member:`~Py_buffer."

"ndim`. Se ``suboffsets[n] >= 0``, os valores armazenados ao longo da n-ésima "

"dimensão são ponteiros e o valor suboffset determina quantos bytes para "

"adicionar a cada ponteiro após desreferenciar. Um valor de suboffset que é "

"negativo indica que não deve ocorrer desreferenciação (caminhando em um "

"bloco de memória contíguo)."

#: ../../c-api/buffer.rst:206

msgid ""

"If all suboffsets are negative (i.e. no de-referencing is needed), then this "

"field must be ``NULL`` (the default value)."

msgstr ""

"Se todos os subconjuntos forem negativos (ou seja, não é necessário fazer "

"referência), então este campo deve ser ``NULL`` (o valor padrão)."

#: ../../c-api/buffer.rst:209

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

"Esse tipo de representação de matriz é usado pela Python Imaging Library "

"(PIL). Veja `complex arrays`_ para obter mais informações sobre como acessar "

"elementos dessa matriz.a matriz."

#: ../../c-api/buffer.rst:213

msgid "The suboffsets array is read-only for the consumer."

msgstr "A matriz de subconjuntos é somente leitura para o consumidor."

#: ../../c-api/buffer.rst:217

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

"Isso é para uso interno pelo objeto exportador. Por exemplo, isso pode ser "

"re-moldado como um número inteiro pelo exportador e usado para armazenar "

"bandeiras sobre se os conjuntos de forma, passos e suboffsets devem ou não "

"ser liberados quando o buffer é liberado. O consumidor NÃO DEVE alterar esse "

"valor."

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

msgid "Constants:"

msgstr "Constantes:"

#: ../../c-api/buffer.rst:228

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

"O número máximo de dimensões que a memória representa. Exportadores DEVEM "

"respeitar esse limite, consumidores de buffers multidimensionais DEVEM ser "

"capazes de lidar com até :c:macro:`!PyBUF_MAX_NDIM` dimensões. Atualmente "

"definido como 64."

#: ../../c-api/buffer.rst:237

msgid "Buffer request types"

msgstr "Tipos de solicitação do buffer"

#: ../../c-api/buffer.rst:239

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

"Os buffers geralmente são obtidos enviando uma solicitação de buffer para um "

"objeto exportador via :c:func:`PyObject_GetBuffer`. Uma vez que a "

"complexidade da estrutura lógica da memória pode variar drasticamente, o "

"consumidor usa o argumento *flags* para especificar o tipo de buffer exato "

"que pode manipular."

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

msgid ""

"All :c:type:`Py_buffer` fields are unambiguously defined by the request type."

msgstr ""

"Todos os campos :c:type:`Py_buffer` são definidos de forma não-ambígua pelo "

"tipo de requisição."

#: ../../c-api/buffer.rst:248

msgid "request-independent fields"

msgstr "campos independentes do pedido"

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

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

"Os seguintes campos não são influenciados por *flags* e devem sempre ser "

"preenchidos com os valores corretos: :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:254

msgid "readonly, format"

msgstr "apenas em formato"

#: ../../c-api/buffer.rst:258

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

"Controla o campo :c:member:`~Py_buffer.readonly` . Se configurado, o "

"exportador DEVE fornecer um buffer gravável ou então relatar falha. Do "

"contrário, o exportador PODE fornecer um buffer somente leitura ou um buffer "

"gravável , mas a escolha DEVE ser consistente para todos os consumidores. "

"Por exemplo, :c:expr:`PyBUF_SIMPLE | PyBUF_WRITABLE` pode ser usado para "

"requisitar um buffer simples gravável."

#: ../../c-api/buffer.rst:266

msgid "This is a :term:`soft deprecated` alias to :c:macro:`PyBUF_WRITABLE`."

msgstr ""

"Este é um apelido :term:`suavemente descontinuado` para :c:macro:"

"`PyBUF_WRITABLE`."

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

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

"Controla o campo :c:member:`~Py_buffer.format`. Se configurado, este campo "

"DEVE ser preenchido corretamente. Caso contrário, este campo DEVE ser "

"``NULL``."

#: ../../c-api/buffer.rst:274

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` pode ser \\|'d para qualquer um dos sinalizadores "

"na próxima seção. Uma vez que :c:macro:`PyBUF_WRITABLE` é definido como 0, :"

"c:macro:`PyBUF_WRITABLE` pode ser usado como uma bandeira autônoma para "

"solicitar um buffer simples gravável."

#: ../../c-api/buffer.rst:278

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` deve ser \\|'d para qualquer um dos sinalizadores "

"exceto :c:macro:`PyBUF_SIMPLE`, uma vez que este já indica que o formato "

"``B`` (unsigned bytes). :c:macro:`!PyBUF_FORMAT` não pode ser utilizado "

"sozinho."

#: ../../c-api/buffer.rst:284

msgid "shape, strides, suboffsets"

msgstr "forma, avanços, suboffsets"

#: ../../c-api/buffer.rst:286

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

"As bandeiras que controlam a estrutura lógica da memória estão listadas em "

"ordem decrescente de complexidade. Observe que cada bandeira contém todos os "

"bits das bandeiras abaixo."

#: ../../c-api/buffer.rst:293 ../../c-api/buffer.rst:317

#: ../../c-api/buffer.rst:342

msgid "Request"

msgstr "Solicitação"

#: ../../c-api/buffer.rst:293 ../../c-api/buffer.rst:317

#: ../../c-api/buffer.rst:342

msgid "shape"

msgstr "Forma"

#: ../../c-api/buffer.rst:293 ../../c-api/buffer.rst:317

#: ../../c-api/buffer.rst:342

msgid "strides"

msgstr "Avanços"

#: ../../c-api/buffer.rst:293 ../../c-api/buffer.rst:317

#: ../../c-api/buffer.rst:342

msgid "suboffsets"

msgstr "subconjuntos"

#: ../../c-api/buffer.rst:295 ../../c-api/buffer.rst:297

#: ../../c-api/buffer.rst:299 ../../c-api/buffer.rst:319

#: ../../c-api/buffer.rst:321 ../../c-api/buffer.rst:323

#: ../../c-api/buffer.rst:325 ../../c-api/buffer.rst:344

#: ../../c-api/buffer.rst:346 ../../c-api/buffer.rst:348

#: ../../c-api/buffer.rst:350 ../../c-api/buffer.rst:352

#: ../../c-api/buffer.rst:354 ../../c-api/buffer.rst:356

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

msgid "yes"

msgstr "sim"

#: ../../c-api/buffer.rst:295 ../../c-api/buffer.rst:344

#: ../../c-api/buffer.rst:346

msgid "if needed"

msgstr "se necessário"

#: ../../c-api/buffer.rst:297 ../../c-api/buffer.rst:299

#: ../../c-api/buffer.rst:301 ../../c-api/buffer.rst:319

#: ../../c-api/buffer.rst:321 ../../c-api/buffer.rst:323

#: ../../c-api/buffer.rst:325 ../../c-api/buffer.rst:348

#: ../../c-api/buffer.rst:350 ../../c-api/buffer.rst:352

#: ../../c-api/buffer.rst:354 ../../c-api/buffer.rst:356

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

msgid "NULL"

msgstr "NULL"

#: ../../c-api/buffer.rst:308

msgid "contiguity requests"

msgstr "requisições contíguas"

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

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

":term:`contiguity <contiguous>` do C ou Fortran podem ser explicitamente "

"solicitadas, com ou sem informação de avanço. Sem informação de avanço, o "

"buffer deve ser C-contíguo."

#: ../../c-api/buffer.rst:317 ../../c-api/buffer.rst:342

msgid "contig"

msgstr "contig"

#: ../../c-api/buffer.rst:319 ../../c-api/buffer.rst:325

#: ../../c-api/buffer.rst:356 ../../c-api/buffer.rst:358

msgid "C"

msgstr "C"

#: ../../c-api/buffer.rst:321

msgid "F"

msgstr "F"

#: ../../c-api/buffer.rst:323

msgid "C or F"

msgstr "C ou F"

#: ../../c-api/buffer.rst:325

msgid ":c:macro:`PyBUF_ND`"

msgstr ":c:macro:`PyBUF_ND`"

#: ../../c-api/buffer.rst:330

msgid "compound requests"

msgstr "requisições compostas"

#: ../../c-api/buffer.rst:332

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

"Todas as requisições possíveis foram completamente definidas por alguma "

"combinação dos sinalizadores na seção anterior. Por conveniência, o "

"protocolo do buffer fornece combinações frequentemente utilizadas como "

"sinalizadores únicos."

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

msgid ""

"In the following table *U* stands for undefined contiguity. The consumer "

"would have to call :c:func:`PyBuffer_IsContiguous` to determine contiguity."

msgstr ""

"Na seguinte tabela *U* significa contiguidade indefinida. O consumidor deve "

"chamar :c:func:`PyBuffer_IsContiguous` para determinar a contiguidade."

#: ../../c-api/buffer.rst:342

msgid "readonly"

msgstr "readonly"

#: ../../c-api/buffer.rst:342

msgid "format"

msgstr "formato"

#: ../../c-api/buffer.rst:344 ../../c-api/buffer.rst:346

#: ../../c-api/buffer.rst:348 ../../c-api/buffer.rst:350

#: ../../c-api/buffer.rst:352 ../../c-api/buffer.rst:354

msgid "U"

msgstr "U"

#: ../../c-api/buffer.rst:344 ../../c-api/buffer.rst:348

#: ../../c-api/buffer.rst:352 ../../c-api/buffer.rst:356

msgid "0"

msgstr "0"

#: ../../c-api/buffer.rst:346 ../../c-api/buffer.rst:350

#: ../../c-api/buffer.rst:354 ../../c-api/buffer.rst:358

msgid "1 or 0"

msgstr "1 ou 0"

#: ../../c-api/buffer.rst:363

msgid "Complex arrays"

msgstr "Vetores Complexos"

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

msgid "NumPy-style: shape and strides"

msgstr "Estilo NumPy: forma e avanços"

#: ../../c-api/buffer.rst:368

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

"A estrutura lógica de vetores do estilo NumPy é definida por :c:member:"

"`~Py_buffer.itemsize`, :c:member:`~Py_buffer.ndim`, :c:member:`~Py_buffer."

"shape` e :c:member:`~Py_buffer.strides`."

#: ../../c-api/buffer.rst:371

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

"Se ``ndim == 0``, a localização da memória apontada para :c:member:"

"`~Py_buffer.buf` é interpretada como um escalar de tamanho :c:member:"

"`~Py_buffer.itemsize`. Nesse caso, ambos :c:member:`~Py_buffer.shape` e :c:"

"member:`~Py_buffer.strides` são ``NULL``."

#: ../../c-api/buffer.rst:375

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

"Se :c:member:`~Py_buffer.strides` é ``NULL``, o vetor é interpretado como um "

"vetor C n-dimensional padrão. Caso contrário, o consumidor deve acessar um "

"vetor n-dimensional como a seguir:"

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

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:385

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

"Como notado acima, :c:member:`~Py_buffer.buf` pode apontar para qualquer "

"localização dentro do bloco de memória em si. Um exportador pode verificar a "

"validade de um buffer com essa função:"

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

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"

" \"\"\"Verifica se os parâmetros representa um vetor válido dentro\n"

" dos limites da memória alocada:\n"

" char *mem: início do bloco de memória física\n"

" memlen: comprimento do bloco de memória física\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:419

msgid "PIL-style: shape, strides and suboffsets"

msgstr "Estilo-PIL: forma, avanços e suboffsets"

#: ../../c-api/buffer.rst:421

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

"Além dos itens normais, uma matriz em estilo PIL pode conter ponteiros que "

"devem ser seguidos para se obter o próximo elemento em uma dimensão. Por "

"exemplo, a matriz tridimensional em C ``char v[2][2][3]`` também pode ser "

"vista como um vetor de 2 ponteiros para duas matrizes bidimensionais: ``char "

"(*v[2])[2][3]``. Na representação por suboffsets, esses dois ponteiros podem "

"ser embutidos no início de :c:member:`~Py_buffer.buf`, apontando para duas "

"matrizes ``char x[2][3]`` que podem estar localizadas em qualquer lugar na "

"memória."

#: ../../c-api/buffer.rst:430

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

"Esta é uma função que retorna um ponteiro para o elemento em uma matriz N-D "

"apontada por um índice N-dimensional onde existem ambos passos e "

"subconjuntos não-``NULL``::"

#: ../../c-api/buffer.rst:434

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:449

msgid "Buffer-related functions"

msgstr "Funções relacionadas ao Buffer"

#: ../../c-api/buffer.rst:453

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

"Retorna ``1`` se *obj* oferece suporte à interface de buffer, se não, ``0``. "

"Quando ``1`` é retornado, isso não garante que :c:func:`PyObject_GetBuffer` "

"será bem sucedida. Esta função é sempre bem sucedida."

#: ../../c-api/buffer.rst:460

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

"Envia uma requisição ao *exporter* para preencher a *view* conforme "

"especificado por *flags*. Se o exporter não conseguir prover um buffer do "

"tipo especificado, ele DEVE levantar :exc:`BufferError`, definir ``view-"

">obj`` para ``NULL`` e retornar ``-1``."

#: ../../c-api/buffer.rst:465

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

"Em caso de sucesso, preenche *view*, define ``view->obj`` para uma nova "

"referência para *exporter* e retorna 0. No caso de provedores de buffer "

"encadeados que redirecionam requisições para um único objeto, ``view->obj`` "

"DEVE se referir a este objeto em vez de *exporter* (Veja :ref:`Buffer Object "

"Structures <buffer-structs>`)."

#: ../../c-api/buffer.rst:470

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

"Chamadas bem sucedidas para :c:func:`PyObject_GetBuffer` devem ser "

"emparelhadas a chamadas para :c:func:`PyBuffer_Release`, similar para :c:"

"func:`malloc` e :c:func:`free`. Assim, após o consumidor terminar com o "

"buffer, :c:func:`PyBuffer_Release` deve ser chamado exatamente uma vez."

#: ../../c-api/buffer.rst:478

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

"Libera o buffer de *view* e libera o :term:`strong reference` (por exemplo, "

"decrementa o contador de referências) para o objeto de suporte da view, "

"``view->obj``. Esta função DEVE ser chamada quando o buffer não estiver mais "

"sendo usado, ou o vazamento de referências pode acontecer."

#: ../../c-api/buffer.rst:483

msgid ""

"It is an error to call this function on a buffer that was not obtained via :"

"c:func:`PyObject_GetBuffer`."

msgstr ""

"É um erro chamar essa função em um buffer que não foi obtido via :c:func:"

"`PyObject_GetBuffer`."

#: ../../c-api/buffer.rst:489

msgid ""

"Return the implied :c:member:`~Py_buffer.itemsize` from :c:member:"

"`~Py_buffer.format`. On error, raise an exception and return -1."

msgstr ""

"Retorna o :c:member:`~Py_buffer.itemsize` implícito de :c:member:`~Py_buffer."

"format`. Em erro, levantar e exceção e retornar -1."

#: ../../c-api/buffer.rst:497

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

"Retorna ``1`` se a memória definida pela *view* é :term:`contígua "

"<contíguo>` no estilo C (*order* é ``'C'``) ou no estilo Fortran (*order* é "

"``'F'``) ou qualquer outra (*order* é ``'A'``). Retorna ``0`` caso "

"contrário. Essa função é sempre bem sucedida."

#: ../../c-api/buffer.rst:504

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

"Recebe a área de memória apontada pelos *indices* dentro da *view* dada. "

"*indices* deve apontar para um array de ``view->ndim`` índices."

#: ../../c-api/buffer.rst:510

msgid ""

"Copy contiguous *len* bytes from *buf* to *view*. *fort* can be ``'C'`` or "

"``'F'`` (for C-style or Fortran-style ordering). ``0`` is returned on "

"success, ``-1`` on error."

msgstr ""

"Copia *len* bytes contíguos de *buf* para *view*. *fort* pode ser ``'C'`` ou "

"``'F'`` (para ordenação estilo C ou estilo Fortran). Retorna ``0`` em caso "

"de sucesso e ``-1`` em caso de erro."

#: ../../c-api/buffer.rst:517

msgid ""

"Copy *len* bytes from *src* to its contiguous representation in *buf*. "

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

"Copia *len* bytes de *src* para sua representação contígua em *buf*. *order* "

"pode ser ``'C'`` ou ``'F'`` ou ``'A'`` (para ordenação estilo C, Fortran ou "

"qualquer uma). O retorno é ``0`` em caso de sucesso e ``-1`` em caso de "

"falha."

#: ../../c-api/buffer.rst:521

msgid "This function fails if *len* != *src->len*."

msgstr "Esta função falha se *len* != *src->len*."