# Copyright (C) 2001-2020, Python Software Foundation

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

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to

# get the list of volunteers

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2024-11-21 16:38-0300\n"

"PO-Revision-Date: 2023-11-23 16:41+0100\n"

"Last-Translator: Francisco Mora <fr.morac@duocuc.cl>\n"

"Language: es_ES\n"

"Language-Team: python-doc-es\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"MIME-Version: 1.0\n"

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

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

"Generated-By: Babel 2.16.0\n"

#: ../Doc/library/decimal.rst:2

#, fuzzy

msgid ":mod:`!decimal` --- Decimal fixed-point and floating-point arithmetic"

msgstr ":mod:`decimal` --- Aritmética decimal de coma fija y coma flotante"

#: ../Doc/library/decimal.rst:15

msgid "**Source code:** :source:`Lib/decimal.py`"

msgstr "**Código fuente:** :source:`Lib/decimal.py`"

#: ../Doc/library/decimal.rst:33

#, fuzzy

msgid ""

"The :mod:`decimal` module provides support for fast correctly rounded "

"decimal floating-point arithmetic. It offers several advantages over the :"

"class:`float` datatype:"

msgstr ""

"El módulo :mod:`decimal` proporciona soporte para aritmética de coma "

"flotante decimal rápida y redondeada correctamente. Ofrece varias ventajas "

"en comparación con el tipo de dato :class:`float`:"

#: ../Doc/library/decimal.rst:37

msgid ""

"Decimal \"is based on a floating-point model which was designed with people "

"in mind, and necessarily has a paramount guiding principle -- computers must "

"provide an arithmetic that works in the same way as the arithmetic that "

"people learn at school.\" -- excerpt from the decimal arithmetic "

"specification."

msgstr ""

"Decimal \"se basa en un modelo de coma flotante que se diseñó pensando en "

"las personas, y necesariamente tiene un principio rector supremo: las "

"computadoras deben proporcionar una aritmética que funcione de la misma "

"manera que la aritmética que las personas aprenden en la escuela.\" -- "

"extracto (traducido) de la especificación de la aritmética decimal."

#: ../Doc/library/decimal.rst:42

msgid ""

"Decimal numbers can be represented exactly. In contrast, numbers like "

"``1.1`` and ``2.2`` do not have exact representations in binary floating "

"point. End users typically would not expect ``1.1 + 2.2`` to display as "

"``3.3000000000000003`` as it does with binary floating point."

msgstr ""

"Los números decimales se pueden representar de forma exacta en coma flotante "

"decimal. En cambio, números como ``1.1`` y ``2.2`` no tienen "

"representaciones exactas en coma flotante binaria. Los usuarios finales "

"normalmente no esperaran que ``1.1 + 2.2`` se muestre como "

"``3.3000000000000003``, como ocurre al usar la representación binaria en "

"coma flotante."

#: ../Doc/library/decimal.rst:47

msgid ""

"The exactness carries over into arithmetic. In decimal floating point, "

"``0.1 + 0.1 + 0.1 - 0.3`` is exactly equal to zero. In binary floating "

"point, the result is ``5.5511151231257827e-017``. While near to zero, the "

"differences prevent reliable equality testing and differences can "

"accumulate. For this reason, decimal is preferred in accounting applications "

"which have strict equality invariants."

msgstr ""

"La exactitud se traslada a la aritmética. En coma flotante decimal, ``0.1 + "

"0.1 + 0.1 - 0.3`` es exactamente igual a cero. En coma flotante binaria, el "

"resultado es ``5.5511151231257827e-017``. Aunque cercanas a cero, las "

"diferencias impiden pruebas de igualdad confiables y las diferencias pueden "

"acumularse. Por estas razones, se recomienda el uso de decimal en "

"aplicaciones de contabilidad con estrictas restricciones de confiabilidad."

#: ../Doc/library/decimal.rst:54

msgid ""

"The decimal module incorporates a notion of significant places so that "

"``1.30 + 1.20`` is ``2.50``. The trailing zero is kept to indicate "

"significance. This is the customary presentation for monetary applications. "

"For multiplication, the \"schoolbook\" approach uses all the figures in the "

"multiplicands. For instance, ``1.3 * 1.2`` gives ``1.56`` while ``1.30 * "

"1.20`` gives ``1.5600``."

msgstr ""

"El módulo decimal incorpora una noción de dígitos significativos, de modo "

"que ``1.30 + 1.20`` es ``2.50``. El cero final se mantiene para indicar el "

"número de dígitos significativos. Esta es la representación habitual en "

"aplicaciones monetarias. Para la multiplicación, el método de \"libro "

"escolar\" utilizado usa todas las cifras de los multiplicandos. Por ejemplo, "

"``1.3 * 1.2`` es igual a ``1.56``, mientras que ``1.30 * 1.20`` es igual a "

"``1.5600``."

#: ../Doc/library/decimal.rst:61

msgid ""

"Unlike hardware based binary floating point, the decimal module has a user "

"alterable precision (defaulting to 28 places) which can be as large as "

"needed for a given problem:"

msgstr ""

"A diferencia del punto flotante binario basado en hardware, el módulo "

"decimal tiene una precisión modificable por el usuario (por defecto es de 28 "

"dígitos decimales) que puede ser tan grande como sea necesario para un "

"problema dado:"

#: ../Doc/library/decimal.rst:73

msgid ""

"Both binary and decimal floating point are implemented in terms of published "

"standards. While the built-in float type exposes only a modest portion of "

"its capabilities, the decimal module exposes all required parts of the "

"standard. When needed, the programmer has full control over rounding and "

"signal handling. This includes an option to enforce exact arithmetic by "

"using exceptions to block any inexact operations."

msgstr ""

"Tanto la representación en coma flotante binaria como la decimal se "

"implementan de acuerdo a estándares publicados. Mientras que el tipo "

"incorporado float expone solo una pequeña parte de sus capacidades, el "

"módulo decimal expone todos los componentes requeridos del estándar. Cuando "

"es necesario, el desarrollador tiene control total sobre el redondeo y la "

"gestión de las señales. Esto incluye la capacidad de forzar la aritmética "

"exacta, utilizando excepciones para bloquear cualquier operación inexacta."

#: ../Doc/library/decimal.rst:80

msgid ""

"The decimal module was designed to support \"without prejudice, both exact "

"unrounded decimal arithmetic (sometimes called fixed-point arithmetic) and "

"rounded floating-point arithmetic.\" -- excerpt from the decimal arithmetic "

"specification."

msgstr ""

"El módulo decimal fue diseñado para admitir \"indiscriminadamente, tanto "

"aritmética decimal exacta sin redondeo (a veces llamada aritmética de coma "

"fija) como la aritmética de coma flotante con redondeo.\" -- extracto "

"(traducido) de la especificación de la aritmética decimal."

#: ../Doc/library/decimal.rst:85

msgid ""

"The module design is centered around three concepts: the decimal number, "

"the context for arithmetic, and signals."

msgstr ""

"El módulo está diseñado en torno a tres conceptos: el número decimal, el "

"contexto aritmético y las señales."

#: ../Doc/library/decimal.rst:88

msgid ""

"A decimal number is immutable. It has a sign, coefficient digits, and an "

"exponent. To preserve significance, the coefficient digits do not truncate "

"trailing zeros. Decimals also include special values such as ``Infinity``, "

"``-Infinity``, and ``NaN``. The standard also differentiates ``-0`` from "

"``+0``."

msgstr ""

"Un número decimal es inmutable. Tiene un signo, un coeficiente y un "

"exponente. Para conservar el número de dígitos significativos, los ceros "

"iniciales no se truncan. Los números decimales también incluyen valores "

"especiales como ``Infinity``, ``-Infinity`` y ``NaN``. El estándar también "

"marca la diferencia entre ``-0`` y ``+0``."

#: ../Doc/library/decimal.rst:94

msgid ""

"The context for arithmetic is an environment specifying precision, rounding "

"rules, limits on exponents, flags indicating the results of operations, and "

"trap enablers which determine whether signals are treated as exceptions. "

"Rounding options include :const:`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:"

"`ROUND_FLOOR`, :const:`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:"

"`ROUND_HALF_UP`, :const:`ROUND_UP`, and :const:`ROUND_05UP`."

msgstr ""

"El contexto aritmético es un entorno que permite especificar una precisión, "

"reglas de redondeo, límites en los exponentes, flags que indican el "

"resultado de las operaciones y habilitadores de trampas que especifican si "

"las señales (reportadas durante operaciones ilegales) son tratadas o no como "

"excepciones de Python. Las opciones de redondeo incluyen :const:"

"`ROUND_CEILING`, :const:`ROUND_DOWN`, :const:`ROUND_FLOOR`, :const:"

"`ROUND_HALF_DOWN`, :const:`ROUND_HALF_EVEN`, :const:`ROUND_HALF_UP`, :const:"

"`ROUND_UP` y :const:`ROUND_05UP`."

#: ../Doc/library/decimal.rst:101

msgid ""

"Signals are groups of exceptional conditions arising during the course of "

"computation. Depending on the needs of the application, signals may be "

"ignored, considered as informational, or treated as exceptions. The signals "

"in the decimal module are: :const:`Clamped`, :const:`InvalidOperation`, :"

"const:`DivisionByZero`, :const:`Inexact`, :const:`Rounded`, :const:"

"`Subnormal`, :const:`Overflow`, :const:`Underflow` and :const:"

"`FloatOperation`."

msgstr ""

"Las señales son grupos de condiciones excepcionales que ocurren durante el "

"cálculo. Dependiendo de las necesidades de la aplicación, las señales pueden "

"ignorarse, tratarse como información o tratarse como excepciones. Las "

"señales existentes en el módulo decimal son :const:`Clamped`, :const:"

"`InvalidOperation`, :const:`DivisionByZero`, :const:`Inexact`, :const:"

"`Rounded`, :const:`Subnormal`, :const:`Overflow`, :const:`Underflow` y :"

"const:`FloatOperation`."

#: ../Doc/library/decimal.rst:108

msgid ""

"For each signal there is a flag and a trap enabler. When a signal is "

"encountered, its flag is set to one, then, if the trap enabler is set to "

"one, an exception is raised. Flags are sticky, so the user needs to reset "

"them before monitoring a calculation."

msgstr ""

"Por cada señal hay un flag y un habilitador de trampa. Cuando ocurre una "

"operación ilegal, su flag se establece en uno, luego, si su habilitador de "

"trampa está establecido en uno, se lanza una excepción. La configuración de "

"los flags es persistente, por lo que el usuario debe restablecerlos antes de "

"comenzar un cálculo que desee monitorear."

#: ../Doc/library/decimal.rst:116

msgid ""

"IBM's General Decimal Arithmetic Specification, `The General Decimal "

"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."

msgstr ""

"Especificación general de la aritmética decimal de IBM, `The General Decimal "

"Arithmetic Specification <https://speleotrove.com/decimal/decarith.html>`_."

#: ../Doc/library/decimal.rst:125

msgid "Quick-start Tutorial"

msgstr "Tutorial de inicio rápido"

#: ../Doc/library/decimal.rst:127

msgid ""

"The usual start to using decimals is importing the module, viewing the "

"current context with :func:`getcontext` and, if necessary, setting new "

"values for precision, rounding, or enabled traps::"

msgstr ""

"El punto de partida habitual para usar decimales es importar el módulo, ver "

"el contexto actual con :func:`getcontext` y, si es necesario, establecer "

"nuevos valores para la precisión, el redondeo o trampas de señales "

"habilitadas::"

#: ../Doc/library/decimal.rst:131

msgid ""

">>> from decimal import *\n"

">>> getcontext()\n"

"Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"

" capitals=1, clamp=0, flags=[], traps=[Overflow, DivisionByZero,\n"

" InvalidOperation])\n"

"\n"

">>> getcontext().prec = 7 # Set a new precision"

msgstr ""

#: ../Doc/library/decimal.rst:139

msgid ""

"Decimal instances can be constructed from integers, strings, floats, or "

"tuples. Construction from an integer or a float performs an exact conversion "

"of the value of that integer or float. Decimal numbers include special "

"values such as ``NaN`` which stands for \"Not a number\", positive and "

"negative ``Infinity``, and ``-0``::"

msgstr ""

"Las instancias de la clase Decimal se pueden construir a partir de números "

"enteros, cadenas de caracteres, flotantes o tuplas. La construcción a partir "

"de un número entero o flotante realiza una conversión exacta del valor de "

"ese número. Los números decimales incluyen valores especiales como ``NaN``, "

"que significa \"No es un número\", ``Infinity`` positivo y negativo o "

"``-0``::"

#: ../Doc/library/decimal.rst:145

msgid ""

">>> getcontext().prec = 28\n"

">>> Decimal(10)\n"

"Decimal('10')\n"

">>> Decimal('3.14')\n"

"Decimal('3.14')\n"

">>> Decimal(3.14)\n"

"Decimal('3.140000000000000124344978758017532527446746826171875')\n"

">>> Decimal((0, (3, 1, 4), -2))\n"

"Decimal('3.14')\n"

">>> Decimal(str(2.0 ** 0.5))\n"

"Decimal('1.4142135623730951')\n"

">>> Decimal(2) ** Decimal('0.5')\n"

"Decimal('1.414213562373095048801688724')\n"

">>> Decimal('NaN')\n"

"Decimal('NaN')\n"

">>> Decimal('-Infinity')\n"

"Decimal('-Infinity')"

msgstr ""

#: ../Doc/library/decimal.rst:163

msgid ""

"If the :exc:`FloatOperation` signal is trapped, accidental mixing of "

"decimals and floats in constructors or ordering comparisons raises an "

"exception::"

msgstr ""

"Si la señal :exc:`FloatOperation` es atrapada, la mezcla accidental de "

"decimales y flotantes en constructores o comparaciones de orden lanzará una "

"excepción::"

#: ../Doc/library/decimal.rst:167

msgid ""

">>> c = getcontext()\n"

">>> c.traps[FloatOperation] = True\n"

">>> Decimal(3.14)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"decimal.FloatOperation: [<class 'decimal.FloatOperation'>]\n"

">>> Decimal('3.5') < 3.7\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"decimal.FloatOperation: [<class 'decimal.FloatOperation'>]\n"

">>> Decimal('3.5') == 3.5\n"

"True"

msgstr ""

#: ../Doc/library/decimal.rst:182

msgid ""

"The significance of a new Decimal is determined solely by the number of "

"digits input. Context precision and rounding only come into play during "

"arithmetic operations."

msgstr ""

"La significación de un nuevo objeto Decimal es determinada únicamente por el "

"número de dígitos ingresados. La precisión y el redondeo establecidos en el "

"contexto solo entran en juego durante las operaciones aritméticas."

#: ../Doc/library/decimal.rst:186

msgid ""

">>> getcontext().prec = 6\n"

">>> Decimal('3.0')\n"

"Decimal('3.0')\n"

">>> Decimal('3.1415926535')\n"

"Decimal('3.1415926535')\n"

">>> Decimal('3.1415926535') + Decimal('2.7182818285')\n"

"Decimal('5.85987')\n"

">>> getcontext().rounding = ROUND_UP\n"

">>> Decimal('3.1415926535') + Decimal('2.7182818285')\n"

"Decimal('5.85988')"

msgstr ""

#: ../Doc/library/decimal.rst:199

msgid ""

"If the internal limits of the C version are exceeded, constructing a decimal "

"raises :class:`InvalidOperation`::"

msgstr ""

"Se lanza una excepción :class:`InvalidOperation` si durante la construcción "

"de un objeto Decimal se exceden los límites internos de la versión de C::"

#: ../Doc/library/decimal.rst:202

msgid ""

">>> Decimal(\"1e9999999999999999999\")\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]"

msgstr ""

#: ../Doc/library/decimal.rst:209

#, fuzzy

msgid ""

"Decimals interact well with much of the rest of Python. Here is a small "

"decimal floating-point flying circus:"

msgstr ""

"Los objetos Decimal interactúan bien con gran parte del resto de Python. "

"Aquí hay un pequeño circo volador de punto flotante decimal:"

#: ../Doc/library/decimal.rst:212

msgid ""

">>> data = list(map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split()))\n"

">>> max(data)\n"

"Decimal('9.25')\n"

">>> min(data)\n"

"Decimal('0.03')\n"

">>> sorted(data)\n"

"[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),\n"

" Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]\n"

">>> sum(data)\n"

"Decimal('19.29')\n"

">>> a,b,c = data[:3]\n"

">>> str(a)\n"

"'1.34'\n"

">>> float(a)\n"

"1.34\n"

">>> round(a, 1)\n"

"Decimal('1.3')\n"

">>> int(a)\n"

"1\n"

">>> a * 5\n"

"Decimal('6.70')\n"

">>> a * b\n"

"Decimal('2.5058')\n"

">>> c % a\n"

"Decimal('0.77')"

msgstr ""

#: ../Doc/library/decimal.rst:241

msgid "And some mathematical functions are also available to Decimal:"

msgstr ""

"Y algunas funciones matemáticas también están disponibles para Decimal:"

#: ../Doc/library/decimal.rst:253

msgid ""

"The :meth:`~Decimal.quantize` method rounds a number to a fixed exponent. "

"This method is useful for monetary applications that often round results to "

"a fixed number of places:"

msgstr ""

"El método :meth:`~Decimal.quantize` redondea un número a un exponente fijo. "

"Este método es útil para aplicaciones monetarias, que a menudo redondean los "

"resultados a un número fijo de dígitos significativos:"

#: ../Doc/library/decimal.rst:262

msgid ""

"As shown above, the :func:`getcontext` function accesses the current context "

"and allows the settings to be changed. This approach meets the needs of "

"most applications."

msgstr ""

"Como se muestra arriba, la función :func:`getcontext` accede al contexto "

"actual y permite cambiar la configuración. Este enfoque satisface las "

"necesidades de la mayoría de las aplicaciones."

#: ../Doc/library/decimal.rst:266

msgid ""

"For more advanced work, it may be useful to create alternate contexts using "

"the Context() constructor. To make an alternate active, use the :func:"

"`setcontext` function."

msgstr ""

"Para trabajos más avanzados, puede resultar útil crear contextos "

"alternativos utilizando el constructor Context(). Para activar un contexto "

"alternativo, usa la función :func:`setcontext`."

#: ../Doc/library/decimal.rst:270

msgid ""

"In accordance with the standard, the :mod:`decimal` module provides two "

"ready to use standard contexts, :const:`BasicContext` and :const:"

"`ExtendedContext`. The former is especially useful for debugging because "

"many of the traps are enabled:"

msgstr ""

"De acuerdo con el estándar, el módulo :mod:`decimal` proporciona dos "

"contextos estándar listos para usar, :const:`BasicContext` y :const:"

"`ExtendedContext`. El primero es particularmente útil para la depuración, ya "

"que muchas de las trampas de señales están habilitadas por defecto:"

#: ../Doc/library/decimal.rst:275

msgid ""

">>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)\n"

">>> setcontext(myothercontext)\n"

">>> Decimal(1) / Decimal(7)\n"

"Decimal('0.142857142857142857142857142857142857142857142857142857142857')\n"

"\n"

">>> ExtendedContext\n"

"Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"

" capitals=1, clamp=0, flags=[], traps=[])\n"

">>> setcontext(ExtendedContext)\n"

">>> Decimal(1) / Decimal(7)\n"

"Decimal('0.142857143')\n"

">>> Decimal(42) / Decimal(0)\n"

"Decimal('Infinity')\n"

"\n"

">>> setcontext(BasicContext)\n"

">>> Decimal(42) / Decimal(0)\n"

"Traceback (most recent call last):\n"

" File \"<pyshell#143>\", line 1, in -toplevel-\n"

" Decimal(42) / Decimal(0)\n"

"DivisionByZero: x / 0"

msgstr ""

#: ../Doc/library/decimal.rst:299

msgid ""

"Contexts also have signal flags for monitoring exceptional conditions "

"encountered during computations. The flags remain set until explicitly "

"cleared, so it is best to clear the flags before each set of monitored "

"computations by using the :meth:`~Context.clear_flags` method. ::"

msgstr ""

"Los objetos Context también tienen flags de señalización para detectar "

"condiciones excepcionales detectadas durante los cálculos. Estos flags "

"permanecen habilitados hasta que se restablecen explícitamente. Por esta "

"razón, suele ser buena idea restablecerlos mediante el método :meth:"

"`~Context.clear_flags` antes de proceder con cada conjunto de cálculos "

"monitorizados. ::"

#: ../Doc/library/decimal.rst:304

msgid ""

">>> setcontext(ExtendedContext)\n"

">>> getcontext().clear_flags()\n"

">>> Decimal(355) / Decimal(113)\n"

"Decimal('3.14159292')\n"

">>> getcontext()\n"

"Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,\n"

" capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[])"

msgstr ""

#: ../Doc/library/decimal.rst:312

msgid ""

"The *flags* entry shows that the rational approximation to pi was rounded "

"(digits beyond the context precision were thrown away) and that the result "

"is inexact (some of the discarded digits were non-zero)."

msgstr ""

"La entrada *flags* muestra que la aproximación racional de Pi fue redondeada "

"(los dígitos más allá de la precisión especificada por el contexto se "

"descartaron) y que el resultado es inexacto (algunos de los dígitos "

"descartados no eran cero)."

#: ../Doc/library/decimal.rst:316

msgid ""

"Individual traps are set using the dictionary in the :attr:`~Context.traps` "

"attribute of a context:"

msgstr ""

"Las trampas de señales se habilitan a través del diccionario expuesto por el "

"atributo :attr:`~Context.traps` del objeto Context:"

#: ../Doc/library/decimal.rst:319

msgid ""

">>> setcontext(ExtendedContext)\n"

">>> Decimal(1) / Decimal(0)\n"

"Decimal('Infinity')\n"

">>> getcontext().traps[DivisionByZero] = 1\n"

">>> Decimal(1) / Decimal(0)\n"

"Traceback (most recent call last):\n"

" File \"<pyshell#112>\", line 1, in -toplevel-\n"

" Decimal(1) / Decimal(0)\n"

"DivisionByZero: x / 0"

msgstr ""

#: ../Doc/library/decimal.rst:331

msgid ""

"Most programs adjust the current context only once, at the beginning of the "

"program. And, in many applications, data is converted to :class:`Decimal` "

"with a single cast inside a loop. With context set and decimals created, "

"the bulk of the program manipulates the data no differently than with other "

"Python numeric types."

msgstr ""

"La mayoría de los programas ajustan el contexto actual una sola vez, al "

"comienzo del programa. Y, en muchas aplicaciones, los datos se convierten a :"

"class:`Decimal` mediante una única conversión dentro de un bucle. Con el "

"contexto establecido y los decimales creados, la mayor parte del programa "

"manipula los datos de la misma forma que con otros tipos numéricos de Python."

#: ../Doc/library/decimal.rst:343

msgid "Decimal objects"

msgstr "Objetos Decimal"

#: ../Doc/library/decimal.rst:348

msgid "Construct a new :class:`Decimal` object based from *value*."

msgstr "Construye un nuevo objeto :class:`Decimal` basado en *value*."

#: ../Doc/library/decimal.rst:350

msgid ""

"*value* can be an integer, string, tuple, :class:`float`, or another :class:"

"`Decimal` object. If no *value* is given, returns ``Decimal('0')``. If "

"*value* is a string, it should conform to the decimal numeric string syntax "

"after leading and trailing whitespace characters, as well as underscores "

"throughout, are removed::"

msgstr ""

"*value* puede ser un entero, una cadena de caracteres, una tupla, un :class:"

"`float` u otro objeto :class:`Decimal`. Si no se proporciona *value*, "

"retorna ``Decimal('0')``. Si *value* es una cadena, debe ajustarse a la "

"sintaxis de cadena numérica decimal después de que los espacios en blanco "

"iniciales y finales, así como los guiones bajos, sean eliminados::"

#: ../Doc/library/decimal.rst:355

msgid ""

"sign ::= '+' | '-'\n"

"digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | "

"'9'\n"

"indicator ::= 'e' | 'E'\n"

"digits ::= digit [digit]...\n"

"decimal-part ::= digits '.' [digits] | ['.'] digits\n"

"exponent-part ::= indicator [sign] digits\n"

"infinity ::= 'Infinity' | 'Inf'\n"

"nan ::= 'NaN' [digits] | 'sNaN' [digits]\n"

"numeric-value ::= decimal-part [exponent-part] | infinity\n"

"numeric-string ::= [sign] numeric-value | [sign] nan"

msgstr ""

#: ../Doc/library/decimal.rst:366

msgid ""

"Other Unicode decimal digits are also permitted where ``digit`` appears "

"above. These include decimal digits from various other alphabets (for "

"example, Arabic-Indic and Devanāgarī digits) along with the fullwidth digits "

"``'\\uff10'`` through ``'\\uff19'``."

msgstr ""

"También se permiten otros dígitos decimales Unicode en aquellos lugares en "

"los que arriba aparece ``digit``. Estos incluyen dígitos decimales de otros "

"alfabetos (por ejemplo, dígitos del alfabeto árabe-índico y devanāgarī) "

"junto con los dígitos de ancho completo desde ``'\\uff10'`` a ``'\\uff19'``."

#: ../Doc/library/decimal.rst:371

msgid ""

"If *value* is a :class:`tuple`, it should have three components, a sign "

"(``0`` for positive or ``1`` for negative), a :class:`tuple` of digits, and "

"an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), -3))`` returns "

"``Decimal('1.414')``."

msgstr ""

"Si *value* es un objeto :class:`tuple`, debe tener tres componentes, un "

"signo (``0`` para positivo o ``1`` para negativo), un objeto :class:`tuple` "

"con los dígitos y un exponente entero. Por ejemplo, ``Decimal((0, (1, 4, 1, "

"4), -3))`` retorna ``Decimal('1.414')``."

#: ../Doc/library/decimal.rst:376

#, fuzzy

msgid ""

"If *value* is a :class:`float`, the binary floating-point value is "

"losslessly converted to its exact decimal equivalent. This conversion can "

"often require 53 or more digits of precision. For example, "

"``Decimal(float('1.1'))`` converts to "

"``Decimal('1.100000000000000088817841970012523233890533447265625')``."

msgstr ""

"Si *value* es un :class:`float`, el valor binario de coma flotante se "

"convierte sin pérdidas a su equivalente decimal exacto. Esta conversión a "

"menudo puede requerir 53 o más dígitos de precisión. Por ejemplo, "

"``Decimal(float('1.1'))`` se convierte en "

"``Decimal('1.100000000000000088817841970012523233890533447265625')``."

#: ../Doc/library/decimal.rst:382

msgid ""

"The *context* precision does not affect how many digits are stored. That is "

"determined exclusively by the number of digits in *value*. For example, "

"``Decimal('3.00000')`` records all five zeros even if the context precision "

"is only three."

msgstr ""

"La precisión de *context* no afecta a la cantidad de dígitos almacenados. "

"Eso está determinado exclusivamente por el número de dígitos en *value*. Por "

"ejemplo, ``Decimal('3.00000')`` registra los cinco ceros incluso si la "

"precisión del contexto es solo tres."

#: ../Doc/library/decimal.rst:387

msgid ""

"The purpose of the *context* argument is determining what to do if *value* "

"is a malformed string. If the context traps :const:`InvalidOperation`, an "

"exception is raised; otherwise, the constructor returns a new Decimal with "

"the value of ``NaN``."

msgstr ""

"El propósito del argumento *context* es determinar qué hacer si *value* es "

"una cadena de caracteres mal formada. Si el contexto atrapa la señal :const:"

"`InvalidOperation`, se genera una excepción; de lo contrario, el constructor "

"retorna un nuevo decimal con el valor ``NaN``."

#: ../Doc/library/decimal.rst:392

msgid "Once constructed, :class:`Decimal` objects are immutable."

msgstr "Una vez construidos, los objetos :class:`Decimal` son inmutables."

#: ../Doc/library/decimal.rst:394

msgid ""

"The argument to the constructor is now permitted to be a :class:`float` "

"instance."

msgstr ""

"Ahora se permite que el argumento del constructor sea una instancia :class:"

"`float`."

#: ../Doc/library/decimal.rst:398

msgid ""

":class:`float` arguments raise an exception if the :exc:`FloatOperation` "

"trap is set. By default the trap is off."

msgstr ""

"Los argumentos :class:`float` ahora generan una excepción si se establece la "

"trampa :exc:`FloatOperation`. Por defecto, la trampa está desactivada."

#: ../Doc/library/decimal.rst:402

msgid ""

"Underscores are allowed for grouping, as with integral and floating-point "

"literals in code."

msgstr ""

"Se permiten guiones bajos para la agrupación, como ocurre en el código con "

"los literales enteros y de punto flotante."

#: ../Doc/library/decimal.rst:406

#, fuzzy

msgid ""

"Decimal floating-point objects share many properties with the other built-in "

"numeric types such as :class:`float` and :class:`int`. All of the usual "

"math operations and special methods apply. Likewise, decimal objects can be "

"copied, pickled, printed, used as dictionary keys, used as set elements, "

"compared, sorted, and coerced to another type (such as :class:`float` or :"

"class:`int`)."

msgstr ""

"Los objetos de coma flotante decimal comparten muchas propiedades con los "

"otros tipos numéricos integrados, como :class:`float` e :class:`int`. Se "

"aplican todas las operaciones matemáticas habituales y los métodos "

"especiales. Asimismo, los objetos decimales se pueden copiar, serializar con "

"pickle, imprimir, usar como claves de un diccionario o como elementos de un "

"conjunto, comparar, ordenar y convertir a otros tipos (como :class:`float` "

"o :class:`int`)."

#: ../Doc/library/decimal.rst:413

msgid ""

"There are some small differences between arithmetic on Decimal objects and "

"arithmetic on integers and floats. When the remainder operator ``%`` is "

"applied to Decimal objects, the sign of the result is the sign of the "

"*dividend* rather than the sign of the divisor::"

msgstr ""

"Hay algunas pequeñas diferencias entre la aritmética en objetos decimales y "

"la aritmética en enteros y flotantes. Cuando el operador de resto ``%`` se "

"aplica a objetos Decimal, el signo del resultado es el signo del *dividendo* "

"en lugar del signo del divisor::"

#: ../Doc/library/decimal.rst:418

msgid ""

">>> (-7) % 4\n"

"1\n"

">>> Decimal(-7) % Decimal(4)\n"

"Decimal('-3')"

msgstr ""

#: ../Doc/library/decimal.rst:423

msgid ""

"The integer division operator ``//`` behaves analogously, returning the "

"integer part of the true quotient (truncating towards zero) rather than its "

"floor, so as to preserve the usual identity ``x == (x // y) * y + x % y``::"

msgstr ""

"El operador de división entera ``//`` se comporta de manera análoga, "

"retornando la parte entera del cociente verdadero (truncando hacia cero) en "

"lugar del resultado de aplicarle la función suelo. Esto se hace con la "

"finalidad de preservar la identidad habitual ``x == (x // y) * y + x % y``::"

#: ../Doc/library/decimal.rst:427

msgid ""

">>> -7 // 4\n"

"-2\n"

">>> Decimal(-7) // Decimal(4)\n"

"Decimal('-1')"

msgstr ""

#: ../Doc/library/decimal.rst:432

msgid ""

"The ``%`` and ``//`` operators implement the ``remainder`` and ``divide-"

"integer`` operations (respectively) as described in the specification."

msgstr ""

"Los operadores ``%`` y ``//`` implementan las operaciones ``remainder`` y "

"``divide-integer`` (respectivamente) como se describe en la especificación."

#: ../Doc/library/decimal.rst:436

msgid ""

"Decimal objects cannot generally be combined with floats or instances of :"

"class:`fractions.Fraction` in arithmetic operations: an attempt to add a :"

"class:`Decimal` to a :class:`float`, for example, will raise a :exc:"

"`TypeError`. However, it is possible to use Python's comparison operators "

"to compare a :class:`Decimal` instance ``x`` with another number ``y``. "

"This avoids confusing results when doing equality comparisons between "

"numbers of different types."

msgstr ""

"Los objetos de la clase Decimal generalmente no se pueden combinar con "

"flotantes o instancias de :class:`fractions.Fraction` en operaciones "

"aritméticas: un intento de agregar un objeto :class:`Decimal` a un :class:"

"`float`, por ejemplo, lanzará una excepción :exc:`TypeError`. Sin embargo, "

"es posible usar los operadores de comparación de Python para comparar una "

"instancia de :class:`Decimal` ``x`` con otro número ``y``. Esto evita "

"resultados confusos al hacer comparaciones de igualdad entre números de "

"diferentes tipos."

#: ../Doc/library/decimal.rst:444

msgid ""

"Mixed-type comparisons between :class:`Decimal` instances and other numeric "

"types are now fully supported."

msgstr ""

"Las comparaciones de tipo mixto entre instancias de :class:`Decimal` y otros "

"tipos numéricos ahora son totalmente compatibles."

#: ../Doc/library/decimal.rst:448

#, fuzzy

msgid ""

"In addition to the standard numeric properties, decimal floating-point "

"objects also have a number of specialized methods:"

msgstr ""

"Además de las propiedades numéricas estándar, los objetos de coma flotante "

"decimal también tienen varios métodos especializados:"

#: ../Doc/library/decimal.rst:454

msgid ""

"Return the adjusted exponent after shifting out the coefficient's rightmost "

"digits until only the lead digit remains: ``Decimal('321e+5').adjusted()`` "

"returns seven. Used for determining the position of the most significant "

"digit with respect to the decimal point."

msgstr ""

"Retorna el exponente ajustado después de desplazar los dígitos del extremo "

"derecho del coeficiente hasta que solo quede el dígito principal: "

"``Decimal('321e+5').adjusted()`` retorna siete. Se utiliza para determinar "

"la posición del dígito más significativo con respecto al punto decimal."

#: ../Doc/library/decimal.rst:461

msgid ""

"Return a pair ``(n, d)`` of integers that represent the given :class:"

"`Decimal` instance as a fraction, in lowest terms and with a positive "

"denominator::"

msgstr ""

"Retorna un par de enteros ``(n, d)`` que representan la instancia de :class:"

"`Decimal` proporcionada como una fracción irreducible y con un denominador "

"positivo::"

#: ../Doc/library/decimal.rst:465

msgid ""

">>> Decimal('-3.14').as_integer_ratio()\n"

"(-157, 50)"

msgstr ""

#: ../Doc/library/decimal.rst:468

msgid ""

"The conversion is exact. Raise OverflowError on infinities and ValueError "

"on NaNs."

msgstr ""

"La conversión es exacta. Lanza una excepción OverflowError si se "

"proporcionan valores infinitos y ValueError con valores NaN."

#: ../Doc/library/decimal.rst:475

msgid ""

"Return a :term:`named tuple` representation of the number: "

"``DecimalTuple(sign, digits, exponent)``."

msgstr ""

"Retorna una representación en forma de :term:`named tuple` del número: "

"``DecimalTuple(sign, digits, exponent)``."

#: ../Doc/library/decimal.rst:481

msgid ""

"Return the canonical encoding of the argument. Currently, the encoding of "

"a :class:`Decimal` instance is always canonical, so this operation returns "

"its argument unchanged."

msgstr ""

"Retorna la codificación canónica del argumento. Actualmente, la codificación "

"de una instancia de :class:`Decimal` es siempre canónica, por lo que esta "

"operación retorna su argumento sin cambios."

#: ../Doc/library/decimal.rst:487

msgid ""

"Compare the values of two Decimal instances. :meth:`compare` returns a "

"Decimal instance, and if either operand is a NaN then the result is a NaN::"

msgstr ""

"Compara los valores de dos instancias de Decimal. El método :meth:`compare` "

"retorna una instancia de Decimal, y si alguno de los operandos es un NaN, el "

"resultado es un NaN::"

#: ../Doc/library/decimal.rst:491

msgid ""

"a or b is a NaN ==> Decimal('NaN')\n"

"a < b ==> Decimal('-1')\n"

"a == b ==> Decimal('0')\n"

"a > b ==> Decimal('1')"

msgstr ""

#: ../Doc/library/decimal.rst:498

msgid ""

"This operation is identical to the :meth:`compare` method, except that all "

"NaNs signal. That is, if neither operand is a signaling NaN then any quiet "

"NaN operand is treated as though it were a signaling NaN."

msgstr ""

"Esta operación es idéntica al método :meth:`compare`, excepto que todos los "

"valores NaN generan una señal. Es decir, si ninguno de los operandos es un "

"NaN señalizador, cualquier operando de NaN silencioso se trata como si fuera "

"un NaN señalizador."

#: ../Doc/library/decimal.rst:504

msgid ""

"Compare two operands using their abstract representation rather than their "

"numerical value. Similar to the :meth:`compare` method, but the result "

"gives a total ordering on :class:`Decimal` instances. Two :class:`Decimal` "

"instances with the same numeric value but different representations compare "

"unequal in this ordering:"

msgstr ""

"Compara dos operandos utilizando su representación abstracta en lugar de su "

"valor numérico. Similar al método :meth:`compare`, pero el resultado "

"proporciona un ordenamiento total en las instancias de :class:`Decimal`. Dos "

"instancias de :class:`Decimal` con el mismo valor numérico, pero diferentes "

"representaciones, se comparan como desiguales usando este orden:"

#: ../Doc/library/decimal.rst:513

msgid ""

"Quiet and signaling NaNs are also included in the total ordering. The "

"result of this function is ``Decimal('0')`` if both operands have the same "

"representation, ``Decimal('-1')`` if the first operand is lower in the total "

"order than the second, and ``Decimal('1')`` if the first operand is higher "

"in the total order than the second operand. See the specification for "

"details of the total order."

msgstr ""

"Los NaN silenciosos y señalizadores también se incluyen en el ordenamiento "

"total. El resultado de esta función es ``Decimal('0')`` si ambos operandos "

"tienen la misma representación, ``Decimal('-1')`` si el primer operando es "

"menor en el orden total que el segundo y ``Decimal('1')`` si el primer "

"operando es mayor en el orden total que el segundo operando. Consulta las "

"especificaciones para obtener detalles sobre el ordenamiento total."

#: ../Doc/library/decimal.rst:520 ../Doc/library/decimal.rst:531

#: ../Doc/library/decimal.rst:559 ../Doc/library/decimal.rst:846

msgid ""

"This operation is unaffected by context and is quiet: no flags are changed "

"and no rounding is performed. As an exception, the C version may raise "

"InvalidOperation if the second operand cannot be converted exactly."

msgstr ""

"Esta operación no se ve afectada por el contexto y es silenciosa: no se "

"cambian los flags y no se realiza ningún redondeo. Como excepción, la "

"versión de C puede lanzar InvalidOperation si el segundo operando no se "

"puede convertir exactamente."

#: ../Doc/library/decimal.rst:526

msgid ""

"Compare two operands using their abstract representation rather than their "

"value as in :meth:`compare_total`, but ignoring the sign of each operand. "

"``x.compare_total_mag(y)`` is equivalent to ``x.copy_abs().compare_total(y."

"copy_abs())``."

msgstr ""

"Compara dos operandos usando su representación abstracta en lugar de su "

"valor, como en :meth:`compare_total`, pero ignorando el signo de cada "

"operando. ``x.compare_total_mag(y)`` es equivalente a ``x.copy_abs()."

"compare_total(y.copy_abs())``."

#: ../Doc/library/decimal.rst:537

msgid ""

"Just returns self, this method is only to comply with the Decimal "

"Specification."

msgstr ""

"Simplemente retorna self (el propio objeto al que pertenece el método "

"invocado). Este método existe solo para cumplir con la Especificación "

"decimal."

#: ../Doc/library/decimal.rst:542

msgid ""

"Return the absolute value of the argument. This operation is unaffected by "

"the context and is quiet: no flags are changed and no rounding is performed."

msgstr ""

"Retorna el valor absoluto del argumento. Esta operación no se ve afectada "

"por el contexto y es silenciosa: no se modifican los flags y no se realiza "

"ningún redondeo."

#: ../Doc/library/decimal.rst:548

msgid ""

"Return the negation of the argument. This operation is unaffected by the "

"context and is quiet: no flags are changed and no rounding is performed."

msgstr ""

"Retorna la negación del argumento. Esta operación no se ve afectada por el "

"contexto y es silenciosa: no se cambian los flags y no se realiza ningún "

"redondeo."

#: ../Doc/library/decimal.rst:553

msgid ""

"Return a copy of the first operand with the sign set to be the same as the "

"sign of the second operand. For example:"

msgstr ""

"Retorna una copia del primer operando pero con el signo establecido para que "

"sea el mismo que el del segundo operando. Por ejemplo:"

#: ../Doc/library/decimal.rst:565

msgid ""

"Return the value of the (natural) exponential function ``e**x`` at the given "

"number. The result is correctly rounded using the :const:`ROUND_HALF_EVEN` "

"rounding mode."

msgstr ""

"Retorna el valor de la función exponencial (natural) ``e**x`` en el número "

"dado. El resultado es correctamente redondeado utilizando el modo de "

"redondeo :const:`ROUND_HALF_EVEN`."

#: ../Doc/library/decimal.rst:576

msgid ""

"Alternative constructor that only accepts instances of :class:`float` or :"

"class:`int`."

msgstr ""

"Constructor alternativo que acepta únicamente instancias de :class:`float` "

"o :class:`int`."

#: ../Doc/library/decimal.rst:579

msgid ""

"Note ``Decimal.from_float(0.1)`` is not the same as ``Decimal('0.1')``. "

"Since 0.1 is not exactly representable in binary floating point, the value "

"is stored as the nearest representable value which is "

"``0x1.999999999999ap-4``. That equivalent value in decimal is "

"``0.1000000000000000055511151231257827021181583404541015625``."

msgstr ""

"Fíjate que ``Decimal.from_float(0.1)`` no es lo mismo que "

"``Decimal('0.1')``. Dado que 0.1 no es exactamente representable en coma "

"flotante binaria, el valor se almacena como el valor representable más "

"cercano, que es ``0x1.999999999999ap-4``. Ese valor equivalente en decimal "

"es ``0.1000000000000000055511151231257827021181583404541015625``."

#: ../Doc/library/decimal.rst:585

msgid ""

"From Python 3.2 onwards, a :class:`Decimal` instance can also be constructed "

"directly from a :class:`float`."

msgstr ""

"Desde Python 3.2 en adelante, una instancia de :class:`Decimal` también se "

"puede construir directamente desde una instancia de :class:`float`."

#: ../Doc/library/decimal.rst:588

msgid ""

">>> Decimal.from_float(0.1)\n"

"Decimal('0.1000000000000000055511151231257827021181583404541015625')\n"

">>> Decimal.from_float(float('nan'))\n"

"Decimal('NaN')\n"

">>> Decimal.from_float(float('inf'))\n"

"Decimal('Infinity')\n"

">>> Decimal.from_float(float('-inf'))\n"

"Decimal('-Infinity')"

msgstr ""

#: ../Doc/library/decimal.rst:603

msgid ""

"Fused multiply-add. Return self*other+third with no rounding of the "

"intermediate product self*other."

msgstr ""

"Fusión de la multiplicación y la suma. Retorna self*other+third sin redondeo "

"del producto intermedio self*other."

#: ../Doc/library/decimal.rst:611

msgid ""

"Return :const:`True` if the argument is canonical and :const:`False` "

"otherwise. Currently, a :class:`Decimal` instance is always canonical, so "

"this operation always returns :const:`True`."

msgstr ""

"Retorna :const:`True` si el argumento es canónico y :const:`False` en caso "

"contrario. Actualmente, una instancia de :class:`Decimal` es siempre "

"canónica, por lo que esta operación siempre retorna :const:`True`."