# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# python-doc bot, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-09-16 17:23+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: python-doc bot, 2025\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pt_BR\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"
#: ../../tutorial/stdlib2.rst:5
msgid "Brief Tour of the Standard Library --- Part II"
msgstr "Um breve passeio pela biblioteca padrão --- parte II"
#: ../../tutorial/stdlib2.rst:7
msgid ""
"This second tour covers more advanced modules that support professional "
"programming needs. These modules rarely occur in small scripts."
msgstr ""
"Este segundo passeio apresenta alguns módulos avançados que atendem "
"necessidades de programação profissional. Estes módulos raramente aparecem "
"em scripts pequenos."
#: ../../tutorial/stdlib2.rst:14
msgid "Output Formatting"
msgstr "Formatando a saída"
#: ../../tutorial/stdlib2.rst:16
msgid ""
"The :mod:`reprlib` module provides a version of :func:`repr` customized for "
"abbreviated displays of large or deeply nested containers::"
msgstr ""
"O módulo :mod:`reprlib` fornece uma versão de :func:`repr` personalizado "
"para exibições abreviadas de contêineres grandes ou profundamente aninhados::"
#: ../../tutorial/stdlib2.rst:19
msgid ""
">>> import reprlib\n"
">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"
"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""
msgstr ""
">>> import reprlib\n"
">>> reprlib.repr(set('supercalifragilisticexpialidoce'))\n"
"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""
#: ../../tutorial/stdlib2.rst:23
msgid ""
"The :mod:`pprint` module offers more sophisticated control over printing "
"both built-in and user defined objects in a way that is readable by the "
"interpreter. When the result is longer than one line, the \"pretty printer\" "
"adds line breaks and indentation to more clearly reveal data structure::"
msgstr ""
"O módulo :mod:`pprint` oferece um controle mais sofisticado na exibição "
"tanto de objetos embutidos quanto aqueles criados pelo usuário de maneira "
"que fique legível para o interpretador. Quando o resultado é maior que uma "
"linha, o \"pretty printer\" acrescenta quebras de linha e indentação para "
"revelar as estruturas de maneira mais clara::"
#: ../../tutorial/stdlib2.rst:28
msgid ""
">>> import pprint\n"
">>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',\n"
"... 'yellow'], 'blue']]]\n"
"...\n"
">>> pprint.pprint(t, width=30)\n"
"[[[['black', 'cyan'],\n"
" 'white',\n"
" ['green', 'red']],\n"
" [['magenta', 'yellow'],\n"
" 'blue']]]"
msgstr ""
">>> import pprint\n"
">>> t = [[[['preto', 'ciano'], 'branco', ['verde', 'vermelho']], "
"[['magenta',\n"
"... 'amarelo'], 'azul']]]\n"
">>>\n"
">>> pprint.pprint(t, width=30)\n"
"[[[['preto', 'ciano'],\n"
" 'branco',\n"
" ['verde', 'vermelho']],\n"
" [['magenta', 'amarelo'],\n"
" 'azul']]]"
#: ../../tutorial/stdlib2.rst:39
msgid ""
"The :mod:`textwrap` module formats paragraphs of text to fit a given screen "
"width::"
msgstr ""
"O módulo :mod:`textwrap` formata parágrafos de texto para que caibam em uma "
"dada largura de tela::"
#: ../../tutorial/stdlib2.rst:42
msgid ""
">>> import textwrap\n"
">>> doc = \"\"\"The wrap() method is just like fill() except that it "
"returns\n"
"... a list of strings instead of one big string with newlines to separate\n"
"... the wrapped lines.\"\"\"\n"
"...\n"
">>> print(textwrap.fill(doc, width=40))\n"
"The wrap() method is just like fill()\n"
"except that it returns a list of strings\n"
"instead of one big string with newlines\n"
"to separate the wrapped lines."
msgstr ""
">>> import textwrap\n"
">>> doc = \"\"\"O método wrap() é como fill(), exceto que ele retorna\n"
"... uma lista de strings em vez de uma string grande com quebras\n"
"... de linha para separar as linhas quebradas.\"\"\"\n"
"...\n"
">>> print(textwrap.fill(doc, width=40))\n"
"O método wrap() é como fill(), exceto\n"
"que ele retorna uma lista de strings em\n"
"vez de uma string grande com quebras de\n"
"linha para separar as linhas quebradas."
#: ../../tutorial/stdlib2.rst:53
msgid ""
"The :mod:`locale` module accesses a database of culture specific data "
"formats. The grouping attribute of locale's format function provides a "
"direct way of formatting numbers with group separators::"
msgstr ""
"O módulo :mod:`locale` acessa uma base de dados de formatos específicos a "
"determinada cultura. O atributo de agrupamento da função \"format\" oferece "
"uma forma direta de formatar números com separadores de grupo::"
#: ../../tutorial/stdlib2.rst:57
msgid ""
">>> import locale\n"
">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"
"'English_United States.1252'\n"
">>> conv = locale.localeconv() # get a mapping of conventions\n"
">>> x = 1234567.8\n"
">>> locale.format_string(\"%d\", x, grouping=True)\n"
"'1,234,567'\n"
">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"
"... conv['frac_digits'], x), grouping=True)\n"
"'$1,234,567.80'"
msgstr ""
">>> import locale\n"
">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"
"'English_United States.1252'\n"
">>> conv = locale.localeconv() # obtém mapeamento de convenções\n"
">>> x = 1234567.8\n"
">>> locale.format_string(\"%d\", x, grouping=True)\n"
"'1,234,567'\n"
">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"
"... conv['frac_digits'], x), grouping=True)\n"
"'$1,234,567.80'"
#: ../../tutorial/stdlib2.rst:72
msgid "Templating"
msgstr "Usando templates"
#: ../../tutorial/stdlib2.rst:74
msgid ""
"The :mod:`string` module includes a versatile :class:`~string.Template` "
"class with a simplified syntax suitable for editing by end-users. This "
"allows users to customize their applications without having to alter the "
"application."
msgstr ""
"módulo :mod:`string` inclui a versátil classe :class:`Template` com uma "
"sintaxe simplificada, adequada para ser editada por usuários finais. Isso "
"permite que usuários personalizem suas aplicações sem a necessidade de "
"alterar a aplicação."
#: ../../tutorial/stdlib2.rst:78
msgid ""
"The format uses placeholder names formed by ``$`` with valid Python "
"identifiers (alphanumeric characters and underscores). Surrounding the "
"placeholder with braces allows it to be followed by more alphanumeric "
"letters with no intervening spaces. Writing ``$$`` creates a single escaped "
"``$``::"
msgstr ""
"Em um template são colocadas marcações indicando o local onde o texto "
"variável deve ser inserido. Uma marcação é formada por ``$`` seguido de um "
"identificador Python válido (caracteres alfanuméricos e underscores). "
"Envolvendo-se o identificador da marcação entre chaves, permite que ele seja "
"seguido por mais caracteres alfanuméricos sem a necessidade de espaços. "
"Escrevendo-se ``$$`` cria-se um único ``$``::"
#: ../../tutorial/stdlib2.rst:83
msgid ""
">>> from string import Template\n"
">>> t = Template('${village}folk send $$10 to $cause.')\n"
">>> t.substitute(village='Nottingham', cause='the ditch fund')\n"
"'Nottinghamfolk send $10 to the ditch fund.'"
msgstr ""
">>> from string import Template\n"
">>> t = Template('O povo de ${vila} envia $$10 para $causa.')\n"
">>> t.substitute(vila='Nottingham', causa='o fundo de recuperação')\n"
"'O povo de Nottingham envia $10 para o fundo de recuperação.'"
#: ../../tutorial/stdlib2.rst:88
msgid ""
"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` when "
"a placeholder is not supplied in a dictionary or a keyword argument. For "
"mail-merge style applications, user supplied data may be incomplete and the :"
"meth:`~string.Template.safe_substitute` method may be more appropriate --- "
"it will leave placeholders unchanged if data is missing::"
msgstr ""
"O método :meth:`substitute` levanta uma exceção :exc:`KeyError` quando o "
"identificador de uma marcação não é fornecido em um dicionário ou em um "
"argumento nomeado (*keyword argument*). Para aplicações que podem receber "
"dados incompletos fornecidos pelo usuário, o método :meth:`safe_substitute` "
"pode ser mais apropriado --- deixará os marcadores intactos se os dados "
"estiverem faltando::"
#: ../../tutorial/stdlib2.rst:94
msgid ""
">>> t = Template('Return the $item to $owner.')\n"
">>> d = dict(item='unladen swallow')\n"
">>> t.substitute(d)\n"
"Traceback (most recent call last):\n"
" ...\n"
"KeyError: 'owner'\n"
">>> t.safe_substitute(d)\n"
"'Return the unladen swallow to $owner.'"
msgstr ""
">>> t = Template('Devolva $item para $dono.')\n"
">>> d = dict(item='a andorinha descarregada')\n"
">>> t.substitute(d)\n"
"Traceback (most recent call last):\n"
" ...\n"
"KeyError: 'dono'\n"
">>> t.safe_substitute(d)\n"
"'Devolva a andorinha descarregada para $dono.'"
#: ../../tutorial/stdlib2.rst:103
msgid ""
"Template subclasses can specify a custom delimiter. For example, a batch "
"renaming utility for a photo browser may elect to use percent signs for "
"placeholders such as the current date, image sequence number, or file "
"format::"
msgstr ""
"Subclasses de Template podem especificar um delimitador personalizado. Por "
"exemplo, um utilitário para renomeação em lote de fotos pode usar o sinal de "
"porcentagem para marcações como a data atual, número sequencial da imagem ou "
"formato do aquivo::"
#: ../../tutorial/stdlib2.rst:107
msgid ""
">>> import time, os.path\n"
">>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"
">>> class BatchRename(Template):\n"
"... delimiter = '%'\n"
"...\n"
">>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format): ')\n"
"Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f\n"
"\n"
">>> t = BatchRename(fmt)\n"
">>> date = time.strftime('%d%b%y')\n"
">>> for i, filename in enumerate(photofiles):\n"
"... base, ext = os.path.splitext(filename)\n"
"... newname = t.substitute(d=date, n=i, f=ext)\n"
"... print('{0} --> {1}'.format(filename, newname))\n"
"\n"
"img_1074.jpg --> Ashley_0.jpg\n"
"img_1076.jpg --> Ashley_1.jpg\n"
"img_1077.jpg --> Ashley_2.jpg"
msgstr ""
">>> import time, os.path\n"
">>> arquivos_fotos = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"
">>> class RenomeiaEmLote(Template):\n"
"... delimiter = '%'\n"
"...\n"
">>> formato = input('Informe o estilo de renomeação (%d-data %n-sequencia %f-"
"formato): ')\n"
"Informe o estilo de renomeação (%d-data %n-sequencia %f-formato): "
"Ashley_%n%f\n"
"\n"
">>> t = RenomeiaEmLote(formato)\n"
">>> data = time.strftime('%d%b%y')\n"
">>> for i, nome_arquivo in enumerate(arquivos_fotos):\n"
"... base, extensão = os.path.splitext(nome_arquivo)\n"
"... novo_nome = t.substitute(d=data, n=i, f=extensão)\n"
"... print('{0} --> {1}'.format(nome_arquivo, novo_nome))\n"
"\n"
"img_1074.jpg --> Ashley_0.jpg\n"
"img_1076.jpg --> Ashley_1.jpg\n"
"img_1077.jpg --> Ashley_2.jpg"
#: ../../tutorial/stdlib2.rst:126
msgid ""
"Another application for templating is separating program logic from the "
"details of multiple output formats. This makes it possible to substitute "
"custom templates for XML files, plain text reports, and HTML web reports."
msgstr ""
"Outra aplicação para templates é separar a lógica da aplicação dos detalhes "
"de múltiplos formatos de saída. Assim é possível usar templates "
"personalizados para gerar arquivos XML, relatórios em texto puro e "
"relatórios web em HTML."
#: ../../tutorial/stdlib2.rst:134
msgid "Working with Binary Data Record Layouts"
msgstr "Trabalhando com formatos binários de dados"
#: ../../tutorial/stdlib2.rst:136
msgid ""
"The :mod:`struct` module provides :func:`~struct.pack` and :func:`~struct."
"unpack` functions for working with variable length binary record formats. "
"The following example shows how to loop through header information in a ZIP "
"file without using the :mod:`zipfile` module. Pack codes ``\"H\"`` and "
"``\"I\"`` represent two and four byte unsigned numbers respectively. The "
"``\"<\"`` indicates that they are standard size and in little-endian byte "
"order::"
msgstr ""
"O módulo :mod:`struct` oferece as funções :func:`pack` e :func:`unpack` para "
"trabalhar com registros binários de tamanho variável. O exemplo a seguir "
"mostra como iterar através do cabeçalho de informação num aquivo ZIP sem "
"usar o módulo :mod:`zipfile`. Os códigos de empacotamento ``\"H\"`` e "
"``\"I\"`` representam números sem sinal de dois e quatro bytes "
"respectivamente. O ``\"<\"`` indica que os números têm tamanho padrão e são "
"little-endian (bytes menos significativos primeiro)::"
#: ../../tutorial/stdlib2.rst:144
msgid ""
"import struct\n"
"\n"
"with open('myfile.zip', 'rb') as f:\n"
" data = f.read()\n"
"\n"
"start = 0\n"
"for i in range(3): # show the first 3 file headers\n"
" start += 14\n"
" fields = struct.unpack('` para "
"eliminar ciclos). A memória ocupada por um objeto é liberada logo depois da "
"última referência a ele ser eliminada."
#: ../../tutorial/stdlib2.rst:255
msgid ""
"This approach works fine for most applications but occasionally there is a "
"need to track objects only as long as they are being used by something else. "
"Unfortunately, just tracking them creates a reference that makes them "
"permanent. The :mod:`weakref` module provides tools for tracking objects "
"without creating a reference. When the object is no longer needed, it is "
"automatically removed from a weakref table and a callback is triggered for "
"weakref objects. Typical applications include caching objects that are "
"expensive to create::"
msgstr ""
"Essa abordagem funciona bem para a maioria das aplicações, mas "
"ocasionalmente surge a necessidade de rastrear objetos apenas enquanto estão "
"sendo usados por algum outro. Infelizmente rastreá-los cria uma referência, "
"e isso os fazem permanentes. O módulo :mod:`weakref` oferece ferramentas "
"para rastrear objetos sem criar uma referência. Quando o objeto não é mais "
"necessário, ele é automaticamente removido de uma tabela de referências "
"fracas e uma chamada (*callback*) é disparada. Aplicações típicas incluem "
"armazenamento em cache de objetos que são muito custosos para criar::"
#: ../../tutorial/stdlib2.rst:263
msgid ""
">>> import weakref, gc\n"
">>> class A:\n"
"... def __init__(self, value):\n"
"... self.value = value\n"
"... def __repr__(self):\n"
"... return str(self.value)\n"
"...\n"
">>> a = A(10) # create a reference\n"
">>> d = weakref.WeakValueDictionary()\n"
">>> d['primary'] = a # does not create a reference\n"
">>> d['primary'] # fetch the object if it is still alive\n"
"10\n"
">>> del a # remove the one reference\n"
">>> gc.collect() # run garbage collection right away\n"
"0\n"
">>> d['primary'] # entry was automatically removed\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \n"
" d['primary'] # entry was automatically removed\n"
" File \"C:/python314/lib/weakref.py\", line 46, in __getitem__\n"
" o = self.data[key]()\n"
"KeyError: 'primary'"
msgstr ""
">>> import weakref, gc\n"
">>> class A:\n"
"... def __init__(self, valor):\n"
"... self.valor = valor\n"
"... def __repr__(self):\n"
"... return str(self.valor)\n"
"...\n"
">>> a = A(10) # cria uma referência\n"
">>> d = weakref.WeakValueDictionary()\n"
">>> d['primaria'] = a # não cria uma referência\n"
">>> d['primaria'] # busca o objeto se ele estiver ativo\n"
"10\n"
">>> del a # remove a referência criada\n"
">>> gc.collect() # roda imediatamente a coleta de lixo\n"
"0\n"
">>> d['primaria'] # o acesso foi automaticamente removido\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \n"
" d['primaria'] # o acesso foi automaticamente removido\n"
" File \"C:/python314/lib/weakref.py\", line 46, in __getitem__\n"
" o = self.data[key]()\n"
"KeyError: 'primaria'"
#: ../../tutorial/stdlib2.rst:290
msgid "Tools for Working with Lists"
msgstr "Ferramentas para trabalhar com listas"
#: ../../tutorial/stdlib2.rst:292
msgid ""
"Many data structure needs can be met with the built-in list type. However, "
"sometimes there is a need for alternative implementations with different "
"performance trade-offs."
msgstr ""
"Muitas necessidades envolvendo estruturas de dados podem ser satisfeitas com "
"o tipo embutido lista. Entretanto, algumas vezes há uma necessidade por "
"implementações alternativas que sacrificam algumas facilidades em nome de "
"melhor desempenho."
#: ../../tutorial/stdlib2.rst:296
msgid ""
"The :mod:`array` module provides an :class:`~array.array` object that is "
"like a list that stores only homogeneous data and stores it more compactly. "
"The following example shows an array of numbers stored as two byte unsigned "
"binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes per entry "
"for regular lists of Python int objects::"
msgstr ""
"O módulo :mod:`array` oferece uma classe :class:`~array.array`, semelhante a "
"uma lista, mas que armazena apenas dados homogêneos e de maneira mais "
"compacta. O exemplo a seguir mostra um vetor de números armazenados como "
"números binários de dois bytes sem sinal (código de tipo ``\"H\"``) ao invés "
"dos 16 bytes usuais para cada item em uma lista de ``int``::"
#: ../../tutorial/stdlib2.rst:302
msgid ""
">>> from array import array\n"
">>> a = array('H', [4000, 10, 700, 22222])\n"
">>> sum(a)\n"
"26932\n"
">>> a[1:3]\n"
"array('H', [10, 700])"
msgstr ""
">>> from array import array\n"
">>> a = array('H', [4000, 10, 700, 22222])\n"
">>> sum(a)\n"
"26932\n"
">>> a[1:3]\n"
"array('H', [10, 700])"
#: ../../tutorial/stdlib2.rst:309
msgid ""
"The :mod:`collections` module provides a :class:`~collections.deque` object "
"that is like a list with faster appends and pops from the left side but "
"slower lookups in the middle. These objects are well suited for implementing "
"queues and breadth first tree searches::"
msgstr ""
"O módulo :mod:`collections` oferece um objeto :class:`~collections.deque` "
"que comporta-se como uma lista mas com *appends* e *pops* pela esquerda mais "
"rápidos, porém mais lento ao percorrer o meio da sequência. Esses objetos "
"são adequados para implementar filas e buscas em amplitude em árvores de "
"dados::"
#: ../../tutorial/stdlib2.rst:314
msgid ""
">>> from collections import deque\n"
">>> d = deque([\"task1\", \"task2\", \"task3\"])\n"
">>> d.append(\"task4\")\n"
">>> print(\"Handling\", d.popleft())\n"
"Handling task1"
msgstr ""
">>> from collections import deque\n"
">>> d = deque([\"tarefa1\", \"tarefa2\", \"tarefa3\"])\n"
">>> d.append(\"tarefa4\")\n"
">>> print(\"Tratando\", d.popleft())\n"
"Tratando tarefa1"
#: ../../tutorial/stdlib2.rst:322
msgid ""
"unsearched = deque([starting_node])\n"
"def breadth_first_search(unsearched):\n"
" node = unsearched.popleft()\n"
" for m in gen_moves(node):\n"
" if is_goal(m):\n"
" return m\n"
" unsearched.append(m)"
msgstr ""
"nao_pesquisada = deque([no_inicial])\n"
"def busca_em_profundidade(nao_pesquisada):\n"
" no = nao_pesquisada.popleft()\n"
" for m in gen_moves(no):\n"
" if eh_o_alvo(m):\n"
" return m\n"
" nao_pesquisada.append(m)"
#: ../../tutorial/stdlib2.rst:330
msgid ""
"In addition to alternative list implementations, the library also offers "
"other tools such as the :mod:`bisect` module with functions for manipulating "
"sorted lists::"
msgstr ""
"Além de implementações alternativas de listas, a biblioteca também oferece "
"outras ferramentas como o módulo :mod:`bisect` com funções para manipulação "
"de listas ordenadas::"
#: ../../tutorial/stdlib2.rst:334
msgid ""
">>> import bisect\n"
">>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]\n"
">>> bisect.insort(scores, (300, 'ruby'))\n"
">>> scores\n"
"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]"
msgstr ""
">>> import bisect\n"
">>> notas = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]\n"
">>> bisect.insort(notas, (300, 'ruby'))\n"
">>> notas\n"
"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]"
#: ../../tutorial/stdlib2.rst:340
msgid ""
"The :mod:`heapq` module provides functions for implementing heaps based on "
"regular lists. The lowest valued entry is always kept at position zero. "
"This is useful for applications which repeatedly access the smallest element "
"but do not want to run a full list sort::"
msgstr ""
"O módulo :mod:`heapq` oferece funções para implementação de *heaps* baseadas "
"em listas normais. O valor mais baixo é sempre mantido na posição zero. Isso "
"é útil para aplicações que acessam repetidamente o menor elemento, mas não "
"querem reordenar a lista toda a cada acesso::"
#: ../../tutorial/stdlib2.rst:345
msgid ""
">>> from heapq import heapify, heappop, heappush\n"
">>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"
">>> heapify(data) # rearrange the list into heap order\n"
">>> heappush(data, -5) # add a new entry\n"
">>> [heappop(data) for i in range(3)] # fetch the three smallest entries\n"
"[-5, 0, 1]"
msgstr ""
">>> from heapq import heapify, heappop, heappush\n"
">>> dados = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"
">>> heapify(dados) # reorganiza a lista como um heap\n"
">>> heappush(dados, -5) # adiciona o valor -5 ao heap\n"
">>> [heappop(dados) for i in range(3)] # encontra as 3 menores entradas\n"
"[-5, 0, 1]"
#: ../../tutorial/stdlib2.rst:356
msgid "Decimal Floating-Point Arithmetic"
msgstr "Aritmética decimal com ponto flutuante"
#: ../../tutorial/stdlib2.rst:358
msgid ""
"The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for "
"decimal floating-point arithmetic. Compared to the built-in :class:`float` "
"implementation of binary floating point, the class is especially helpful for"
msgstr ""
"O módulo :mod:`decimal` oferece o tipo :class:`~decimal.Decimal` para "
"aritmética decimal com ponto flutuante. Comparado a implementação embutida :"
"class:`float` que usa aritmética binária de ponto flutuante, a classe é "
"especialmente útil para:"
#: ../../tutorial/stdlib2.rst:362
msgid ""
"financial applications and other uses which require exact decimal "
"representation,"
msgstr "aplicações financeiras que requerem representação decimal exata,"
#: ../../tutorial/stdlib2.rst:364
msgid "control over precision,"
msgstr "controle sobre a precisão,"
#: ../../tutorial/stdlib2.rst:365
msgid "control over rounding to meet legal or regulatory requirements,"
msgstr "controle sobre arredondamento para satisfazer requisitos legais,"
#: ../../tutorial/stdlib2.rst:366
msgid "tracking of significant decimal places, or"
msgstr "rastreamento de casas decimais significativas, ou"
#: ../../tutorial/stdlib2.rst:367
msgid ""
"applications where the user expects the results to match calculations done "
"by hand."
msgstr ""
"aplicações onde o usuário espera que os resultados sejam os mesmos que os "
"dos cálculos feitos à mão."
#: ../../tutorial/stdlib2.rst:370
msgid ""
"For example, calculating a 5% tax on a 70 cent phone charge gives different "
"results in decimal floating point and binary floating point. The difference "
"becomes significant if the results are rounded to the nearest cent::"
msgstr ""
"Por exemplo, calcular um imposto de 5% sobre uma chamada telefônica de 70 "
"centavos devolve diferentes resultados com aritmética de ponto flutuante "
"decimal ou binária. A diferença torna-se significativa se os resultados são "
"arredondados para o centavo mais próximo::"
#: ../../tutorial/stdlib2.rst:374
msgid ""
">>> from decimal import *\n"
">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"
"Decimal('0.74')\n"
">>> round(.70 * 1.05, 2)\n"
"0.73"
msgstr ""
">>> from decimal import *\n"
">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"
"Decimal('0.74')\n"
">>> round(.70 * 1.05, 2)\n"
"0.73"
#: ../../tutorial/stdlib2.rst:380
msgid ""
"The :class:`~decimal.Decimal` result keeps a trailing zero, automatically "
"inferring four place significance from multiplicands with two place "
"significance. Decimal reproduces mathematics as done by hand and avoids "
"issues that can arise when binary floating point cannot exactly represent "
"decimal quantities."
msgstr ""
"O resultado de :class:`~decimal.Decimal` considera zeros à direita, "
"automaticamente inferindo quatro casas decimais a partir de multiplicandos "
"com duas casas decimais. O módulo Decimal reproduz a aritmética como fazemos "
"à mão e evita problemas que podem ocorrer quando a representação binária do "
"ponto flutuante não consegue representar quantidades decimais com exatidão."
#: ../../tutorial/stdlib2.rst:386
msgid ""
"Exact representation enables the :class:`~decimal.Decimal` class to perform "
"modulo calculations and equality tests that are unsuitable for binary "
"floating point::"
msgstr ""
"A representação exata permite à classe :class:`~decimal.Decimal` executar "
"cálculos de módulo e testes de igualdade que não funcionam bem em ponto "
"flutuante binário::"
#: ../../tutorial/stdlib2.rst:390
msgid ""
">>> Decimal('1.00') % Decimal('.10')\n"
"Decimal('0.00')\n"
">>> 1.00 % 0.10\n"
"0.09999999999999995\n"
"\n"
">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"
"True\n"
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False"
msgstr ""
">>> Decimal('1.00') % Decimal('.10')\n"
"Decimal('0.00')\n"
">>> 1.00 % 0.10\n"
"0.09999999999999995\n"
"\n"
">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"
"True\n"
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False"
#: ../../tutorial/stdlib2.rst:400
msgid ""
"The :mod:`decimal` module provides arithmetic with as much precision as "
"needed::"
msgstr ""
"O módulo :mod:`decimal` implementa a aritmética com tanta precisão quanto "
"necessária::"
#: ../../tutorial/stdlib2.rst:402
msgid ""
">>> getcontext().prec = 36\n"
">>> Decimal(1) / Decimal(7)\n"
"Decimal('0.142857142857142857142857142857142857')"
msgstr ""
">>> getcontext().prec = 36\n"
">>> Decimal(1) / Decimal(7)\n"
"Decimal('0.142857142857142857142857142857142857')"