# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, 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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-09-22 20:37+0000\n"

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

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

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

"teams/5390/pt_BR/)\n"

"Language: pt_BR\n"

"MIME-Version: 1.0\n"

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

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

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

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

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

msgid "Unicode Objects and Codecs"

msgstr "Objetos Unicode e Codecs"

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

msgid "Unicode Objects"

msgstr "Objetos Unicode"

#: ../../c-api/unicode.rst:14

msgid ""

"Since the implementation of :pep:`393` in Python 3.3, Unicode objects "

"internally use a variety of representations, in order to allow handling the "

"complete range of Unicode characters while staying memory efficient. There "

"are special cases for strings where all code points are below 128, 256, or "

"65536; otherwise, code points must be below 1114112 (which is the full "

"Unicode range)."

msgstr ""

"Desde a implementação da :pep:`393` no Python 3.3, os objetos Unicode usam "

"internamente uma variedade de representações para permitir o processamento "

"de toda a gama de caracteres Unicode, mantendo a eficiência de memória. Há "

"casos especiais para strings em que todos os pontos de código estão abaixo "

"de 128, 256 ou 65536; caso contrário, os pontos de código devem estar abaixo "

"de 1114112 (que é a gama completa de caracteres Unicode)."

#: ../../c-api/unicode.rst:20

msgid ""

":c:expr:`Py_UNICODE*` and UTF-8 representations are created on demand and "

"cached in the Unicode object. The :c:expr:`Py_UNICODE*` representation is "

"deprecated and inefficient."

msgstr ""

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

msgid ""

"Due to the transition between the old APIs and the new APIs, Unicode objects "

"can internally be in two states depending on how they were created:"

msgstr ""

#: ../../c-api/unicode.rst:27

msgid ""

"\"canonical\" Unicode objects are all objects created by a non-deprecated "

"Unicode API. They use the most efficient representation allowed by the "

"implementation."

msgstr ""

#: ../../c-api/unicode.rst:31

msgid ""

"\"legacy\" Unicode objects have been created through one of the deprecated "

"APIs (typically :c:func:`PyUnicode_FromUnicode`) and only bear the :c:expr:"

"`Py_UNICODE*` representation; you will have to call :c:func:"

"`PyUnicode_READY` on them before calling any other API."

msgstr ""

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

msgid ""

"The \"legacy\" Unicode object will be removed in Python 3.12 with deprecated "

"APIs. All Unicode objects will be \"canonical\" since then. See :pep:`623` "

"for more information."

msgstr ""

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

msgid "Unicode Type"

msgstr "Tipo Unicode"

#: ../../c-api/unicode.rst:45

msgid ""

"These are the basic Unicode object types used for the Unicode implementation "

"in Python:"

msgstr ""

"Estes são os tipos básicos de objetos Unicode usados para a implementação "

"Unicode em Python:"

#: ../../c-api/unicode.rst:52

msgid ""

"These types are typedefs for unsigned integer types wide enough to contain "

"characters of 32 bits, 16 bits and 8 bits, respectively. When dealing with "

"single Unicode characters, use :c:type:`Py_UCS4`."

msgstr ""

"Esses tipos são definições de tipo para tipos inteiros sem sinal, amplos o "

"suficiente para conter caracteres de 32 bits, 16 bits e 8 bits, "

"respectivamente. Ao lidar com caracteres Unicode simples, use :c:type:"

"`Py_UCS4`."

#: ../../c-api/unicode.rst:61

msgid ""

"This is a typedef of :c:type:`wchar_t`, which is a 16-bit type or 32-bit "

"type depending on the platform."

msgstr ""

"Este é um typedef de :c:type:`wchar_t`, que é um tipo de 16 bits ou 32 bits, "

"dependendo da plataforma."

#: ../../c-api/unicode.rst:64

msgid ""

"In previous versions, this was a 16-bit type or a 32-bit type depending on "

"whether you selected a \"narrow\" or \"wide\" Unicode version of Python at "

"build time."

msgstr ""

"Em versões anteriores, esse era um tipo de 16 bits ou de 32 bits, dependendo "

"se você selecionava uma versão Unicode \"estreita\" ou \"ampla\" do Python "

"no momento da construção."

#: ../../c-api/unicode.rst:74

msgid ""

"These subtypes of :c:type:`PyObject` represent a Python Unicode object. In "

"almost all cases, they shouldn't be used directly, since all API functions "

"that deal with Unicode objects take and return :c:type:`PyObject` pointers."

msgstr ""

"Esses subtipos de :c:type:`PyObject` representam um objeto Unicode do "

"Python. Em quase todos os casos, eles não devem ser usados diretamente, pois "

"todas as funções da API que lidam com objetos Unicode recebem e retornam "

"ponteiros :c:type:`PyObject`."

#: ../../c-api/unicode.rst:83

msgid ""

"This instance of :c:type:`PyTypeObject` represents the Python Unicode type. "

"It is exposed to Python code as ``str``."

msgstr ""

#: ../../c-api/unicode.rst:87

msgid ""

"The following APIs are C macros and static inlined functions for fast checks "

"and access to internal read-only data of Unicode objects:"

msgstr ""

"As seguintes APIs são macros C e funções estáticas embutidas para "

"verificações rápidas e acesso a dados internos somente leitura de objetos "

"Unicode:"

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

msgid ""

"Return true if the object *obj* is a Unicode object or an instance of a "

"Unicode subtype. This function always succeeds."

msgstr ""

"Retorna verdadeiro se o objeto *obj* for um objeto Unicode ou uma instância "

"de um subtipo Unicode. Esta função sempre tem sucesso."

#: ../../c-api/unicode.rst:98

msgid ""

"Return true if the object *obj* is a Unicode object, but not an instance of "

"a subtype. This function always succeeds."

msgstr ""

"Retorna verdadeiro se o objeto *obj* for um objeto Unicode, mas não uma "

"instância de um subtipo. Esta função sempre tem sucesso."

#: ../../c-api/unicode.rst:104

msgid ""

"Ensure the string object *o* is in the \"canonical\" representation. This "

"is required before using any of the access macros described below."

msgstr ""

#: ../../c-api/unicode.rst:109

msgid ""

"Returns ``0`` on success and ``-1`` with an exception set on failure, which "

"in particular happens if memory allocation fails."

msgstr ""

#: ../../c-api/unicode.rst:115

msgid "This API will be removed with :c:func:`PyUnicode_FromUnicode`."

msgstr ""

#: ../../c-api/unicode.rst:120

msgid ""

"Return the length of the Unicode string, in code points. *unicode* has to "

"be a Unicode object in the \"canonical\" representation (not checked)."

msgstr ""

"Retorna o comprimento da string Unicode, em pontos de código. *unicode* deve "

"ser um objeto Unicode na representação \"canônica\" (não marcado)."

#: ../../c-api/unicode.rst:130

msgid ""

"Return a pointer to the canonical representation cast to UCS1, UCS2 or UCS4 "

"integer types for direct character access. No checks are performed if the "

"canonical representation has the correct character size; use :c:func:"

"`PyUnicode_KIND` to select the right macro. Make sure :c:func:"

"`PyUnicode_READY` has been called before accessing this."

msgstr ""

#: ../../c-api/unicode.rst:144

msgid "Return values of the :c:func:`PyUnicode_KIND` macro."

msgstr "Valores de retorno da macro :c:func:`PyUnicode_KIND`."

#: ../../c-api/unicode.rst:149

msgid "``PyUnicode_WCHAR_KIND`` is deprecated."

msgstr ""

#: ../../c-api/unicode.rst:154

msgid ""

"Return one of the PyUnicode kind constants (see above) that indicate how "

"many bytes per character this Unicode object uses to store its data. "

"*unicode* has to be a Unicode object in the \"canonical\" representation "

"(not checked)."

msgstr ""

"Retorna uma das constantes do tipo PyUnicode (veja acima) que indicam "

"quantos bytes por caractere este objeto Unicode usa para armazenar seus "

"dados. *unicode* precisa ser um objeto Unicode na representação "

"\"canônica\" (não marcado)."

#: ../../c-api/unicode.rst:165

msgid ""

"Return a void pointer to the raw Unicode buffer. *unicode* has to be a "

"Unicode object in the \"canonical\" representation (not checked)."

msgstr ""

"Retorna um ponteiro vazio para o buffer Unicode bruto. *unicode* deve ser um "

"objeto Unicode na representação \"canônica\" (não marcado)."

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

msgid ""

"Write into a canonical representation *data* (as obtained with :c:func:"

"`PyUnicode_DATA`). This function performs no sanity checks, and is intended "

"for usage in loops. The caller should cache the *kind* value and *data* "

"pointer as obtained from other calls. *index* is the index in the string "

"(starts at 0) and *value* is the new code point value which should be "

"written to that location."

msgstr ""

"Escreva em uma representação canônica *data* (conforme obtido com :c:func:"

"`PyUnicode_DATA`). Esta função não realiza verificações de sanidade e "

"destina-se ao uso em laços. O chamador deve armazenar em cache o valor de "

"*type* e o ponteiro *data* conforme obtidos de outras chamadas. *índice* é o "

"índice na string (começa em 0) e *value* é o novo valor do ponto de código "

"que deve ser escrito naquele local."

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

msgid ""

"Read a code point from a canonical representation *data* (as obtained with :"

"c:func:`PyUnicode_DATA`). No checks or ready calls are performed."

msgstr ""

"Lê um ponto de código de uma representação canônica *data* (conforme obtido "

"com :c:func:`PyUnicode_DATA`). Nenhuma verificação ou chamada pronta é "

"realizada."

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

msgid ""

"Read a character from a Unicode object *unicode*, which must be in the "

"\"canonical\" representation. This is less efficient than :c:func:"

"`PyUnicode_READ` if you do multiple consecutive reads."

msgstr ""

"Lê um caractere de um objeto Unicode *unicode*, que deve estar na "

"representação \"canônica\". Isso é menos eficiente do que :c:func:"

"`PyUnicode_READ` se você fizer várias leituras consecutivas."

#: ../../c-api/unicode.rst:204

msgid ""

"Return the maximum code point that is suitable for creating another string "

"based on *unicode*, which must be in the \"canonical\" representation. This "

"is always an approximation but more efficient than iterating over the string."

msgstr ""

"Retorna o ponto de código máximo adequado para criar outra string baseada em "

"*unicode*, que deve estar na representação \"canônica\". Isso é sempre uma "

"aproximação, mas é mais eficiente do que iterar sobre a string."

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

msgid ""

"Return the size of the deprecated :c:type:`Py_UNICODE` representation, in "

"code units (this includes surrogate pairs as 2 units). *unicode* has to be "

"a Unicode object (not checked)."

msgstr ""

#: ../../c-api/unicode.rst:219 ../../c-api/unicode.rst:229

#: ../../c-api/unicode.rst:761

msgid ""

"Part of the old-style Unicode API, please migrate to using :c:func:"

"`PyUnicode_GET_LENGTH`."

msgstr ""

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

msgid ""

"Return the size of the deprecated :c:type:`Py_UNICODE` representation in "

"bytes. *unicode* has to be a Unicode object (not checked)."

msgstr ""

#: ../../c-api/unicode.rst:235

msgid ""

"Return a pointer to a :c:type:`Py_UNICODE` representation of the object. "

"The returned buffer is always terminated with an extra null code point. It "

"may also contain embedded null code points, which would cause the string to "

"be truncated when used in most C functions. The ``AS_DATA`` form casts the "

"pointer to :c:expr:`const char *`. The *unicode* argument has to be a "

"Unicode object (not checked)."

msgstr ""

#: ../../c-api/unicode.rst:242

msgid ""

"This function is now inefficient -- because in many cases the :c:type:"

"`Py_UNICODE` representation does not exist and needs to be created -- and "

"can fail (return ``NULL`` with an exception set). Try to port the code to "

"use the new :c:func:`PyUnicode_nBYTE_DATA` macros or use :c:func:"

"`PyUnicode_WRITE` or :c:func:`PyUnicode_READ`."

msgstr ""

#: ../../c-api/unicode.rst:251

msgid ""

"Part of the old-style Unicode API, please migrate to using the :c:func:"

"`PyUnicode_nBYTE_DATA` family of macros."

msgstr ""

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

msgid ""

"Return ``1`` if the string is a valid identifier according to the language "

"definition, section :ref:`identifiers`. Return ``0`` otherwise."

msgstr ""

"Retorna ``1`` se a string é um identificador válido conforme a definição da "

"linguagem, seção :ref:`identifiers`. Do contrário, retorna ``0``."

#: ../../c-api/unicode.rst:259

msgid ""

"The function does not call :c:func:`Py_FatalError` anymore if the string is "

"not ready."

msgstr ""

"A função não chama mais :c:func:`Py_FatalError` se a string não estiver "

"pronta."

#: ../../c-api/unicode.rst:265

msgid "Unicode Character Properties"

msgstr "Propriedade de caracteres Unicode"

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

msgid ""

"Unicode provides many different character properties. The most often needed "

"ones are available through these macros which are mapped to C functions "

"depending on the Python configuration."

msgstr ""

"O Unicode fornece muitas propriedades de caracteres diferentes. As mais "

"frequentemente necessárias estão disponíveis por meio destas macros, que são "

"mapeadas para funções C, dependendo da configuração do Python."

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

msgid ""

"Return ``1`` or ``0`` depending on whether *ch* is a whitespace character."

msgstr ""

"Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere de espaço em branco."

#: ../../c-api/unicode.rst:279

msgid ""

"Return ``1`` or ``0`` depending on whether *ch* is a lowercase character."

msgstr "Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere minúsculo."

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

msgid ""

"Return ``1`` or ``0`` depending on whether *ch* is an uppercase character."

msgstr "Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere maiúsculo."

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

msgid ""

"Return ``1`` or ``0`` depending on whether *ch* is a titlecase character."

msgstr "Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere em TitleCase."

#: ../../c-api/unicode.rst:294

msgid ""

"Return ``1`` or ``0`` depending on whether *ch* is a linebreak character."

msgstr ""

"Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere de quebra de linha."

#: ../../c-api/unicode.rst:299

msgid "Return ``1`` or ``0`` depending on whether *ch* is a decimal character."

msgstr "Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere decimal."

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

msgid "Return ``1`` or ``0`` depending on whether *ch* is a digit character."

msgstr "Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere de dígito."

#: ../../c-api/unicode.rst:309

msgid "Return ``1`` or ``0`` depending on whether *ch* is a numeric character."

msgstr "Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere numérico."

#: ../../c-api/unicode.rst:314

msgid ""

"Return ``1`` or ``0`` depending on whether *ch* is an alphabetic character."

msgstr "Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere alfabético."

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

msgid ""

"Return ``1`` or ``0`` depending on whether *ch* is an alphanumeric character."

msgstr "Retorna ``1`` ou ``0`` dependendo se *ch* é um caractere alfanumérico."

#: ../../c-api/unicode.rst:324

msgid ""

"Return ``1`` or ``0`` depending on whether *ch* is a printable character. "

"Nonprintable characters are those characters defined in the Unicode "

"character database as \"Other\" or \"Separator\", excepting the ASCII space "

"(0x20) which is considered printable. (Note that printable characters in "

"this context are those which should not be escaped when :func:`repr` is "

"invoked on a string. It has no bearing on the handling of strings written "

"to :data:`sys.stdout` or :data:`sys.stderr`.)"

msgstr ""

#: ../../c-api/unicode.rst:333

msgid "These APIs can be used for fast direct character conversions:"

msgstr ""

#: ../../c-api/unicode.rst:338

msgid "Return the character *ch* converted to lower case."

msgstr ""

#: ../../c-api/unicode.rst:340 ../../c-api/unicode.rst:348

#: ../../c-api/unicode.rst:356

msgid "This function uses simple case mappings."

msgstr ""

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

msgid "Return the character *ch* converted to upper case."

msgstr ""

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

msgid "Return the character *ch* converted to title case."

msgstr ""

#: ../../c-api/unicode.rst:362

msgid ""

"Return the character *ch* converted to a decimal positive integer. Return "

"``-1`` if this is not possible. This macro does not raise exceptions."

msgstr ""

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

msgid ""

"Return the character *ch* converted to a single digit integer. Return ``-1`` "

"if this is not possible. This macro does not raise exceptions."

msgstr ""

#: ../../c-api/unicode.rst:374

msgid ""

"Return the character *ch* converted to a double. Return ``-1.0`` if this is "

"not possible. This macro does not raise exceptions."

msgstr ""

#: ../../c-api/unicode.rst:378

msgid "These APIs can be used to work with surrogates:"

msgstr ""

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

msgid "Check if *ch* is a surrogate (``0xD800 <= ch <= 0xDFFF``)."

msgstr ""

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

msgid "Check if *ch* is a high surrogate (``0xD800 <= ch <= 0xDBFF``)."

msgstr ""

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

msgid "Check if *ch* is a low surrogate (``0xDC00 <= ch <= 0xDFFF``)."

msgstr ""

#: ../../c-api/unicode.rst:394

msgid ""

"Join two surrogate characters and return a single Py_UCS4 value. *high* and "

"*low* are respectively the leading and trailing surrogates in a surrogate "

"pair."

msgstr ""

#: ../../c-api/unicode.rst:400

msgid "Creating and accessing Unicode strings"

msgstr ""

#: ../../c-api/unicode.rst:402

msgid ""

"To create Unicode objects and access their basic sequence properties, use "

"these APIs:"

msgstr ""

#: ../../c-api/unicode.rst:407

msgid ""

"Create a new Unicode object. *maxchar* should be the true maximum code "

"point to be placed in the string. As an approximation, it can be rounded up "

"to the nearest value in the sequence 127, 255, 65535, 1114111."

msgstr ""

#: ../../c-api/unicode.rst:411

msgid ""

"This is the recommended way to allocate a new Unicode object. Objects "

"created using this function are not resizable."

msgstr ""

#: ../../c-api/unicode.rst:420

msgid ""

"Create a new Unicode object with the given *kind* (possible values are :c:"

"macro:`PyUnicode_1BYTE_KIND` etc., as returned by :c:func:"

"`PyUnicode_KIND`). The *buffer* must point to an array of *size* units of "

"1, 2 or 4 bytes per character, as given by the kind."

msgstr ""

"Cria um novo objeto Unicode com o tipo *type* fornecido (os valores "

"possíveis são :c:macro:`PyUnicode_1BYTE_KIND` etc., conforme retornado por :"

"c:func:`PyUnicode_KIND`). O *buffer* deve apontar para um array de unidades "

"com *size* de 1, 2 ou 4 bytes por caractere, conforme fornecido pelo tipo."

#: ../../c-api/unicode.rst:425

msgid ""

"If necessary, the input *buffer* is copied and transformed into the "

"canonical representation. For example, if the *buffer* is a UCS4 string (:c:"

"macro:`PyUnicode_4BYTE_KIND`) and it consists only of codepoints in the UCS1 "

"range, it will be transformed into UCS1 (:c:macro:`PyUnicode_1BYTE_KIND`)."

msgstr ""

#: ../../c-api/unicode.rst:436

msgid ""

"Create a Unicode object from the char buffer *str*. The bytes will be "

"interpreted as being UTF-8 encoded. The buffer is copied into the new "

"object. If the buffer is not ``NULL``, the return value might be a shared "

"object, i.e. modification of the data is not allowed."

msgstr ""

#: ../../c-api/unicode.rst:441

msgid ""

"If *str* is ``NULL``, this function behaves like :c:func:"

"`PyUnicode_FromUnicode` with the buffer set to ``NULL``. This usage is "

"deprecated in favor of :c:func:`PyUnicode_New`, and will be removed in "

"Python 3.12."

msgstr ""

#: ../../c-api/unicode.rst:448

msgid ""

"Create a Unicode object from a UTF-8 encoded null-terminated char buffer "

"*str*."

msgstr ""

#: ../../c-api/unicode.rst:454

msgid ""

"Take a C :c:func:`printf`\\ -style *format* string and a variable number of "

"arguments, calculate the size of the resulting Python Unicode string and "

"return a string with the values formatted into it. The variable arguments "

"must be C types and must correspond exactly to the format characters in the "

"*format* ASCII-encoded string. The following format characters are allowed:"

msgstr ""

#: ../../c-api/unicode.rst:469

msgid "Format Characters"

msgstr "Caracteres Formatados"

#: ../../c-api/unicode.rst:469

msgid "Type"

msgstr "Tipo"

#: ../../c-api/unicode.rst:469

msgid "Comment"

msgstr "Comentário"

#: ../../c-api/unicode.rst:471

msgid ":attr:`%%`"

msgstr ":attr:`%%`"

#: ../../c-api/unicode.rst:471

msgid "*n/a*"

msgstr "*n/d*"

#: ../../c-api/unicode.rst:471

msgid "The literal % character."

msgstr "O caractere literal %."

#: ../../c-api/unicode.rst:473

msgid ":attr:`%c`"

msgstr ":attr:`%c`"

#: ../../c-api/unicode.rst:473 ../../c-api/unicode.rst:476

#: ../../c-api/unicode.rst:509 ../../c-api/unicode.rst:512

msgid "int"

msgstr "int"

#: ../../c-api/unicode.rst:473

msgid "A single character, represented as a C int."

msgstr ""

#: ../../c-api/unicode.rst:476

msgid ":attr:`%d`"

msgstr ":attr:`%d`"

#: ../../c-api/unicode.rst:476

msgid "Equivalent to ``printf(\"%d\")``. [1]_"

msgstr "Equivalente a ``printf(\"%d\")``. [1]_"

#: ../../c-api/unicode.rst:479

msgid ":attr:`%u`"

msgstr ":attr:`%u`"

#: ../../c-api/unicode.rst:479

msgid "unsigned int"

msgstr "unsigned int"

#: ../../c-api/unicode.rst:479

msgid "Equivalent to ``printf(\"%u\")``. [1]_"

msgstr "Equivalente a ``printf(\"%u\")``. [1]_"

#: ../../c-api/unicode.rst:482

msgid ":attr:`%ld`"

msgstr ":attr:`%ld`"

#: ../../c-api/unicode.rst:482 ../../c-api/unicode.rst:485

msgid "long"

msgstr "long"

#: ../../c-api/unicode.rst:482

msgid "Equivalent to ``printf(\"%ld\")``. [1]_"

msgstr "Equivalente a ``printf(\"%ld\")``. [1]_"

#: ../../c-api/unicode.rst:485

msgid ":attr:`%li`"

msgstr ":attr:`%li`"

#: ../../c-api/unicode.rst:485

msgid "Equivalent to ``printf(\"%li\")``. [1]_"

msgstr "Equivalente a ``printf(\"%li\")``. [1]_"

#: ../../c-api/unicode.rst:488

msgid ":attr:`%lu`"

msgstr ":attr:`%lu`"

#: ../../c-api/unicode.rst:488

msgid "unsigned long"

msgstr "unsigned long"

#: ../../c-api/unicode.rst:488

msgid "Equivalent to ``printf(\"%lu\")``. [1]_"

msgstr "Equivalente a ``printf(\"%lu\")``. [1]_"

#: ../../c-api/unicode.rst:491

msgid ":attr:`%lld`"

msgstr ":attr:`%lld`"

#: ../../c-api/unicode.rst:491 ../../c-api/unicode.rst:494

msgid "long long"

msgstr "long long"

#: ../../c-api/unicode.rst:491

msgid "Equivalent to ``printf(\"%lld\")``. [1]_"

msgstr "Equivalente a ``printf(\"%lld\")``. [1]_"

#: ../../c-api/unicode.rst:494

msgid ":attr:`%lli`"

msgstr ":attr:`%lli`"

#: ../../c-api/unicode.rst:494

msgid "Equivalent to ``printf(\"%lli\")``. [1]_"

msgstr "Equivalente a ``printf(\"%lli\")``. [1]_"

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

msgid ":attr:`%llu`"

msgstr ":attr:`%llu`"

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

msgid "unsigned long long"

msgstr "unsigned long long"

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

msgid "Equivalent to ``printf(\"%llu\")``. [1]_"

msgstr "Equivalente a ``printf(\"%llu\")``. [1]_"

#: ../../c-api/unicode.rst:500

msgid ":attr:`%zd`"

msgstr ":attr:`%zd`"

#: ../../c-api/unicode.rst:500 ../../c-api/unicode.rst:503

msgid ":c:type:`\\ Py_ssize_t`"

msgstr ":c:type:`\\ Py_ssize_t`"

#: ../../c-api/unicode.rst:500

msgid "Equivalent to ``printf(\"%zd\")``. [1]_"

msgstr "Equivalente a ``printf(\"%zd\")``. [1]_"

#: ../../c-api/unicode.rst:503

msgid ":attr:`%zi`"

msgstr ":attr:`%zi`"

#: ../../c-api/unicode.rst:503

msgid "Equivalent to ``printf(\"%zi\")``. [1]_"

msgstr "Equivalente a ``printf(\"%zi\")``. [1]_"

#: ../../c-api/unicode.rst:506

msgid ":attr:`%zu`"

msgstr ":attr:`%zu`"

#: ../../c-api/unicode.rst:506

msgid "size_t"

msgstr "size_t"

#: ../../c-api/unicode.rst:506

msgid "Equivalent to ``printf(\"%zu\")``. [1]_"

msgstr "Equivalente a ``printf(\"%zu\")``. [1]_"

#: ../../c-api/unicode.rst:509

msgid ":attr:`%i`"

msgstr ":attr:`%i`"

#: ../../c-api/unicode.rst:509

msgid "Equivalent to ``printf(\"%i\")``. [1]_"

msgstr "Equivalente a ``printf(\"%i\")``. [1]_"

#: ../../c-api/unicode.rst:512

msgid ":attr:`%x`"

msgstr ":attr:`%x`"

#: ../../c-api/unicode.rst:512

msgid "Equivalent to ``printf(\"%x\")``. [1]_"

msgstr "Equivalente a ``printf(\"%x\")``. [1]_"

#: ../../c-api/unicode.rst:515

msgid ":attr:`%s`"

msgstr ":attr:`%s`"

#: ../../c-api/unicode.rst:515

msgid "const char\\*"

msgstr "const char\\*"

#: ../../c-api/unicode.rst:515

msgid "A null-terminated C character array."

msgstr "Uma matriz de caracteres C com terminação nula."

#: ../../c-api/unicode.rst:518

msgid ":attr:`%p`"

msgstr ":attr:`%p`"

#: ../../c-api/unicode.rst:518

msgid "const void\\*"

msgstr "const void\\*"

#: ../../c-api/unicode.rst:518

msgid ""

"The hex representation of a C pointer. Mostly equivalent to "

"``printf(\"%p\")`` except that it is guaranteed to start with the literal "

"``0x`` regardless of what the platform's ``printf`` yields."

msgstr ""

"A representação hexadecimal de um ponteiro C. Principalmente equivalente a "

"``printf(\"%p\")`` exceto que é garantido que comece com o literal ``0x`` "

"independentemente do que o ``printf`` da plataforma ceda."

#: ../../c-api/unicode.rst:526

msgid ":attr:`%A`"

msgstr ":attr:`%A`"

#: ../../c-api/unicode.rst:526 ../../c-api/unicode.rst:529

#: ../../c-api/unicode.rst:538 ../../c-api/unicode.rst:541

msgid "PyObject\\*"

msgstr ""

#: ../../c-api/unicode.rst:526

msgid "The result of calling :func:`ascii`."

msgstr ""

#: ../../c-api/unicode.rst:529

msgid ":attr:`%U`"

msgstr ":attr:`%U`"

#: ../../c-api/unicode.rst:529

msgid "A Unicode object."

msgstr ""

#: ../../c-api/unicode.rst:531

msgid ":attr:`%V`"

msgstr ":attr:`%V`"

#: ../../c-api/unicode.rst:531

msgid "PyObject\\*, const char\\*"

msgstr ""

#: ../../c-api/unicode.rst:531

msgid ""

"A Unicode object (which may be ``NULL``) and a null-terminated C character "

"array as a second parameter (which will be used, if the first parameter is "

"``NULL``)."

msgstr ""

#: ../../c-api/unicode.rst:538

msgid ":attr:`%S`"

msgstr ":attr:`%S`"

#: ../../c-api/unicode.rst:538

msgid "The result of calling :c:func:`PyObject_Str`."

msgstr ""

#: ../../c-api/unicode.rst:541

msgid ":attr:`%R`"

msgstr ":attr:`%R`"

#: ../../c-api/unicode.rst:541

msgid "The result of calling :c:func:`PyObject_Repr`."

msgstr ""

#: ../../c-api/unicode.rst:545

msgid ""

"An unrecognized format character causes all the rest of the format string to "

"be copied as-is to the result string, and any extra arguments discarded."

msgstr ""

#: ../../c-api/unicode.rst:549

msgid ""

"The width formatter unit is number of characters rather than bytes. The "

"precision formatter unit is number of bytes for ``\"%s\"`` and ``\"%V\"`` "

"(if the ``PyObject*`` argument is ``NULL``), and a number of characters for "

"``\"%A\"``, ``\"%U\"``, ``\"%S\"``, ``\"%R\"`` and ``\"%V\"`` (if the "

"``PyObject*`` argument is not ``NULL``)."

msgstr ""

#: ../../c-api/unicode.rst:555

msgid ""

"For integer specifiers (d, u, ld, li, lu, lld, lli, llu, zd, zi, zu, i, x): "

"the 0-conversion flag has effect even when a precision is given."

msgstr ""

#: ../../c-api/unicode.rst:558

msgid "Support for ``\"%lld\"`` and ``\"%llu\"`` added."

msgstr "Suporte adicionado para ``\"%lld\"`` e ``\"%llu\"``."

#: ../../c-api/unicode.rst:561

msgid "Support for ``\"%li\"``, ``\"%lli\"`` and ``\"%zi\"`` added."

msgstr ""

#: ../../c-api/unicode.rst:564

msgid ""

"Support width and precision formatter for ``\"%s\"``, ``\"%A\"``, "

"``\"%U\"``, ``\"%V\"``, ``\"%S\"``, ``\"%R\"`` added."

msgstr ""

#: ../../c-api/unicode.rst:571

msgid ""

"Identical to :c:func:`PyUnicode_FromFormat` except that it takes exactly two "

"arguments."

msgstr ""

#: ../../c-api/unicode.rst:577

msgid ""

"Copy an instance of a Unicode subtype to a new true Unicode object if "

"necessary. If *obj* is already a true Unicode object (not a subtype), return "

"a new :term:`strong reference` to the object."

msgstr ""

#: ../../c-api/unicode.rst:581

msgid ""

"Objects other than Unicode or its subtypes will cause a :exc:`TypeError`."

msgstr ""

#: ../../c-api/unicode.rst:587

msgid "Decode an encoded object *obj* to a Unicode object."

msgstr ""

#: ../../c-api/unicode.rst:589

msgid ""

":class:`bytes`, :class:`bytearray` and other :term:`bytes-like objects "

"<bytes-like object>` are decoded according to the given *encoding* and using "

"the error handling defined by *errors*. Both can be ``NULL`` to have the "

"interface use the default values (see :ref:`builtincodecs` for details)."

msgstr ""

#: ../../c-api/unicode.rst:595

msgid ""

"All other objects, including Unicode objects, cause a :exc:`TypeError` to be "

"set."

msgstr ""

#: ../../c-api/unicode.rst:598

msgid ""

"The API returns ``NULL`` if there was an error. The caller is responsible "

"for decref'ing the returned objects."

msgstr ""

#: ../../c-api/unicode.rst:604

msgid "Return the length of the Unicode object, in code points."

msgstr ""

#: ../../c-api/unicode.rst:615

msgid ""

"Copy characters from one Unicode object into another. This function "

"performs character conversion when necessary and falls back to :c:func:`!"

"memcpy` if possible. Returns ``-1`` and sets an exception on error, "

"otherwise returns the number of copied characters."

msgstr ""

#: ../../c-api/unicode.rst:626

msgid ""

"Fill a string with a character: write *fill_char* into ``unicode[start:"

"start+length]``."

msgstr ""

#: ../../c-api/unicode.rst:629

msgid ""

"Fail if *fill_char* is bigger than the string maximum character, or if the "

"string has more than 1 reference."

msgstr ""

#: ../../c-api/unicode.rst:632

msgid ""

"Return the number of written character, or return ``-1`` and raise an "

"exception on error."

msgstr ""

#: ../../c-api/unicode.rst:641

msgid ""

"Write a character to a string. The string must have been created through :c:"

"func:`PyUnicode_New`. Since Unicode strings are supposed to be immutable, "

"the string must not be shared, or have been hashed yet."

msgstr ""

#: ../../c-api/unicode.rst:645

msgid ""

"This function checks that *unicode* is a Unicode object, that the index is "

"not out of bounds, and that the object can be modified safely (i.e. that it "

"its reference count is one)."

msgstr ""

#: ../../c-api/unicode.rst:654

msgid ""

"Read a character from a string. This function checks that *unicode* is a "

"Unicode object and the index is not out of bounds, in contrast to :c:func:"

"`PyUnicode_READ_CHAR`, which performs no error checking."

msgstr ""

#: ../../c-api/unicode.rst:664

msgid ""

"Return a substring of *unicode*, from character index *start* (included) to "

"character index *end* (excluded). Negative indices are not supported."

msgstr ""

#: ../../c-api/unicode.rst:673

msgid ""

"Copy the string *unicode* into a UCS4 buffer, including a null character, if "

"*copy_null* is set. Returns ``NULL`` and sets an exception on error (in "

"particular, a :exc:`SystemError` if *buflen* is smaller than the length of "

"*unicode*). *buffer* is returned on success."

msgstr ""

#: ../../c-api/unicode.rst:683

msgid ""

"Copy the string *unicode* into a new UCS4 buffer that is allocated using :c:"

"func:`PyMem_Malloc`. If this fails, ``NULL`` is returned with a :exc:"

"`MemoryError` set. The returned buffer always has an extra null code point "

"appended."

msgstr ""

#: ../../c-api/unicode.rst:692

msgid "Deprecated Py_UNICODE APIs"

msgstr ""

#: ../../c-api/unicode.rst:696

msgid ""

"These API functions are deprecated with the implementation of :pep:`393`. "

"Extension modules can continue using them, as they will not be removed in "

"Python 3.x, but need to be aware that their use can now cause performance "

"and memory hits."

msgstr ""

#: ../../c-api/unicode.rst:703

msgid ""

"Create a Unicode object from the Py_UNICODE buffer *u* of the given size. "

"*u* may be ``NULL`` which causes the contents to be undefined. It is the "

"user's responsibility to fill in the needed data. The buffer is copied into "

"the new object."

msgstr ""

#: ../../c-api/unicode.rst:708

msgid ""

"If the buffer is not ``NULL``, the return value might be a shared object. "

"Therefore, modification of the resulting Unicode object is only allowed when "

"*u* is ``NULL``."

msgstr ""

#: ../../c-api/unicode.rst:712

msgid ""

"If the buffer is ``NULL``, :c:func:`PyUnicode_READY` must be called once the "

"string content has been filled before using any of the access macros such "

"as :c:func:`PyUnicode_KIND`."

msgstr ""

#: ../../c-api/unicode.rst:719

msgid ""

"Part of the old-style Unicode API, please migrate to using :c:func:"

"`PyUnicode_FromKindAndData`, :c:func:`PyUnicode_FromWideChar`, or :c:func:"

"`PyUnicode_New`."

msgstr ""

#: ../../c-api/unicode.rst:724

msgid ""

"Return a read-only pointer to the Unicode object's internal :c:type:"

"`Py_UNICODE` buffer, or ``NULL`` on error. This will create the :c:expr:"

"`Py_UNICODE*` representation of the object if it is not yet available. The "

"buffer is always terminated with an extra null code point. Note that the "

"resulting :c:type:`Py_UNICODE` string may also contain embedded null code "

"points, which would cause the string to be truncated when used in most C "

"functions."

msgstr ""

#: ../../c-api/unicode.rst:735 ../../c-api/unicode.rst:751

msgid ""

"Part of the old-style Unicode API, please migrate to using :c:func:"