string.po

# 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:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-03 18:36+0000\n"
"PO-Revision-Date: 2026-05-08 17:18+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2026\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"

#: ../../library/string.rst:2
msgid ":mod:`!string` --- Common string operations"
msgstr ":mod:`!string` --- Operações comuns de strings"

#: ../../library/string.rst:7
msgid "**Source code:** :source:`Lib/string/__init__.py`"
msgstr "**Código-fonte:** :source:`Lib/string/__init__.py`"

#: ../../library/string.rst:14
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"

#: ../../library/string.rst:16
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"

#: ../../library/string.rst:19
msgid "String constants"
msgstr "Constantes de strings"

#: ../../library/string.rst:21
msgid "The constants defined in this module are:"
msgstr "As constantes definidas neste módulo são:"

#: ../../library/string.rst:26
msgid ""
"The concatenation of the :const:`ascii_lowercase` and :const:"
"`ascii_uppercase` constants described below.  This value is not locale-"
"dependent."
msgstr ""
"A concatenação das constantes :const:`ascii_lowercase` e :const:"
"`ascii_uppercase` descritas abaixo. Este valor não depende da localidade."

#: ../../library/string.rst:32
msgid ""
"The lowercase letters ``'abcdefghijklmnopqrstuvwxyz'``.  This value is not "
"locale-dependent and will not change."
msgstr ""
"As letras minúsculas ``'abcdefghijklmnopqrstuvwxyz'``. Este valor não "
"depende da localidade e não mudará."

#: ../../library/string.rst:38
msgid ""
"The uppercase letters ``'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``.  This value is not "
"locale-dependent and will not change."
msgstr ""
"As letras maiúsculas ``'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``. Este valor não "
"depende da localidade e não mudará."

#: ../../library/string.rst:44
msgid "The string ``'0123456789'``."
msgstr "A string ``'0123456789'``."

#: ../../library/string.rst:49
msgid "The string ``'0123456789abcdefABCDEF'``."
msgstr "A string ``'0123456789abcdefABCDEF'``."

#: ../../library/string.rst:54
msgid "The string ``'01234567'``."
msgstr "A string ``'01234567'``."

#: ../../library/string.rst:59
msgid ""
"String of ASCII characters which are considered punctuation characters in "
"the ``C`` locale: ``!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~``."
msgstr ""
"String de caracteres ASCII que são considerados caracteres de pontuação na "
"localidade ``C``: ``!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~``."

#: ../../library/string.rst:65
msgid ""
"String of ASCII characters which are considered printable by Python. This is "
"a combination of :const:`digits`, :const:`ascii_letters`, :const:"
"`punctuation`, and :const:`whitespace`."
msgstr ""
"String de caracteres ASCII que são considerados imprimíveis pelo Python. "
"Esta é uma combinação de :const:`digits`, :const:`ascii_letters`, :const:"
"`punctuation` e :const:`whitespace`."

#: ../../library/string.rst:71
msgid ""
"By design, :meth:`string.printable.isprintable() <str.isprintable>` returns :"
"const:`False`. In particular, ``string.printable`` is not printable in the "
"POSIX sense (see :manpage:`LC_CTYPE <locale(5)>`)."
msgstr ""
"Por design, :meth:`string.printable.isprintable() <str.isprintable>` "
"retorna :const:`False`. Em particular, ``string.printable`` não é imprimível "
"no sentido POSIX (veja :manpage:`LC_CTYPE <locale(5)>`)."

#: ../../library/string.rst:78
msgid ""
"A string containing all ASCII characters that are considered whitespace. "
"This includes the characters space, tab, linefeed, return, formfeed, and "
"vertical tab."
msgstr ""
"Uma string contendo todos os caracteres ASCII que são considerados espaços "
"em branco. Isso inclui espaço de caracteres, tabulação, avanço de linha, "
"retorno, avanço de formulário e tabulação vertical."

#: ../../library/string.rst:86
msgid "Custom string formatting"
msgstr "Formatação personalizada de strings"

#: ../../library/string.rst:88
msgid ""
"The built-in string class provides the ability to do complex variable "
"substitutions and value formatting via the :meth:`~str.format` method "
"described in :pep:`3101`.  The :class:`Formatter` class in the :mod:`!"
"string` module allows you to create and customize your own string formatting "
"behaviors using the same implementation as the built-in :meth:`~str.format` "
"method."
msgstr ""
"A classe embutida de string fornece a capacidade de substituir variáveis "
"complexas e de formatar valores por meio do método :meth:`~str.format` "
"descrito na :pep:`3101`. A classe :class:`Formatter` no módulo :mod:`!"
"string` permite que você crie e personalize seus próprios comportamentos de "
"formatação de strings, usando a mesma implementação do método embutido :meth:"
"`~str.format`."

#: ../../library/string.rst:97
msgid "The :class:`Formatter` class has the following public methods:"
msgstr "A classe :class:`Formatter` tem os seguintes métodos públicos:"

#: ../../library/string.rst:101
msgid ""
"The primary API method.  It takes a format string and an arbitrary set of "
"positional and keyword arguments. It is just a wrapper that calls :meth:"
"`vformat`."
msgstr ""
"O método principal da API. Ele aceita uma string de formato e um conjunto "
"arbitrário de argumentos posicionais e nomeados. É apenas um invólucro que "
"chama :meth:`vformat`."

#: ../../library/string.rst:105
msgid ""
"A format string argument is now :ref:`positional-only <positional-"
"only_parameter>`."
msgstr ""
"Um argumento de string de formato é agora :ref:`somente-posicional "
"<positional-only_parameter>`."

#: ../../library/string.rst:111
msgid ""
"This function does the actual work of formatting.  It is exposed as a "
"separate function for cases where you want to pass in a predefined "
"dictionary of arguments, rather than unpacking and repacking the dictionary "
"as individual arguments using the ``*args`` and ``**kwargs`` syntax.  :meth:"
"`vformat` does the work of breaking up the format string into character data "
"and replacement fields.  It calls the various methods described below."
msgstr ""
"Esta função realiza o trabalho real de formatação. Ela é exposta como uma "
"função separada para casos em que você deseja passar um dicionário "
"predefinido de argumentos, em vez de desempacotar e empacotar novamente o "
"dicionário como argumentos individuais usando a sintaxe ``*args`` e "
"``**kwargs``. :meth:`vformat` faz o trabalho de quebrar a string de formato "
"em dados de caracteres e campos de substituição. Ela chama os vários métodos "
"descritos a seguir."

#: ../../library/string.rst:119
msgid ""
"In addition, the :class:`Formatter` defines a number of methods that are "
"intended to be replaced by subclasses:"
msgstr ""
"Além disso, o :class:`Formatter` define uma série de métodos que devem ser "
"substituídos por subclasses:"

#: ../../library/string.rst:124
msgid ""
"Loop over the format_string and return an iterable of tuples "
"(*literal_text*, *field_name*, *format_spec*, *conversion*).  This is used "
"by :meth:`vformat` to break the string into either literal text, or "
"replacement fields."
msgstr ""
"Percorre format_string e retorna um iterável de tuplas (*literal_text*, "
"*field_name*, *format_spec*, *conversion*). Isso é usado por :meth:`vformat` "
"para quebrar a string em texto literal ou em campos de substituição."

#: ../../library/string.rst:129
msgid ""
"The values in the tuple conceptually represent a span of literal text "
"followed by a single replacement field.  If there is no literal text (which "
"can happen if two replacement fields occur consecutively), then "
"*literal_text* will be a zero-length string.  If there is no replacement "
"field, then the values of *field_name*, *format_spec* and *conversion* will "
"be ``None``. The value of *field_name* is unmodified and auto-numbering of "
"non-numbered positional fields is done by :meth:`vformat`."
msgstr ""
"Os valores da tupla representam, conceitualmente, um intervalo de texto "
"literal, seguido de um único campo de substituição. Se não houver texto "
"literal (o que pode ocorrer se dois campos de substituição forem "
"consecutivos), *literal_text* será uma string de comprimento zero. Se não "
"houver campo de substituição, os valores de *field_name*, *format_spec* e "
"*conversion* serão ``None``. O valor de *field_name* não é modificado, e a "
"numeração automática de campos posicionais não numerados é realizada por :"
"meth:`vformat`."

#: ../../library/string.rst:139
msgid ""
"Given *field_name*, convert it to an object to be formatted. Auto-numbering "
"of *field_name* returned from :meth:`parse` is done by :meth:`vformat` "
"before calling this method.  Returns a tuple (obj, used_key). The default "
"version takes strings of the form defined in :pep:`3101`, such as "
"\"0[name]\" or \"label.title\". *args* and *kwargs* are as passed in to :"
"meth:`vformat`. The return value *used_key* has the same meaning as the "
"*key* parameter to :meth:`get_value`."
msgstr ""
"Dado *field_name*, converte-o em um objeto a ser formatado. A autonumeração "
"de *field_name* retornada de :meth:`parse` é feita por :meth:`vformat` antes "
"de chamar este método. Retorna uma tupla (obj, used_key). A versão padrão "
"aceita strings no formato definido na :pep:`3101`, como \"0[name]\" ou "
"\"label.title\". *args* e *kwargs* são como os argumentos passados para :"
"meth:`vformat`. O valor de retorno *used_key* tem o mesmo significado que o "
"parâmetro *key* em :meth:`get_value`."

#: ../../library/string.rst:149
msgid ""
"Retrieve a given field value.  The *key* argument will be either an integer "
"or a string.  If it is an integer, it represents the index of the positional "
"argument in *args*; if it is a string, then it represents a named argument "
"in *kwargs*."
msgstr ""
"Obtém o valor de um campo. O argumento *key* será um inteiro ou uma string. "
"Se for um inteiro, ele representa o índice do argumento posicional em "
"*args*; se for uma string, representa um argumento nomeado em *kwargs*."

#: ../../library/string.rst:154
msgid ""
"The *args* parameter is set to the list of positional arguments to :meth:"
"`vformat`, and the *kwargs* parameter is set to the dictionary of keyword "
"arguments."
msgstr ""
"O parâmetro *args* é definido para a lista de argumentos posicionais de :"
"meth:`vformat`, e o parâmetro *kwargs* é definido para o dicionário de "
"argumentos nomeados."

#: ../../library/string.rst:158
msgid ""
"For compound field names, these functions are only called for the first "
"component of the field name; subsequent components are handled through "
"normal attribute and indexing operations."
msgstr ""
"Para nomes de campos compostos, essas funções são chamadas apenas para o "
"primeiro componente do nome do campo; os componentes subsequentes são "
"tratados por meio de operações normais de atributo e de indexação."

#: ../../library/string.rst:162
msgid ""
"So for example, the field expression '0.name' would cause :meth:`get_value` "
"to be called with a *key* argument of 0.  The ``name`` attribute will be "
"looked up after :meth:`get_value` returns by calling the built-in :func:"
"`getattr` function."
msgstr ""
"Então, por exemplo, a expressão de campo '0.name' faria com que :meth:"
"`get_value` fosse chamado com o argumento *key* 0. O atributo ``name`` será "
"pesquisado após a função :meth:`get_value` retornar, chamando a função "
"embutida :func:`getattr`."

#: ../../library/string.rst:167
msgid ""
"If the index or keyword refers to an item that does not exist, then an :exc:"
"`IndexError` or :exc:`KeyError` should be raised."
msgstr ""
"Se o índice ou palavra-chave se referir a um item que não existe, um :exc:"
"`IndexError` ou :exc:`KeyError` deve ser levantado."

#: ../../library/string.rst:172
msgid ""
"Implement checking for unused arguments if desired.  The arguments to this "
"function is the set of all argument keys that were actually referred to in "
"the format string (integers for positional arguments, and strings for named "
"arguments), and a reference to the *args* and *kwargs* that was passed to "
"vformat.  The set of unused args can be calculated from these parameters.  :"
"meth:`check_unused_args` is assumed to raise an exception if the check fails."
msgstr ""
"Implementa a verificação de argumentos não usados, se desejar. Os argumentos "
"para esta função são o conjunto de todas as chaves de argumento realmente "
"referidas na string de formato (inteiros para argumentos posicionais e "
"strings para argumentos nomeados), e uma referência a *args* e *kwargs* que "
"foi passada para vformat. O conjunto de argumentos não utilizados pode ser "
"calculado com base nesses parâmetros. Presume-se que  :meth:"
"`check_unused_args` levante uma exceção caso a verificação falhe."

#: ../../library/string.rst:182
msgid ""
":meth:`format_field` simply calls the global :func:`format` built-in.  The "
"method is provided so that subclasses can override it."
msgstr ""
":meth:`format_field` simplesmente chama o global embutido :func:`format`. O "
"método é fornecido para que as subclasses possam substituí-lo."

#: ../../library/string.rst:187
msgid ""
"Converts the value (returned by :meth:`get_field`) given a conversion type "
"(as in the tuple returned by the :meth:`parse` method).  The default version "
"understands 's' (str), 'r' (repr) and 'a' (ascii) conversion types."
msgstr ""
"Converte o valor (retornado por :meth:`get_field`) de acordo com um tipo de "
"conversão (como na tupla retornada pelo método :meth:`parse`). A versão "
"padrão entende os tipos de conversão \"s\" (str), \"r\" (repr) e "
"\"a\" (ascii)."

#: ../../library/string.rst:196
msgid "Format string syntax"
msgstr "Sintaxe das strings de formato"

#: ../../library/string.rst:198
msgid ""
"The :meth:`str.format` method and the :class:`Formatter` class share the "
"same syntax for format strings (although in the case of :class:`Formatter`, "
"subclasses can define their own format string syntax).  The syntax is "
"related to that of :ref:`formatted string literals <f-strings>` and :ref:"
"`template string literals <t-strings>`, but it is less sophisticated and, in "
"particular, does not support arbitrary expressions in interpolations."
msgstr ""
"O método :meth:`str.format` e a classe :class:`Formatter` compartilham a "
"mesma sintaxe para strings de formato (embora no caso de :class:`Formatter`, "
"as subclasses possam definir sua própria sintaxe de string de formato). A "
"sintaxe é relacionada a :ref:`literais de strings formatadas <f-strings>` e :"
"ref:`literais de strings templates <t-strings>`, mas é menos sofisticada e, "
"em especial, não oferece suporte a expressões arbitrárias em interpolações."

#: ../../library/string.rst:212
msgid ""
"Format strings contain \"replacement fields\" surrounded by curly braces ``{}"
"``. Anything that is not contained in braces is considered literal text, "
"which is copied unchanged to the output.  If you need to include a brace "
"character in the literal text, it can be escaped by doubling: ``{{`` and ``}}"
"``."
msgstr ""
"As strings de formato contêm \"campos de substituição\" entre chaves ``{}``. "
"Tudo o que não estiver entre chaves é considerado texto literal e é copiado "
"inalterado para a saída. Se você precisar incluir um caractere de chave no "
"texto literal, ele pode ser escapado duplicando-o: ``{{`` e ``}}``."

#: ../../library/string.rst:217
msgid "The grammar for a replacement field is as follows:"
msgstr "A gramática para um campo de substituição é a seguinte:"

#: ../../library/string.rst:229
msgid ""
"In less formal terms, the replacement field can start with a *field_name* "
"that specifies the object whose value is to be formatted and inserted into "
"the output instead of the replacement field. The *field_name* is optionally "
"followed by a  *conversion* field, which is preceded by an exclamation point "
"``'!'``, and a *format_spec*, which is preceded by a colon ``':'``.  These "
"specify a non-default format for the replacement value."
msgstr ""
"Em termos menos formais, o campo de substituição pode começar com um "
"*field_name* que especifica o objeto cujo valor deve ser formatado e "
"inserido na saída, em vez do próprio campo de substituição. O *field_name* é "
"opcionalmente seguido de um campo *conversion*, que é precedido por um ponto "
"de exclamação ``'!'``, e de um *format_spec*, que é precedido por dois "
"pontos ``':'``. Eles especificam um formato não padrão para o valor de "
"substituição."

#: ../../library/string.rst:236
msgid "See also the :ref:`formatspec` section."
msgstr "Veja também a seção :ref:`formatspec`."

#: ../../library/string.rst:238
msgid ""
"The *field_name* itself begins with an *arg_name* that is either a number or "
"a keyword.  If it's a number, it refers to a positional argument, and if "
"it's a keyword, it refers to a named keyword argument. An *arg_name* is "
"treated as a number if a call to :meth:`str.isdecimal` on the string would "
"return true. If the numerical arg_names in a format string are 0, 1, 2, ... "
"in sequence, they can all be omitted (not just some) and the numbers 0, 1, "
"2, ... will be automatically inserted in that order. Because *arg_name* is "
"not quote-delimited, it is not possible to specify arbitrary dictionary keys "
"(e.g., the strings ``'10'`` or ``':-]'``) within a format string. The "
"*arg_name* can be followed by any number of index or attribute expressions. "
"An expression of the form ``'.name'`` selects the named attribute using :"
"func:`getattr`, while an expression of the form ``'[index]'`` does an index "
"lookup using :meth:`~object.__getitem__`."
msgstr ""
"O próprio *field_name* começa com um *arg_name*, que pode ser um número ou "
"uma palavra-chave. Se for um número, ele se refere a um argumento "
"posicional, e se for uma palavra-chave, ele se refere a um argumento "
"nomeado. Um *arg_name* é tratado como um número se uma chamada à :meth:`str."
"isdecimal` na string retornar verdadeiro. Se os arg_names numéricos em uma "
"string de formato forem 0, 1, 2, … em sequência, eles podem ser todos "
"omitidos (não apenas alguns) e os números 0, 1, 2, … serão inseridos "
"automaticamente nessa ordem. Como *arg_name* não está delimitado por aspas, "
"não é possível especificar chaves de dicionário arbitrárias (por exemplo, as "
"strings ``'10'`` ou ``':-]'``) em uma string de formato. O *arg_name* pode "
"ser seguido por qualquer número de expressões de índice ou de atributo. Uma "
"expressão da forma ``'.name'`` seleciona o atributo nomeado com :func:"
"`getattr`, enquanto uma expressão da forma ``'[index]'`` faz uma pesquisa de "
"índice com :meth:`~object.__getitem__`."

#: ../../library/string.rst:252
msgid ""
"The positional argument specifiers can be omitted for :meth:`str.format`, so "
"``'{} {}'.format(a, b)`` is equivalent to ``'{0} {1}'.format(a, b)``."
msgstr ""
"Os especificadores de argumento posicional podem ser omitidos para :meth:"
"`str.format`, de forma que ``'{} {}'.format(a, b)`` é equivalente a ``'{0} "
"{1}'.format(a, b)``."

#: ../../library/string.rst:256
msgid ""
"The positional argument specifiers can be omitted for :class:`Formatter`."
msgstr ""
"Os especificadores de argumento posicional podem ser omitidos para :class:"
"`Formatter`."

#: ../../library/string.rst:259
msgid "Some simple format string examples::"
msgstr "Alguns exemplos simples de string de formato::"

#: ../../library/string.rst:261
msgid ""
"\"First, thou shalt count to {0}\"  # References first positional argument\n"
"\"Bring me a {}\"                   # Implicitly references the first "
"positional argument\n"
"\"From {} to {}\"                   # Same as \"From {0} to {1}\"\n"
"\"My quest is {name}\"              # References keyword argument 'name'\n"
"\"Weight in tons {0.weight}\"       # 'weight' attribute of first positional "
"arg\n"
"\"Units destroyed: {players[0]}\"   # First element of keyword argument "
"'players'."
msgstr ""
"\"Primeiro, tu deverás contar até {0}\"  # Referencia o primeiro argumento "
"posicional\n"
"\"Traga-me um {}\"                       # Referencia implicitamente o "
"primeiro argumento posicional\n"
"\"De {} para {}\"                        # Mesmo que \"De {0} para {1}\"\n"
"\"Minha missão é {nome}\"                # Referencia argumento nomeado "
"'nome'\n"
"\"Peso em toneladas {0.peso}\"           # O atributo 'peso' do primeiro "
"argumento posicional\n"
"\"Unidades destruídas: {jogadores[0]}\"  # Primeiro elemento do argumento "
"nomeado 'jogadores'."

#: ../../library/string.rst:270
msgid ""
"The *conversion* field causes a type coercion before formatting.  Normally, "
"the job of formatting a value is done by the :meth:`~object.__format__` "
"method of the value itself.  However, in some cases it is desirable to force "
"a type to be formatted as a string, overriding its own definition of "
"formatting.  By converting the value to a string before calling :meth:"
"`~object.__format__`, the normal formatting logic is bypassed."
msgstr ""
"O campo *conversion* causa uma coerção de tipo antes da formatação. "
"Normalmente, o trabalho de formatação de um valor é feito pelo método :meth:"
"`~object.__format__` do próprio valor. No entanto, em alguns casos, é "
"desejável forçar um tipo a ser formatado como string, substituindo sua "
"própria definição de formatação. Ao converter o valor em uma string antes de "
"chamar :meth:`~object.__format__`, a lógica de formatação normal é "
"contornada."

#: ../../library/string.rst:277
msgid ""
"Three conversion flags are currently supported: ``'!s'`` which calls :func:"
"`str` on the value, ``'!r'`` which calls :func:`repr` and ``'!a'`` which "
"calls :func:`ascii`."
msgstr ""
"Atualmente, há suporte para três sinalizadores de conversão: ``'!s'``, que "
"chama :func:`str` no valor; ``'!r'``, que chama :func:`repr`; e ``'!a'``, "
"que chama :func:`ascii`."

#: ../../library/string.rst:281
msgid "Some examples::"
msgstr "Alguns exemplos:"

#: ../../library/string.rst:283
msgid ""
"\"Harold's a clever {0!s}\"        # Calls str() on the argument first\n"
"\"Bring out the holy {name!r}\"    # Calls repr() on the argument first\n"
"\"More {!a}\"                      # Calls ascii() on the argument first"
msgstr ""
"\"Harold é um {0!s} esperto\"        # Chama str() no primeiro argumento\n"
"\"Trazei à luz o {name!r} sagrado\"    # Chama repr() no primeiro argumento\n"
"\"Mais {!a}\"                      # Chama ascii() no primeiro argumento"

#: ../../library/string.rst:287
msgid ""
"The *format_spec* field contains a specification of how the value should be "
"presented, including such details as field width, alignment, padding, "
"decimal precision and so on.  Each value type can define its own "
"\"formatting mini-language\" or interpretation of the *format_spec*."
msgstr ""
"O campo *format_spec* contém uma especificação de como o valor deve ser "
"apresentado, incluindo detalhes como a largura do campo, o alinhamento, o "
"preenchimento, a precisão decimal e assim por diante. Cada tipo de valor "
"pode definir sua própria \"minilinguagem de formatação\" ou interpretação de "
"*format_spec*."

#: ../../library/string.rst:292
msgid ""
"Most built-in types support a common formatting mini-language, which is "
"described in the next section."
msgstr ""
"A maioria dos tipos embutidos oferece suporte a uma minilinguagem de "
"formatação comum, descrita na próxima seção."

#: ../../library/string.rst:295
msgid ""
"A *format_spec* field can also include nested replacement fields within it. "
"These nested replacement fields may contain a field name, conversion flag "
"and format specification, but deeper nesting is not allowed.  The "
"replacement fields within the format_spec are substituted before the "
"*format_spec* string is interpreted. This allows the formatting of a value "
"to be dynamically specified."
msgstr ""
"O campo *format_spec* também pode conter campos de substituição aninhados. "
"Esses campos de substituição aninhados podem conter um nome de campo, um "
"sinalizador de conversão e uma especificação de formato, mas um aninhamento "
"mais profundo não é permitido. Os campos de substituição em format_spec são "
"substituídos antes que a string *format_spec* seja interpretada. Isso "
"permite que a formatação de um valor seja especificada dinamicamente."

#: ../../library/string.rst:302
msgid "See the :ref:`formatexamples` section for some examples."
msgstr "Veja a seção :ref:`formatexamples` para alguns exemplos."

#: ../../library/string.rst:308
msgid "Format specification mini-language"
msgstr "Minilinguagem de especificação de formato"

#: ../../library/string.rst:310
msgid ""
"\"Format specifications\" are used within replacement fields contained "
"within a format string to define how individual values are presented (see :"
"ref:`formatstrings`, :ref:`f-strings`, and :ref:`t-strings`). They can also "
"be passed directly to the built-in :func:`format` function.  Each "
"formattable type may define how the format specification is to be "
"interpreted."
msgstr ""
"\"Especificações de formato\" são usadas nos campos de substituição contidos "
"em uma string de formato para definir como os valores individuais são "
"apresentados (consulte :ref:`formatstrings`, :ref:`f-strings` e :ref:`t-"
"strings`). Elas também podem ser passadas diretamente para a função "
"embutida :func:`format`. Cada tipo formatável pode definir como a "
"especificação do formato deve ser interpretada."

#: ../../library/string.rst:317
msgid ""
"Most built-in types implement the following options for format "
"specifications, although some of the formatting options are only supported "
"by the numeric types."
msgstr ""
"A maioria dos tipos embutidos implementa as seguintes opções para "
"especificações de formato, embora algumas das opções de formatação sejam "
"válidas apenas para tipos numéricos."

#: ../../library/string.rst:320
msgid ""
"A general convention is that an empty format specification produces the same "
"result as if you had called :func:`str` on the value. A non-empty format "
"specification typically modifies the result."
msgstr ""
"Uma convenção geral é que uma especificação de formato vazia produz o mesmo "
"resultado que se você tivesse chamado :func:`str` no valor. Uma "
"especificação de formato não vazio geralmente modifica o resultado."

#: ../../library/string.rst:324
msgid "The general form of a *standard format specifier* is:"
msgstr "A forma geral de um *especificador de formato padrão* é:"

#: ../../library/string.rst:341
msgid ""
"If a valid *align* value is specified, it can be preceded by a *fill* "
"character that can be any character and defaults to a space if omitted. It "
"is not possible to use a literal curly brace (\"``{``\" or \"``}``\") as the "
"*fill* character in a :ref:`formatted string literal <f-strings>` or when "
"using the :meth:`str.format` method.  However, it is possible to insert a "
"curly brace with a nested replacement field.  This limitation doesn't affect "
"the :func:`format` function."
msgstr ""
"Se um valor *align*  válido for especificado, ele pode ser precedido por um "
"caractere de preenchimento *fill* que pode ser qualquer caractere e o padrão "
"é um espaço se omitido. Não é possível usar uma chave literal (\"``{``\" ou "
"\"``}``\") como o caractere *fill* em uma :ref:`string formatada literal <f-"
"strings>` ou ao usar o método :meth:`str.format`. No entanto, é possível "
"inserir uma chave com um campo de substituição aninhado. Esta limitação não "
"afeta a função :func:`format`."

#: ../../library/string.rst:350
msgid "The meaning of the various alignment options is as follows:"
msgstr "O significado das várias opções de alinhamento é o seguinte:"

#: ../../library/string.rst:359 ../../library/string.rst:391
#: ../../library/string.rst:457
msgid "Option"
msgstr "Opção"

#: ../../library/string.rst:359 ../../library/string.rst:391
#: ../../library/string.rst:457 ../../library/string.rst:493
#: ../../library/string.rst:504 ../../library/string.rst:544
msgid "Meaning"
msgstr "Significado"

#: ../../library/string.rst:361
msgid "``'<'``"
msgstr "``'<'``"

#: ../../library/string.rst:361
msgid ""
"Forces the field to be left-aligned within the available space (this is the "
"default for most objects)."
msgstr ""
"Força o alinhamento à esquerda do campo no espaço disponível (este é o "
"padrão para a maioria dos objetos)."

#: ../../library/string.rst:364
msgid "``'>'``"
msgstr "``'>'``"

#: ../../library/string.rst:364
msgid ""
"Forces the field to be right-aligned within the available space (this is the "
"default for numbers)."
msgstr ""
"Força o alinhamento à direita do campo no espaço disponível (este é o padrão "
"para números)."

#: ../../library/string.rst:367
msgid "``'='``"
msgstr "``'='``"

#: ../../library/string.rst:367
msgid ""
"Forces the padding to be placed after the sign (if any) but before the "
"digits.  This is used for printing fields in the form '+000000120'. This "
"alignment option is only valid for numeric types, excluding :class:"
"`complex`. It becomes the default for numbers when '0' immediately precedes "
"the field width."
msgstr ""
"Força o preenchimento a ser colocado após o sinal (se houver), mas antes dos "
"dígitos. É usado para imprimir campos na forma \"+000000120\". Esta opção de "
"alinhamento só é válida para tipos numéricos, excluindo :class:`complex`. "
"Torna-se o padrão para números quando \"0\" precede imediatamente a largura "
"do campo."

#: ../../library/string.rst:374
msgid "``'^'``"
msgstr "``'^'``"

#: ../../library/string.rst:374
msgid "Forces the field to be centered within the available space."
msgstr "Força a centralização do campo no espaço disponível."

#: ../../library/string.rst:378
msgid ""
"Note that unless a minimum field width is defined, the field width will "
"always be the same size as the data to fill it, so that the alignment option "
"has no meaning in this case."
msgstr ""
"Observe que, a menos que uma largura de campo mínima seja definida, a "
"largura do campo sempre será igual à largura dos dados que preenchem, de "
"modo que a opção de alinhamento não tem significado neste caso."

#: ../../library/string.rst:382
msgid ""
"The *sign* option is only valid for number types, and can be one of the "
"following:"
msgstr ""
"A opção *sign* só é válida para tipos numéricos e pode ser um dos seguintes:"

#: ../../library/string.rst:393
msgid "``'+'``"
msgstr "``'+'``"

#: ../../library/string.rst:393
msgid ""
"Indicates that a sign should be used for both positive as well as negative "
"numbers."
msgstr "Indica que um sinal deve ser usado para números positivos e negativos."

#: ../../library/string.rst:396
msgid "``'-'``"
msgstr "``'-'``"

#: ../../library/string.rst:396
msgid ""
"Indicates that a sign should be used only for negative numbers (this is the "
"default behavior)."
msgstr ""
"Indica que um sinal deve ser usado apenas para números negativos (este é o "
"comportamento padrão)."

#: ../../library/string.rst:385 ../../library/string.rst:399
msgid "space"
msgstr "espaço"

#: ../../library/string.rst:399
msgid ""
"Indicates that a leading space should be used on positive numbers, and a "
"minus sign on negative numbers."
msgstr ""
"Indica que um espaço inicial deve ser usado em números positivos e um sinal "
"de menos em números negativos."

#: ../../library/string.rst:406
msgid ""
"The ``'z'`` option coerces negative zero floating-point values to positive "
"zero after rounding to the format precision.  This option is only valid for "
"floating-point presentation types."
msgstr ""
"A opção ``'z'`` força valores de ponto flutuante de zero negativo para zero "
"positivo após o arredondamento, conforme a precisão do formato. Esta opção "
"só é válida para tipos de apresentação de ponto flutuante."

#: ../../library/string.rst:410
msgid "Added the ``'z'`` option (see also :pep:`682`)."
msgstr "Adicionada a opção ``'z'`` (veja também :pep:`682`)."

#: ../../library/string.rst:415
msgid ""
"The ``'#'`` option causes the \"alternate form\" to be used for the "
"conversion.  The alternate form is defined differently for different types.  "
"This option is only valid for integer, float and complex types. For "
"integers, when binary, octal, or hexadecimal output is used, this option "
"adds the respective prefix ``'0b'``, ``'0o'``, ``'0x'``, or ``'0X'`` to the "
"output value. For float and complex the alternate form causes the result of "
"the conversion to always contain a decimal-point character, even if no "
"digits follow it. Normally, a decimal-point character appears in the result "
"of these conversions only if a digit follows it. In addition, for ``'g'`` "
"and ``'G'`` conversions, trailing zeros are not removed from the result."
msgstr ""
"A opção ``'#'`` faz com que a \"forma alternativa\" seja usada na conversão. "
"A forma alternativa é definida de forma diferente para cada tipo. Esta opção "
"é válida apenas para tipos inteiros, pontos flutuantes e complexos. Para "
"inteiros, quando a saída binária, octal ou hexadecimal é usada, esta opção "
"adiciona o prefixo respectivo ``'0b'``, ``'0o'``, ``'0x'`` ou ``'0X'`` ao "
"valor de saída. Para pontos flutuantes e complexos, a forma alternativa faz "
"com que o resultado da conversão sempre contenha um caractere de ponto "
"decimal, mesmo que não haja nenhum dígito após. Normalmente, um caractere de "
"ponto decimal aparece no resultado dessas conversões apenas se houver um "
"dígito depois. Além disso, nas conversões ``'g'`` e ``'G'``, os zeros finais "
"não são removidos do resultado."

#: ../../library/string.rst:427
msgid ""
"The *width* is a decimal integer defining the minimum total field width, "
"including any prefixes, separators, and other formatting characters. If not "
"specified, then the field width will be determined by the content."
msgstr ""
"O *width* é um número inteiro decimal que define a largura mínima total do "
"campo, incluindo quaisquer prefixos, separadores e outros caracteres de "
"formatação. Se não for especificado, a largura do campo será determinada "
"pelo conteúdo."

#: ../../library/string.rst:431
msgid ""
"When no explicit alignment is given, preceding the *width* field by a zero "
"(``'0'``) character enables sign-aware zero-padding for numeric types, "
"excluding :class:`complex`.  This is equivalent to a *fill* character of "
"``'0'`` with an *alignment* type of ``'='``."
msgstr ""
"Quando nenhum alinhamento explícito é fornecido, preceder o campo *width* "
"com um caractere zero (``'0'``) habilita o preenchimento por zero, com "
"reconhecimento de sinal, para tipos numéricos, exceto :class:`complex`. Isso "
"é equivalente a um caractere *fill* de valor ``'0'`` e *alignment* de "
"``'='``."

#: ../../library/string.rst:436
msgid ""
"Preceding the *width* field by ``'0'`` no longer affects the default "
"alignment for strings."
msgstr ""
"Preceder o campo *width* com ``'0'`` não afeta mais o alinhamento padrão de "
"strings."

#: ../../library/string.rst:440
msgid ""
"The *precision* is a decimal integer indicating how many digits should be "
"displayed after the decimal point for presentation types ``'f'`` and "
"``'F'``, or before and after the decimal point for presentation types "
"``'g'`` or ``'G'``.  For string presentation types the field indicates the "
"maximum field size - in other words, how many characters will be used from "
"the field content.  The *precision* is not allowed for integer presentation "
"types."
msgstr ""
"*precision* é um número decimal que indica quantos dígitos devem ser "
"exibidos depois do ponto decimal para um valor de ponto flutuante formatado "
"com ``'f'`` e ``'F'``, ou antes e depois do ponto decimal para um valor de "
"ponto flutuante formatado com ``'g'`` ou ``'G'``. Para tipos não numéricos, "
"o campo indica o tamanho máximo do campo -- em outras palavras, quantos "
"caracteres serão usados do conteúdo do campo. *precision* não é permitido "
"para valores inteiros."

#: ../../library/string.rst:448
msgid ""
"The *grouping* option after *width* and *precision* fields specifies a digit "
"group separator for the integral and fractional parts of a number "
"respectively. It can be one of the following:"
msgstr ""
"A opção *grouping* após os campos *width* e *precision* especifica um "
"separador de grupo de dígitos para as partes inteira e fracionária de um "
"número, respectivamente. Pode ser um dos seguintes:"

#: ../../library/string.rst:459
msgid "``','``"
msgstr "``','``"

#: ../../library/string.rst:459
msgid ""
"Inserts a comma every 3 digits for integer presentation type ``'d'`` and "
"floating-point presentation types, excluding ``'n'``. For other presentation "
"types, this option is not supported."
msgstr ""
"Insere uma vírgula a cada 3 dígitos para tipos de apresentação inteiros "
"``'d'`` e de ponto flutuante, excluindo ``'n'``. Não há suporte para essa "
"opção em outros tipos de apresentação."

#: ../../library/string.rst:465
msgid "``'_'``"
msgstr "``'_'``"

#: ../../library/string.rst:465
msgid ""
"Inserts an underscore every 3 digits for integer presentation type ``'d'`` "
"and floating-point presentation types, excluding ``'n'``. For integer "
"presentation types ``'b'``, ``'o'``, ``'x'``, and ``'X'``, underscores are "
"inserted every 4 digits. For other presentation types, this option is not "
"supported."
msgstr ""
"Insere um sublinhado a cada 3 dígitos para tipos de apresentação inteiros "
"``'d'`` e tipos de apresentação de ponto flutuante, excluindo ``'n'``. Para "
"os tipos de apresentação inteiros ``'b'``, ``'o'``, ``'x'`` e ``'X'``, os "
"sublinhados são inseridos a cada 4 dígitos. Para outros tipos de "
"apresentação, esta opção não é suportada."

#: ../../library/string.rst:475
msgid ""
"For a locale-aware separator, use the ``'n'`` :ref:`float presentation type "
"<n-format-float>` or :ref:`integer presentation type <n-format-integer>` "
"instead."
msgstr ""
"Para um separador que respeita as configurações da localidade, utilize em "
"vez disso o ``'n'`` do :ref:`tipo de apresentação para ponto flutuante <n-"
"format-float>` ou do :ref:`tipo de apresentação para números inteiros <n-"
"format-integer>`."

#: ../../library/string.rst:479
msgid "Added the ``','`` option (see also :pep:`378`)."
msgstr "Adicionada a opção ``','`` (veja também :pep:`378`)."

#: ../../library/string.rst:482
msgid "Added the ``'_'`` option (see also :pep:`515`)."
msgstr "Adicionada a opção ``'_'`` (veja também :pep:`515`)."

#: ../../library/string.rst:485
msgid "Support the *grouping* option for the fractional part."
msgstr "Suporte a opção *grouping* para a parte fracionária."

#: ../../library/string.rst:488
msgid "Finally, the *type* determines how the data should be presented."
msgstr "Finalmente, o *type* determina como os dados devem ser apresentados."

#: ../../library/string.rst:490
msgid "The available string presentation types are:"
msgstr "Os tipos de apresentação de string disponíveis são:"

#: ../../library/string.rst:493 ../../library/string.rst:504
#: ../../library/string.rst:544
msgid "Type"
msgstr "Tipo"

#: ../../library/string.rst:495
msgid "``'s'``"
msgstr "``'s'``"

#: ../../library/string.rst:495
msgid "String format. This is the default type for strings and may be omitted."
msgstr ""
"Formato de string. Este é o tipo padrão para strings e pode ser omitido."

#: ../../library/string.rst:498 ../../library/string.rst:532
#: ../../library/string.rst:626
msgid "None"
msgstr "None"

#: ../../library/string.rst:498
msgid "The same as ``'s'``."
msgstr "O mesmo que ``'s'``."

#: ../../library/string.rst:501
msgid "The available integer presentation types are:"
msgstr "Os tipos de apresentação inteira disponíveis são:"

#: ../../library/string.rst:506
msgid "``'b'``"
msgstr "``'b'``"

#: ../../library/string.rst:506
msgid "Binary format. Outputs the number in base 2."
msgstr "Formato binário. Exibe o número na base 2."

#: ../../library/string.rst:508
msgid "``'c'``"
msgstr "``'c'``"

#: ../../library/string.rst:508
msgid ""
"Character. Converts the integer to the corresponding unicode character "
"before printing."
msgstr ""
"Caractere. Converte o inteiro no caractere Unicode correspondente antes de "
"imprimir."

#: ../../library/string.rst:511
msgid "``'d'``"
msgstr "``'d'``"

#: ../../library/string.rst:511
msgid "Decimal Integer. Outputs the number in base 10."
msgstr "Inteiro decimal. Exibe o número na base 10."

#: ../../library/string.rst:513
msgid "``'o'``"
msgstr "``'o'``"

#: ../../library/string.rst:513
msgid "Octal format. Outputs the number in base 8."
msgstr "Formato octal. Exibe o número na base 8."

#: ../../library/string.rst:515
msgid "``'x'``"
msgstr "``'x'``"

#: ../../library/string.rst:515
msgid ""
"Hex format. Outputs the number in base 16, using lower-case letters for the "
"digits above 9."
msgstr ""
"Formato hexadecimal. Produz o número na base 16, usando letras minúsculas "
"para os dígitos acima de 9."

#: ../../library/string.rst:518
msgid "``'X'``"
msgstr "``'X'``"

#: ../../library/string.rst:518
msgid ""
"Hex format. Outputs the number in base 16, using upper-case letters for the "
"digits above 9. In case ``'#'`` is specified, the prefix ``'0x'`` will be "
"upper-cased to ``'0X'`` as well."
msgstr ""
"Formato hexadecimal. Exibe o número na base 16, usando letras maiúsculas "
"para os dígitos acima de 9. No caso de ``'#'`` ser especificado, o prefixo "
"``'0x'`` será maiúsculo para ``'0X'`` também."

#: ../../library/string.rst:523 ../../library/string.rst:613
msgid "``'n'``"
msgstr "``'n'``"

#: ../../library/string.rst:525
msgid ""
"Number. This is the same as ``'d'``, except that it uses the current locale "
"setting to insert the appropriate digit group separators. Note that the "
"default locale is not the system locale. Depending on your use case, you may "
"wish to set :const:`~locale.LC_NUMERIC` with :func:`locale.setlocale` before "
"using ``'n'``."
msgstr ""
"Número. É o mesmo que ``'d'``, exceto pelo fato de utilizar a configuração "
"de localidade atual para inserir os separadores de grupo de dígitos "
"apropriados. Observe que a localidade padrão não é a localidade do sistema. "
"Dependendo do seu caso de uso, talvez você queira definir :const:`~locale."
"LC_NUMERIC` com :func:`locale.setlocale` antes de usar ``'n'``."

#: ../../library/string.rst:532
msgid "The same as ``'d'``."
msgstr "O mesmo que ``'d'``."

#: ../../library/string.rst:535
msgid ""
"In addition to the above presentation types, integers can be formatted with "
"the floating-point presentation types listed below (except ``'n'`` and "
"``None``). When doing so, :func:`float` is used to convert the integer to a "
"floating-point number before formatting."
msgstr ""
"Além dos tipos de apresentação acima, os inteiros podem ser formatados com "