datamodel.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:
# Adorilson Bezerra <adorilson@gmail.com>, 2025
# python-doc bot, 2026
# Rafael Fontenelle <rffontenelle@gmail.com>, 2026
# Raphael Mendes, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-19 19:33+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: Raphael Mendes, 2026\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"

#: ../../reference/datamodel.rst:6
msgid "Data model"
msgstr "Modelo de dados"

#: ../../reference/datamodel.rst:12
msgid "Objects, values and types"
msgstr "Objetos, valores e tipos"

#: ../../reference/datamodel.rst:18
msgid ""
":dfn:`Objects` are Python's abstraction for data.  All data in a Python "
"program is represented by objects or by relations between objects. Even code "
"is represented by objects."
msgstr ""
":dfn:`Objetos` são abstrações do Python para dados. Todos os dados em um "
"programa Python são representados por objetos ou por relações entre objetos. "
"Código também é representado por objetos."

#: ../../reference/datamodel.rst:31
msgid ""
"Every object has an identity, a type and a value.  An object's *identity* "
"never changes once it has been created; you may think of it as the object's "
"address in memory.  The :keyword:`is` operator compares the identity of two "
"objects; the :func:`id` function returns an integer representing its "
"identity."
msgstr ""
"Todo objeto tem uma identidade, um tipo e um valor. A *identidade* de um "
"objeto nunca muda depois de criado; você pode pensar nisso como endereço de "
"objetos em memória. O operador :keyword:`is` compara as identidades de dois "
"objetos; a função :func:`id` retorna um inteiro representando sua identidade."

#: ../../reference/datamodel.rst:38
msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored."
msgstr ""
"Para CPython, ``id(x)`` é o endereço de memória em que ``x`` está armazenado."

#: ../../reference/datamodel.rst:40
msgid ""
"An object's type determines the operations that the object supports (e.g., "
"\"does it have a length?\") and also defines the possible values for objects "
"of that type.  The :func:`type` function returns an object's type (which is "
"an object itself).  Like its identity, an object's :dfn:`type` is also "
"unchangeable. [#]_"
msgstr ""
"O tipo de um objeto determina as operações que o objeto implementa (por "
"exemplo, \"ele tem um comprimento?\") e também define os valores possíveis "
"para objetos desse tipo. A função :func:`type` retorna o tipo de um objeto "
"(que é também um objeto). Como sua identidade, o :dfn:`tipo` do objeto "
"também é imutável. [#]_"

#: ../../reference/datamodel.rst:46
msgid ""
"The *value* of some objects can change.  Objects whose value can change are "
"said to be *mutable*; objects whose value is unchangeable once they are "
"created are called *immutable*. (The value of an immutable container object "
"that contains a reference to a mutable object can change when the latter's "
"value is changed; however the container is still considered immutable, "
"because the collection of objects it contains cannot be changed.  So, "
"immutability is not strictly the same as having an unchangeable value, it is "
"more subtle.) An object's mutability is determined by its type; for "
"instance, numbers, strings and tuples are immutable, while dictionaries and "
"lists are mutable."
msgstr ""
"O *valor* de alguns objetos pode mudar. Objetos cujos valores podem mudar "
"são descritos como *mutáveis*, objetos cujo valor não pode ser mudado uma "
"vez que foram criados são chamados *imutáveis*. (O valor de um objeto "
"contêiner imutável que contém uma referência a um objeto mutável pode mudar "
"quando o valor deste último for mudado; no entanto o contêiner é ainda assim "
"considerada imutável, pois a coleção de objetos que contém não pode ser "
"mudada. Então a imutabilidade não é estritamente o mesmo do que não haver "
"mudanças de valor, é mais sutil.) A mutabilidade de um objeto é determinada "
"pelo seu tipo; por exemplo, números, strings e tuplas são imutáveis, "
"enquanto dicionários e listas são mutáveis."

#: ../../reference/datamodel.rst:61
msgid ""
"Objects are never explicitly destroyed; however, when they become "
"unreachable they may be garbage-collected.  An implementation is allowed to "
"postpone garbage collection or omit it altogether --- it is a matter of "
"implementation quality how garbage collection is implemented, as long as no "
"objects are collected that are still reachable."
msgstr ""
"Os objetos nunca são destruídos explicitamente; no entanto, quando eles se "
"tornam inacessíveis, eles podem ser coletados como lixo. Uma implementação "
"tem permissão para adiar a coleta de lixo ou omiti-la completamente -- é uma "
"questão de detalhe de implementação como a coleta de lixo é implementada, "
"desde que nenhum objeto que ainda esteja acessível seja coletado."

#: ../../reference/datamodel.rst:69
msgid ""
"CPython currently uses a reference-counting scheme with (optional) delayed "
"detection of cyclically linked garbage, which collects most objects as soon "
"as they become unreachable, but is not guaranteed to collect garbage "
"containing circular references.  See the documentation of the :mod:`gc` "
"module for information on controlling the collection of cyclic garbage. "
"Other implementations act differently and CPython may change. Do not depend "
"on immediate finalization of objects when they become unreachable (so you "
"should always close files explicitly)."
msgstr ""
"CPython atualmente usa um esquema de contagem de referências com detecção "
"atrasada (opcional) de lixo ligado ciclicamente, que coleta a maioria dos "
"objetos assim que eles se tornam inacessíveis, mas não é garantido que "
"coletará lixo contendo referências circulares. Veja a documentação do "
"módulo :mod:`gc` para informações sobre como controlar a coleta de lixo "
"cíclico. Outras implementações agem de forma diferente e o CPython pode "
"mudar. Não dependa da finalização imediata dos objetos quando eles se "
"tornarem inacessíveis (isto é, você deve sempre fechar os arquivos "
"explicitamente)."

#: ../../reference/datamodel.rst:78
msgid ""
"Note that the use of the implementation's tracing or debugging facilities "
"may keep objects alive that would normally be collectable. Also note that "
"catching an exception with a :keyword:`try`...\\ :keyword:`except` statement "
"may keep objects alive."
msgstr ""
"Observe que o uso dos recursos de rastreamento ou depuração da implementação "
"pode manter os objetos ativos que normalmente seriam coletáveis. Observe "
"também que capturar uma exceção com uma instrução :keyword:`try`...\\ :"
"keyword:`except` pode manter os objetos vivos."

#: ../../reference/datamodel.rst:83
msgid ""
"Some objects contain references to \"external\" resources such as open files "
"or windows.  It is understood that these resources are freed when the object "
"is garbage-collected, but since garbage collection is not guaranteed to "
"happen, such objects also provide an explicit way to release the external "
"resource, usually a :meth:`!close` method. Programs are strongly recommended "
"to explicitly close such objects.  The :keyword:`try`...\\ :keyword:"
"`finally` statement and the :keyword:`with` statement provide convenient "
"ways to do this."
msgstr ""
"Alguns objetos contêm referências a recursos \"externos\", como arquivos "
"abertos ou janelas. Entende-se que esses recursos são liberados quando o "
"objeto é coletado como lixo, mas como a coleta de lixo não é garantida, tais "
"objetos também fornecem uma maneira explícita de liberar o recurso externo, "
"geralmente um método :meth:`!close`. Os programas são fortemente "
"recomendados para fechar explicitamente esses objetos. A instrução :keyword:"
"`try`...\\ :keyword:`finally` e a instrução :keyword:`with` fornecem "
"maneiras convenientes de fazer isso."

#: ../../reference/datamodel.rst:93
msgid ""
"Some objects contain references to other objects; these are called "
"*containers*. Examples of containers are tuples, lists and dictionaries.  "
"The references are part of a container's value.  In most cases, when we talk "
"about the value of a container, we imply the values, not the identities of "
"the contained objects; however, when we talk about the mutability of a "
"container, only the identities of the immediately contained objects are "
"implied.  So, if an immutable container (like a tuple) contains a reference "
"to a mutable object, its value changes if that mutable object is changed."
msgstr ""
"Alguns objetos contêm referências a outros objetos; eles são chamados de "
"*contêineres*. Exemplos de contêineres são tuplas, listas e dicionários. As "
"referências fazem parte do valor de um contêiner. Na maioria dos casos, "
"quando falamos sobre o valor de um contêiner, nos referimos aos valores, não "
"às identidades dos objetos contidos; entretanto, quando falamos sobre a "
"mutabilidade de um contêiner, apenas as identidades dos objetos contidos "
"imediatamente estão implícitas. Portanto, se um contêiner imutável (como uma "
"tupla) contém uma referência a um objeto mutável, seu valor muda se esse "
"objeto mutável for alterado."

#: ../../reference/datamodel.rst:102
msgid ""
"Types affect almost all aspects of object behavior.  Even the importance of "
"object identity is affected in some sense: for immutable types, operations "
"that compute new values may actually return a reference to any existing "
"object with the same type and value, while for mutable objects this is not "
"allowed. For example, after ``a = 1; b = 1``, *a* and *b* may or may not "
"refer to the same object with the value one, depending on the "
"implementation. This is because :class:`int` is an immutable type, so the "
"reference to ``1`` can be reused. This behaviour depends on the "
"implementation used, so should not be relied upon, but is something to be "
"aware of when making use of object identity tests. However, after ``c = []; "
"d = []``, *c* and *d* are guaranteed to refer to two different, unique, "
"newly created empty lists. (Note that ``e = f = []`` assigns the *same* "
"object to both *e* and *f*.)"
msgstr ""
"Os tipos afetam quase todos os aspectos do comportamento do objeto. Até "
"mesmo a importância da identidade do objeto é afetada em algum sentido: para "
"tipos imutáveis, as operações que calculam novos valores podem realmente "
"retornar uma referência a qualquer objeto existente com o mesmo tipo e "
"valor, enquanto para objetos mutáveis isso não é permitido. Por exemplo, "
"após ``a = 1; b = 1``, *a* e *b* podem ou não se referir ao mesmo objeto com "
"o valor um, dependendo da implementação. Isto ocorre porque :class:`int` é "
"um tipo imutável, então a referência a ``1`` pode ser reutilizada. Este "
"comportamento depende da implementação usada, então não deve ser considerada "
"confiável, mas é algo para se estar ciente ao fazer uso de testes de "
"identidade de objeto. No entanto, após ``c = []; d = []``, *c* e *d* têm a "
"garantia de referir-se a duas listas vazias diferentes e únicas. (Observe "
"que ``e = f = []`` atribui o *mesmo* objeto para *e* e *f*.)"

#: ../../reference/datamodel.rst:120
msgid "The standard type hierarchy"
msgstr "A hierarquia de tipos padrão"

#: ../../reference/datamodel.rst:129
msgid ""
"Below is a list of the types that are built into Python.  Extension modules "
"(written in C, Java, or other languages, depending on the implementation) "
"can define additional types.  Future versions of Python may add types to the "
"type hierarchy (e.g., rational numbers, efficiently stored arrays of "
"integers, etc.), although such additions will often be provided via the "
"standard library instead."
msgstr ""
"Abaixo está uma lista dos tipos que são embutidos no Python. Módulos de "
"extensão (escritos em C, Java ou outras linguagens, dependendo da "
"implementação) podem definir tipos adicionais. Versões futuras do Python "
"podem adicionar tipos à hierarquia de tipo (por exemplo, números racionais, "
"matrizes de inteiros armazenadas de forma eficiente, etc.), embora tais "
"adições sejam frequentemente fornecidas por meio da biblioteca padrão."

#: ../../reference/datamodel.rst:140
msgid ""
"Some of the type descriptions below contain a paragraph listing 'special "
"attributes.'  These are attributes that provide access to the implementation "
"and are not intended for general use.  Their definition may change in the "
"future."
msgstr ""
"Algumas das descrições de tipo abaixo contêm um parágrafo listando "
"\"atributos especiais\". Esses são atributos que fornecem acesso à "
"implementação e não se destinam ao uso geral. Sua definição pode mudar no "
"futuro."

#: ../../reference/datamodel.rst:146 ../../reference/datamodel.rst:148
msgid "None"
msgstr "None"

#: ../../reference/datamodel.rst:150
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the built-in name ``None``. It is used to "
"signify the absence of a value in many situations, e.g., it is returned from "
"functions that don't explicitly return anything. Its truth value is false."
msgstr ""
"Este tipo possui um único valor. Existe um único objeto com este valor. Este "
"objeto é acessado através do nome embutido ``None``. É usado para significar "
"a ausência de um valor em muitas situações, por exemplo, ele é retornado de "
"funções que não retornam nada explicitamente. Seu valor verdade é falso."

#: ../../reference/datamodel.rst:157 ../../reference/datamodel.rst:159
msgid "NotImplemented"
msgstr "NotImplemented"

#: ../../reference/datamodel.rst:161
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the built-in name :data:`NotImplemented`. "
"Numeric methods and rich comparison methods should return this value if they "
"do not implement the operation for the operands provided.  (The interpreter "
"will then try the reflected operation, or some other fallback, depending on "
"the operator.)  It should not be evaluated in a boolean context."
msgstr ""
"Este tipo possui um único valor. Existe um único objeto com este valor. Este "
"objeto é acessado através do nome embutido :data:`NotImplemented`. Os "
"métodos numéricos e métodos de comparação rica devem retornar esse valor se "
"não implementarem a operação para os operandos fornecidos. (O interpretador "
"tentará então a operação refletida ou alguma outra alternativa, dependendo "
"do operador.) Não deve ser avaliado em um contexto booleano."

#: ../../reference/datamodel.rst:168
msgid "See :ref:`implementing-the-arithmetic-operations` for more details."
msgstr ""
"Veja a documentação :ref:`implementing-the-arithmetic-operations` para mais "
"detalhes."

#: ../../reference/datamodel.rst:172
msgid "Evaluating :data:`NotImplemented` in a boolean context was deprecated."
msgstr ""
"A avaliação de :data:`NotImplemented` em um contexto booleano foi "
"descontinuada."

#: ../../reference/datamodel.rst:175
msgid ""
"Evaluating :data:`NotImplemented` in a boolean context now raises a :exc:"
"`TypeError`. It previously evaluated to :const:`True` and emitted a :exc:"
"`DeprecationWarning` since Python 3.9."
msgstr ""
"A avaliação de :data:`NotImplemented` em um contexto booleano agora levanta "
"um :exc:`TypeError`. Anteriormente, ele era avaliado como :const:`True` e "
"emitia um :exc:`DeprecationWarning` desde o Python 3.9."

#: ../../reference/datamodel.rst:182 ../../reference/datamodel.rst:183
msgid "Ellipsis"
msgstr "Ellipsis"

#: ../../reference/datamodel.rst:187
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the literal ``...`` or the built-in name "
"``Ellipsis``.  Its truth value is true."
msgstr ""
"Este tipo possui um único valor. Existe um único objeto com este valor. Este "
"objeto é acessado através do literal ``...`` ou do nome embutido "
"``Ellipsis`` (reticências). Seu valor verdade é verdadeiro."

#: ../../reference/datamodel.rst:193
msgid ":class:`numbers.Number`"
msgstr ":class:`numbers.Number`"

#: ../../reference/datamodel.rst:197
msgid ""
"These are created by numeric literals and returned as results by arithmetic "
"operators and arithmetic built-in functions.  Numeric objects are immutable; "
"once created their value never changes.  Python numbers are of course "
"strongly related to mathematical numbers, but subject to the limitations of "
"numerical representation in computers."
msgstr ""
"Esses são criados por literais numéricos e retornados como resultados por "
"operadores aritméticos e funções aritméticas embutidas. Os objetos numéricos "
"são imutáveis; uma vez criado, seu valor nunca muda. Os números do Python "
"são, obviamente, fortemente relacionados aos números matemáticos, mas "
"sujeitos às limitações da representação numérica em computadores."

#: ../../reference/datamodel.rst:203
msgid ""
"The string representations of the numeric classes, computed by :meth:"
"`~object.__repr__` and :meth:`~object.__str__`, have the following "
"properties:"
msgstr ""
"As representações de string das classes numéricas, calculadas por :meth:"
"`~object.__repr__` e :meth:`~object.__str__`, têm as seguintes propriedades:"

#: ../../reference/datamodel.rst:207
msgid ""
"They are valid numeric literals which, when passed to their class "
"constructor, produce an object having the value of the original numeric."
msgstr ""
"Elas são literais numéricos válidos que, quando passados para seu construtor "
"de classe, produzem um objeto com o valor do numérico original."

#: ../../reference/datamodel.rst:211
msgid "The representation is in base 10, when possible."
msgstr "A representação está na base 10, quando possível."

#: ../../reference/datamodel.rst:213
msgid ""
"Leading zeros, possibly excepting a single zero before a decimal point, are "
"not shown."
msgstr ""
"Os zeros à esquerda, possivelmente com exceção de um único zero antes de um "
"ponto decimal, não são mostrados."

#: ../../reference/datamodel.rst:216
msgid ""
"Trailing zeros, possibly excepting a single zero after a decimal point, are "
"not shown."
msgstr ""
"Os zeros à direita, possivelmente com exceção de um único zero após um ponto "
"decimal, não são mostrados."

#: ../../reference/datamodel.rst:219
msgid "A sign is shown only when the number is negative."
msgstr "Um sinal é mostrado apenas quando o número é negativo."

#: ../../reference/datamodel.rst:221
msgid ""
"Python distinguishes between integers, floating-point numbers, and complex "
"numbers:"
msgstr ""
"Python distingue entre inteiros, números de ponto flutuante e números "
"complexos:"

#: ../../reference/datamodel.rst:226
msgid ":class:`numbers.Integral`"
msgstr ":class:`numbers.Integral`"

#: ../../reference/datamodel.rst:230
msgid ""
"These represent elements from the mathematical set of integers (positive and "
"negative)."
msgstr ""
"Estes representam elementos do conjunto matemático de inteiros (positivos e "
"negativos)."

#: ../../reference/datamodel.rst:236
msgid ""
"The rules for integer representation are intended to give the most "
"meaningful interpretation of shift and mask operations involving negative "
"integers."
msgstr ""
"As regras para representação de inteiros têm como objetivo fornecer a "
"interpretação mais significativa das operações de deslocamento e máscara "
"envolvendo inteiros negativos."

#: ../../reference/datamodel.rst:239
msgid "There are two types of integers:"
msgstr "Existem dois tipos de inteiros:"

#: ../../reference/datamodel.rst:241
msgid "Integers (:class:`int`)"
msgstr "Inteiros (:class:`int`)"

#: ../../reference/datamodel.rst:242
msgid ""
"These represent numbers in an unlimited range, subject to available "
"(virtual) memory only.  For the purpose of shift and mask operations, a "
"binary representation is assumed, and negative numbers are represented in a "
"variant of 2's complement which gives the illusion of an infinite string of "
"sign bits extending to the left."
msgstr ""
"Estes representam números em um intervalo ilimitado, sujeito apenas à "
"memória (virtual) disponível. Para o propósito de operações de deslocamento "
"e máscara, uma representação binária é presumida e os números negativos são "
"representados em uma variante do complemento de 2 que dá a ilusão de uma "
"string infinita de bits de sinal estendendo-se para a esquerda."

#: ../../reference/datamodel.rst:248
msgid "Booleans (:class:`bool`)"
msgstr "Booleanos (:class:`bool`)"

#: ../../reference/datamodel.rst:254
msgid ""
"These represent the truth values False and True.  The two objects "
"representing the values ``False`` and ``True`` are the only Boolean objects. "
"The Boolean type is a subtype of the integer type, and Boolean values behave "
"like the values 0 and 1, respectively, in almost all contexts, the exception "
"being that when converted to a string, the strings ``\"False\"`` or "
"``\"True\"`` are returned, respectively."
msgstr ""
"Estes representam os valores da verdade Falsos e Verdadeiros. Os dois "
"objetos que representam os valores ``False`` e ``True`` são os únicos "
"objetos booleanos. O tipo booleano é um subtipo do tipo inteiro, e os "
"valores booleanos se comportam como os valores 0 e 1, respectivamente, em "
"quase todos os contextos, com exceção de que, quando convertidos em uma "
"string, as strings ``\"False\"`` ou ``\"True\"`` são retornados, "
"respectivamente."

#: ../../reference/datamodel.rst:264
msgid ":class:`numbers.Real` (:class:`float`)"
msgstr ":class:`numbers.Real` (:class:`float`)"

#: ../../reference/datamodel.rst:272
msgid ""
"These represent machine-level double precision floating-point numbers. You "
"are at the mercy of the underlying machine architecture (and C or Java "
"implementation) for the accepted range and handling of overflow. Python does "
"not support single-precision floating-point numbers; the savings in "
"processor and memory usage that are usually the reason for using these are "
"dwarfed by the overhead of using objects in Python, so there is no reason to "
"complicate the language with two kinds of floating-point numbers."
msgstr ""
"Estes representam números de ponto flutuante de precisão dupla no nível da "
"máquina. Você está à mercê da arquitetura da máquina subjacente (e "
"implementação C ou Java) para o intervalo aceito e tratamento de estouro. "
"Python não oferece suporte a números de ponto flutuante de precisão única; a "
"economia no uso do processador e da memória, que normalmente é o motivo de "
"usá-los, é ofuscada pela sobrecarga do uso de objetos em Python, portanto, "
"não há razão para complicar a linguagem com dois tipos de números de ponto "
"flutuante."

#: ../../reference/datamodel.rst:282
msgid ":class:`numbers.Complex` (:class:`complex`)"
msgstr ":class:`numbers.Complex` (:class:`complex`)"

#: ../../reference/datamodel.rst:288
msgid ""
"These represent complex numbers as a pair of machine-level double precision "
"floating-point numbers.  The same caveats apply as for floating-point "
"numbers. The real and imaginary parts of a complex number ``z`` can be "
"retrieved through the read-only attributes ``z.real`` and ``z.imag``."
msgstr ""
"Estes representam números complexos como um par de números de ponto "
"flutuante de precisão dupla no nível da máquina. As mesmas advertências se "
"aplicam aos números de ponto flutuante. As partes reais e imaginárias de um "
"número complexo ``z`` podem ser obtidas através dos atributos somente "
"leitura ``z.real`` e ``z.imag``."

#: ../../reference/datamodel.rst:296
msgid "Sequences"
msgstr "Sequências"

#: ../../reference/datamodel.rst:305
msgid ""
"These represent finite ordered sets indexed by non-negative numbers. The "
"built-in function :func:`len` returns the number of items of a sequence. "
"When the length of a sequence is *n*, the index set contains the numbers 0, "
"1, ..., *n*-1.  Item *i* of sequence *a* is selected by ``a[i]``. Some "
"sequences, including built-in sequences, interpret negative subscripts by "
"adding the sequence length. For example, ``a[-2]`` equals ``a[n-2]``, the "
"second to last item of sequence a with length ``n``."
msgstr ""
"Estes representam conjuntos ordenados finitos indexados por números não "
"negativos. A função embutida :func:`len` retorna o número de itens de uma "
"sequência. Quando o comprimento de uma sequência é *n*, o conjunto de "
"índices contém os números 0, 1, ..., *n*-1. O item *i* da sequência *a* é "
"selecionado por ``a[i]``. Algumas sequências, incluindo sequências "
"embutidas, interpretam subscritos negativos adicionando o comprimento da "
"sequência. Por exemplo, ``a[-2]`` é igual a ``a[n-2]``, o penúltimo item da "
"sequência a com comprimento ``n``."

#: ../../reference/datamodel.rst:313
msgid ""
"The resulting value must be a nonnegative integer less than the number of "
"items in the sequence. If it is not, an :exc:`IndexError` is raised."
msgstr ""
"O valor resultante deve ser um número inteiro não negativo menor que o "
"número de itens na sequência. Caso contrário, uma :exc:`IndexError` é "
"levantada."

#: ../../reference/datamodel.rst:322
msgid ""
"Sequences also support slicing: ``a[start:stop]`` selects all items with "
"index *k* such that *start* ``<=`` *k* ``<`` *stop*.  When used as an "
"expression, a slice is a sequence of the same type. The comment above about "
"negative subscripts also applies to negative slice positions. Note that no "
"error is raised if a slice position is less than zero or larger than the "
"length of the sequence."
msgstr ""
"Sequências também suportam fatiamento: ``a[start:stop]`` seleciona todos os "
"itens com índice *k* tal que *start*``<=``*k* ``<`` *stop*. Quando utilizada "
"como expressão, uma fatia é uma sequência do mesmo tipo. O comentário "
"anterior sobre índices negativos também se aplica a posições negativas em "
"fatiamento. Observe que nenhum erro é gerado se a posição da fatia for menor "
"que zero ou maior que o comprimento da sequência."

#: ../../reference/datamodel.rst:329
msgid ""
"If *start* is missing or :data:`None`, slicing behaves as if *start* was "
"zero. If *stop* is missing or ``None``, slicing behaves as if *stop* was "
"equal to the length of the sequence."
msgstr ""
"Se *start* estiver ausente ou for :data:`None` , o fatiamento se comporta "
"como se *start* fosse zero. Se *stop* estiver ausente ou for ``None`` , o "
"fatiamento se comporta como se *stop* fosse igual ao comprimento da "
"sequência."

#: ../../reference/datamodel.rst:333
msgid ""
"Some sequences also support \"extended slicing\" with a third \"step\" "
"parameter: ``a[i:j:k]`` selects all items of *a* with index *x* where ``x = "
"i + n*k``, *n* ``>=`` ``0`` and *i* ``<=`` *x* ``<`` *j*."
msgstr ""
"Algumas sequências também suportam \"fatiamento estendido\" com um terceiro "
"parâmetro de \"etapa\": ``a[i:j:k]`` seleciona todos os itens de *a* com "
"índice *x* onde ``x = i + n*k``, *n* ``>=`` ``0`` e *i* ``<=`` *x* ``<`` *j*."

#: ../../reference/datamodel.rst:337
msgid "Sequences are distinguished according to their mutability:"
msgstr "As sequências são distinguidas de acordo com sua mutabilidade:"

#: ../../reference/datamodel.rst:341
msgid "Immutable sequences"
msgstr "Sequências imutáveis"

#: ../../reference/datamodel.rst:347
msgid ""
"An object of an immutable sequence type cannot change once it is created.  "
"(If the object contains references to other objects, these other objects may "
"be mutable and may be changed; however, the collection of objects directly "
"referenced by an immutable object cannot change.)"
msgstr ""
"Um objeto de um tipo de sequência imutável não pode ser alterado depois de "
"criado. (Se o objeto contiver referências a outros objetos, esses outros "
"objetos podem ser mutáveis e podem ser alterados; no entanto, a coleção de "
"objetos diretamente referenciada por um objeto imutável não pode ser "
"alterada.)"

#: ../../reference/datamodel.rst:352
msgid "The following types are immutable sequences:"
msgstr "Os tipos a seguir são sequências imutáveis:"

#: ../../reference/datamodel.rst:357
msgid "Strings"
msgstr "Strings"

#: ../../reference/datamodel.rst:365
msgid ""
"A string (:class:`str`) is a sequence of values that represent :dfn:"
"`characters`, or more formally, *Unicode code points*. All the code points "
"in the range ``0`` to ``0x10FFFF`` can be represented in a string."
msgstr ""
"Uma string (:class:`str`) é uma sequência de valores que representam :dfn:"
"`caracteres` ou, mais formalmente, *pontos de código Unicode*. Todos os "
"pontos de código no intervalo de ``0`` a ``0x10FFFF`` podem ser "
"representados em uma string."

#: ../../reference/datamodel.rst:370
msgid ""
"Python doesn't have a dedicated *character* type. Instead, every code point "
"in the string is represented as a string object with length ``1``."
msgstr ""
"Python não possui um tipo de *caractere* dedicado. Em vez disso, cada ponto "
"de código na string é representado como um objeto de string com comprimento "
"``1``."

#: ../../reference/datamodel.rst:374
msgid ""
"The built-in function :func:`ord` converts a code point from its string form "
"to an integer in the range ``0`` to ``0x10FFFF``; :func:`chr` converts an "
"integer in the range ``0`` to ``0x10FFFF`` to the corresponding length ``1`` "
"string object. :meth:`str.encode` can be used to convert a :class:`str` to :"
"class:`bytes` using the given text encoding, and :meth:`bytes.decode` can be "
"used to achieve the opposite."
msgstr ""
"A função embutida :func:`ord` converte um ponto de código de sua forma de "
"string para um inteiro no intervalo de ``0`` a ``0x10FFFF``; :func:`chr` "
"converte um inteiro no intervalo de ``0`` a ``0x10FFFF`` para o objeto de "
"string de comprimento ``1`` correspondente. :meth:`str.encode` pode ser "
"usado para converter :class:`str` em :class:`bytes` usando a codificação do "
"texto, e :meth:`bytes.decode` pode ser usado para realizar a operação "
"inversa."

#: ../../reference/datamodel.rst:382
msgid "Tuples"
msgstr "Tuplas"

#: ../../reference/datamodel.rst:388
msgid ""
"The items of a :class:`tuple` are arbitrary Python objects. Tuples of two or "
"more items are formed by comma-separated lists of expressions.  A tuple of "
"one item (a 'singleton') can be formed by affixing a comma to an expression "
"(an expression by itself does not create a tuple, since parentheses must be "
"usable for grouping of expressions).  An empty tuple can be formed by an "
"empty pair of parentheses."
msgstr ""

#: ../../reference/datamodel.rst:395
msgid "Bytes"
msgstr "Bytes"

#: ../../reference/datamodel.rst:398
msgid ""
"A :class:`bytes` object is an immutable array.  The items are 8-bit bytes, "
"represented by integers in the range 0 <= x < 256.  Bytes literals (like "
"``b'abc'``) and the built-in :func:`bytes` constructor can be used to create "
"bytes objects.  Also, bytes objects can be decoded to strings via the :meth:"
"`~bytes.decode` method."
msgstr ""

#: ../../reference/datamodel.rst:406
msgid "Mutable sequences"
msgstr "Sequências mutáveis"

#: ../../reference/datamodel.rst:415
msgid ""
"Mutable sequences can be changed after they are created.  The subscription "
"and slicing notations can be used as the target of assignment and :keyword:"
"`del` (delete) statements."
msgstr ""
"As sequências mutáveis podem ser alteradas após serem criadas. As notações "
"de subscrição e fatiamento podem ser usadas como o destino da atribuição e "
"instruções :keyword:`del` (*delete*, exclusão)."

#: ../../reference/datamodel.rst:423
msgid ""
"The :mod:`collections` and :mod:`array` module provide additional examples "
"of mutable sequence types."
msgstr ""
"Os módulos :mod:`collections` e :mod:`array` fornecem exemplos adicionais de "
"tipos de sequência mutáveis."

#: ../../reference/datamodel.rst:426
msgid "There are currently two intrinsic mutable sequence types:"
msgstr "Atualmente, existem dois tipos de sequência mutável intrínseca:"

#: ../../reference/datamodel.rst:428
msgid "Lists"
msgstr "Listas"

#: ../../reference/datamodel.rst:431
msgid ""
"The items of a list are arbitrary Python objects.  Lists are formed by "
"placing a comma-separated list of expressions in square brackets. (Note that "
"there are no special cases needed to form lists of length 0 or 1.)"
msgstr ""
"Os itens de uma lista são objetos Python arbitrários. As listas são formadas "
"colocando uma lista de expressões separada por vírgulas entre colchetes. "
"(Observe que não há casos especiais necessários para formar listas de "
"comprimento 0 ou 1.)"

#: ../../reference/datamodel.rst:435
msgid "Byte Arrays"
msgstr "Vetores de bytes"

#: ../../reference/datamodel.rst:438
msgid ""
"A bytearray object is a mutable array. They are created by the built-in :"
"func:`bytearray` constructor.  Aside from being mutable (and hence "
"unhashable), byte arrays otherwise provide the same interface and "
"functionality as immutable :class:`bytes` objects."
msgstr ""
"Um objeto bytearray é um vetor mutável. Eles são criados pelo construtor "
"embutido :func:`bytearray`. Além de serem mutáveis (e, portanto, não-"
"hasheável), os vetores de bytes fornecem a mesma interface e funcionalidade "
"que os objetos imutáveis :class:`bytes`."

#: ../../reference/datamodel.rst:445
msgid "Set types"
msgstr "Tipos de conjuntos"

#: ../../reference/datamodel.rst:451
msgid ""
"These represent unordered, finite sets of unique, immutable objects. As "
"such, they cannot be indexed by any subscript. However, they can be iterated "
"over, and the built-in function :func:`len` returns the number of items in a "
"set. Common uses for sets are fast membership testing, removing duplicates "
"from a sequence, and computing mathematical operations such as intersection, "
"union, difference, and symmetric difference."
msgstr ""
"Estes representam conjuntos finitos e não ordenados de objetos únicos e "
"imutáveis. Como tal, eles não podem ser indexados por nenhum subscrito. No "
"entanto, eles podem ser iterados, e a função embutida :func:`len` retorna o "
"número de itens em um conjunto. Os usos comuns para conjuntos são testes "
"rápidos de associação, remoção de duplicatas de uma sequência e computação "
"de operações matemáticas como interseção, união, diferença e diferença "
"simétrica."

#: ../../reference/datamodel.rst:458
msgid ""
"For set elements, the same immutability rules apply as for dictionary keys. "
"Note that numeric types obey the normal rules for numeric comparison: if two "
"numbers compare equal (e.g., ``1`` and ``1.0``), only one of them can be "
"contained in a set."
msgstr ""
"Para elementos de conjunto, as mesmas regras de imutabilidade se aplicam às "
"chaves de dicionário. Observe que os tipos numéricos obedecem às regras "
"normais para comparação numérica: se dois números forem iguais (por exemplo, "
"``1`` e ``1.0``), apenas um deles pode estar contido em um conjunto."

#: ../../reference/datamodel.rst:463
msgid "There are currently two intrinsic set types:"
msgstr "Atualmente, existem dois tipos de conjuntos intrínsecos:"

#: ../../reference/datamodel.rst:466
msgid "Sets"
msgstr "Conjuntos"

#: ../../reference/datamodel.rst:469
msgid ""
"These represent a mutable set. They are created by the built-in :func:`set` "
"constructor and can be modified afterwards by several methods, such as :meth:"
"`~set.add`."
msgstr ""
"Estes representam um conjunto mutável. Eles são criados pelo construtor "
"embutido :func:`set` e podem ser modificados posteriormente por vários "
"métodos, como :meth:`~set.add`."

#: ../../reference/datamodel.rst:474
msgid "Frozen sets"
msgstr "Conjuntos congelados"

#: ../../reference/datamodel.rst:477
msgid ""
"These represent an immutable set.  They are created by the built-in :func:"
"`frozenset` constructor.  As a frozenset is immutable and :term:`hashable`, "
"it can be used again as an element of another set, or as a dictionary key."
msgstr ""
"Estes representam um conjunto imutável. Eles são criados pelo construtor "
"embutido :func:`frozenset`. Como um frozenset é imutável e :term:`hasheável "
"<hashable>`, ele pode ser usado novamente como um elemento de outro "
"conjunto, ou como uma chave de dicionário."

#: ../../reference/datamodel.rst:486
msgid "Mappings"
msgstr "Mapeamentos"

#: ../../reference/datamodel.rst:493
msgid ""
"These represent finite sets of objects indexed by arbitrary index sets. The "
"subscript notation ``a[k]`` selects the item indexed by ``k`` from the "
"mapping ``a``; this can be used in expressions and as the target of "
"assignments or :keyword:`del` statements. The built-in function :func:`len` "
"returns the number of items in a mapping."
msgstr ""
"Eles representam conjuntos finitos de objetos indexados por conjuntos de "
"índices arbitrários. A notação subscrito ``a[k]`` seleciona o item indexado "
"por ``k`` do mapeamento ``a``; isso pode ser usado em expressões e como alvo "
"de atribuições ou instruções :keyword:`del`. A função embutida :func:`len` "
"retorna o número de itens em um mapeamento."

#: ../../reference/datamodel.rst:499
msgid "There are two intrinsic mapping types:"
msgstr "Existem dois tipos de mapeamento intrínseco:"

#: ../../reference/datamodel.rst:503
msgid "Dictionaries"
msgstr "Dicionários"

#: ../../reference/datamodel.rst:507
msgid ""
"These represent finite sets of objects indexed by nearly arbitrary values.  "
"The only types of values not acceptable as keys are values containing lists "
"or dictionaries or other mutable types that are compared by value rather "
"than by object identity, the reason being that the efficient implementation "
"of dictionaries requires a key's hash value to remain constant. Numeric "
"types used for keys obey the normal rules for numeric comparison: if two "
"numbers compare equal (e.g., ``1`` and ``1.0``) then they can be used "
"interchangeably to index the same dictionary entry."
msgstr ""
"Eles representam conjuntos finitos de objetos indexados por valores quase "
"arbitrários. Os únicos tipos de valores não aceitáveis como chaves são os "
"valores que contêm listas ou dicionários ou outros tipos mutáveis que são "
"comparados por valor em vez de por identidade de objeto, o motivo é que a "
"implementação eficiente de dicionários requer que o valor de hash de uma "
"chave permaneça constante. Os tipos numéricos usados para chaves obedecem às "
"regras normais para comparação numérica: se dois números forem iguais (por "
"exemplo, ``1`` e ``1.0``), eles podem ser usados alternadamente para indexar "
"a mesma entrada do dicionário."

#: ../../reference/datamodel.rst:516
msgid ""
"Dictionaries preserve insertion order, meaning that keys will be produced in "
"the same order they were added sequentially over the dictionary. Replacing "
"an existing key does not change the order, however removing a key and re-"
"inserting it will add it to the end instead of keeping its old place."
msgstr ""
"Dicionários preservam a ordem de inserção, o que significa que as chaves "
"serão produzidas na mesma ordem em que foram adicionadas sequencialmente no "
"dicionário. Substituir uma chave existente não altera a ordem, no entanto, "
"remover uma chave e inseri-la novamente irá adicioná-la ao final em vez de "
"manter seu lugar anterior."

#: ../../reference/datamodel.rst:521
msgid ""
"Dictionaries are mutable; they can be created by the ``{}`` notation (see "
"section :ref:`dict`)."
msgstr ""
"Os dicionários são mutáveis; eles podem ser criados pela notação ``{}`` "
"(veja a seção :ref:`dict`)."

#: ../../reference/datamodel.rst:528
msgid ""
"The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide additional "
"examples of mapping types, as does the :mod:`collections` module."
msgstr ""
"Os módulos de extensão :mod:`dbm.ndbm` e :mod:`dbm.gnu` fornecem exemplos "
"adicionais de tipos de mapeamento, assim como o módulo :mod:`collections`."

#: ../../reference/datamodel.rst:532
msgid ""
"Dictionaries did not preserve insertion order in versions of Python before "
"3.6. In CPython 3.6, insertion order was preserved, but it was considered an "
"implementation detail at that time rather than a language guarantee."
msgstr ""
"Dicionários não preservavam a ordem de inserção nas versões do Python "
"anteriores à 3.6. No CPython 3.6, a ordem de inserção foi preservada, mas "
"foi considerada um detalhe de implementação naquela época, em vez de uma "
"garantia da linguagem."

#: ../../reference/datamodel.rst:539
msgid "Frozen dictionaries"
msgstr "Dicionários congelados"

#: ../../reference/datamodel.rst:543
msgid ""
"These represent an immutable dictionary.  They are created by the built-in :"
"func:`frozendict` constructor.  A frozendict is :term:`hashable` if all of "
"its keys and values are hashable, in which case it can be used as an element "
"of a set, or as a key in another mapping.  :class:`!frozendict` is not a "
"subclass of :class:`dict`; it inherits directly from :class:`object`."
msgstr ""
"Estes representam um dicionário imutável. Eles são criados pelo construtor "
"embutido :func:`frozendict`. Um frozendict é :term:`hashable` se todas as "
"suas chaves e valores forem hasheável, caso em que pode ser usado como um "
"elemento de um conjunto, ou como uma chave em outro mapeamento. :class:`!"
"frozendict` não é uma subclasse de :class:`dict` ; ele herda diretamente de :"
"class:`object`."

#: ../../reference/datamodel.rst:553
msgid "Callable types"
msgstr "Tipos chamáveis"

#: ../../reference/datamodel.rst:561
msgid ""
"These are the types to which the function call operation (see section :ref:"
"`calls`) can be applied:"
msgstr ""
"Estes são os tipos aos quais a operação de chamada de função (veja a seção :"
"ref:`calls`) pode ser aplicada:"

#: ../../reference/datamodel.rst:568
msgid "User-defined functions"
msgstr "Funções definidas pelo usuário"

#: ../../reference/datamodel.rst:575
msgid ""
"A user-defined function object is created by a function definition (see "
"section :ref:`function`).  It should be called with an argument list "
"containing the same number of items as the function's formal parameter list."
msgstr ""
"Um objeto função definido pelo usuário será criado pela definição de função "
"(veja a seção :ref:`function`). A mesma deverá ser invocada com uma lista de "
"argumentos contendo o mesmo número de itens que a lista de parâmetros "
"formais da função."

#: ../../reference/datamodel.rst:581 ../../reference/datamodel.rst:1499
#: ../../reference/datamodel.rst:1702
msgid "Special read-only attributes"
msgstr "Atributos especiais de somente leitura"

#: ../../reference/datamodel.rst:592 ../../reference/datamodel.rst:634
#: ../../reference/datamodel.rst:1232
msgid "Attribute"
msgstr "Atributo"

#: ../../reference/datamodel.rst:593 ../../reference/datamodel.rst:635
#: ../../reference/datamodel.rst:1233
msgid "Meaning"
msgstr "Significado"

#: ../../reference/datamodel.rst:596
msgid ""
"A reference to the :class:`dictionary <dict>` that holds the function's "
"builtins namespace."
msgstr ""

#: ../../reference/datamodel.rst:602
msgid ""
"A reference to the :class:`dictionary <dict>` that holds the function's :ref:"
"`global variables <naming>` -- the global namespace of the module in which "
"the function was defined."
msgstr ""
"Uma referência ao :class:`dicionário <dict>` que contém as :ref:`variáveis "
"globais <naming>` da função -- o espaço de nomes global do módulo no qual a "
"função foi definida."

#: ../../reference/datamodel.rst:607
msgid ""
"``None`` or a :class:`tuple` of cells that contain bindings for the names "
"specified in the :attr:`~codeobject.co_freevars` attribute of the "
"function's :attr:`code object <function.__code__>`."
msgstr ""
"``None`` ou uma :class:`tuple` de células que contêm ligação para os nomes "
"especificados no atributo :attr:`~codeobject.co_freevars` do :attr:`objeto "
"código <function.__code__>` da função."

#: ../../reference/datamodel.rst:611
msgid ""
"A cell object has the attribute ``cell_contents``. This can be used to get "
"the value of the cell, as well as set the value."
msgstr ""
"Um objeto de célula tem o atributo ``cell_contents``. Isso pode ser usado "
"para obter o valor da célula, bem como definir o valor."

#: ../../reference/datamodel.rst:615 ../../reference/datamodel.rst:1750
msgid "Special writable attributes"
msgstr "Atributos especiais graváveis"

#: ../../reference/datamodel.rst:629
msgid "Most of these attributes check the type of the assigned value:"
msgstr "A maioria desses atributos verifica o tipo do valor atribuído:"

#: ../../reference/datamodel.rst:638
msgid "The function's documentation string, or ``None`` if unavailable."
msgstr "A string de documentação da função, ou ``None`` se indisponível."

#: ../../reference/datamodel.rst:641
msgid ""
"The function's name. See also: :attr:`__name__ attributes <definition."
"__name__>`."
msgstr ""
"O nome da função. Veja também: :attr:`atributos __name__ <definition."
"__name__>`."

#: ../../reference/datamodel.rst:645
msgid ""
"The function's :term:`qualified name`. See also: :attr:`__qualname__ "
"attributes <definition.__qualname__>`."
msgstr ""
"O :term:`nome qualificado` da função. Veja também: :attr:`atributos "
"__qualname__ <definition.__qualname__>`."

#: ../../reference/datamodel.rst:651
msgid ""
"The name of the module the function was defined in, or ``None`` if "
"unavailable."
msgstr ""
"O nome do módulo em que a função foi definida ou ``None`` se indisponível."

#: ../../reference/datamodel.rst:655
msgid ""