/
numbers.po
274 lines (245 loc) · 12 KB
/
numbers.po
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
# 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: 2019-05-06 11:59-0400\n"
"PO-Revision-Date: 2020-12-20 19:28-0300\n"
"Language-Team: python-doc-es\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Last-Translator: Jhonatan Barrera <iam3mer@gmail.com>\n"
"Language: es\n"
"X-Generator: Poedit 2.4.1\n"
#: ../Doc/library/numbers.rst:2
msgid ":mod:`numbers` --- Numeric abstract base classes"
msgstr ":mod:`numbers` --- Clase base abstracta numérica"
#: ../Doc/library/numbers.rst:7
msgid "**Source code:** :source:`Lib/numbers.py`"
msgstr "**Código fuente:** :source:`Lib/numbers.py`"
# revisar como usamos "abstract base classes" en el glosario
#: ../Doc/library/numbers.rst:11
#, fuzzy
msgid ""
"The :mod:`numbers` module (:pep:`3141`) defines a hierarchy of numeric :term:"
"`abstract base classes <abstract base class>` which progressively define "
"more operations. None of the types defined in this module can be "
"instantiated."
msgstr ""
"El módulo :mod:`numbers` (:pep:`3141`) define una jerarquía numérica :term:"
"`abstract base classes <abstract base class>` que define progresivamente más "
"operaciones. No se puede crear una instancia de ninguno de los tipos "
"definidos en este módulo."
#: ../Doc/library/numbers.rst:18
msgid ""
"The root of the numeric hierarchy. If you just want to check if an argument "
"*x* is a number, without caring what kind, use ``isinstance(x, Number)``."
msgstr ""
"La raíz de la jerarquía numérica. Si desea validar si un argumento *x* es un "
"número, sin importar su tipo, use ``isinstance(x, Number)``."
# La verdad no se si sea buena esta traducción
#: ../Doc/library/numbers.rst:23
#, fuzzy
msgid "The numeric tower"
msgstr "La torre numérica"
#: ../Doc/library/numbers.rst:27
msgid ""
"Subclasses of this type describe complex numbers and include the operations "
"that work on the built-in :class:`complex` type. These are: conversions to :"
"class:`complex` and :class:`bool`, :attr:`.real`, :attr:`.imag`, ``+``, ``-"
"``, ``*``, ``/``, :func:`abs`, :meth:`conjugate`, ``==``, and ``!=``. All "
"except ``-`` and ``!=`` are abstract."
msgstr ""
"Las subclases de este tipo describen números complejos e incluyen las "
"operaciones integradas del tipo :class:`complex`. Estas son: conversiones a :"
"class:`complex` y :class:`bool`, :attr:`.real`, :attr:`..imag`, ``+``, ``-"
"``, ``*`, ``/``, :func:`abs`, :meth:`conjugate`, ``==``, y ``!=``. Todos "
"excepto ``-`` y ``!=`` estos son abstractos."
#: ../Doc/library/numbers.rst:35
msgid "Abstract. Retrieves the real component of this number."
msgstr "Abstracto. Recupera el componente real de este número."
#: ../Doc/library/numbers.rst:39
msgid "Abstract. Retrieves the imaginary component of this number."
msgstr "Abstracto. Recupera el componente imaginario de este número."
#: ../Doc/library/numbers.rst:43
msgid ""
"Abstract. Returns the complex conjugate. For example, ``(1+3j).conjugate() "
"== (1-3j)``."
msgstr ""
"Abstracto. Retorna el complejo conjugado. Por ejemplo, ``(1+3j).conjugate() "
"== (1-3j)``."
#: ../Doc/library/numbers.rst:48
msgid ""
"To :class:`Complex`, :class:`Real` adds the operations that work on real "
"numbers."
msgstr ""
"Para :class:`Complex`, :class:`Real` agrega las operaciones que trabajan con "
"números reales."
#: ../Doc/library/numbers.rst:51
msgid ""
"In short, those are: a conversion to :class:`float`, :func:`math.trunc`, :"
"func:`round`, :func:`math.floor`, :func:`math.ceil`, :func:`divmod`, ``//``, "
"``%``, ``<``, ``<=``, ``>``, and ``>=``."
msgstr ""
"En resumen, estos son: conversiones a :class:`float`, :func:`math.trunc`, :"
"func:`round`, :func:`math.floor`, :func:`math.ceil`, :func:`divmod`, ``//``, "
"``%``, ``<``, ``<=``, ``>``, y ``>=``."
#: ../Doc/library/numbers.rst:55
msgid ""
"Real also provides defaults for :func:`complex`, :attr:`~Complex.real`, :"
"attr:`~Complex.imag`, and :meth:`~Complex.conjugate`."
msgstr ""
"*Real* también proporciona valores predeterminados para :func:`complex`, :"
"attr:`~Complex.real`, :attr:`~Complex.imag`, y :meth:`~Complex.conjugate`."
# Se me hace super rara toda la cadena. Agrego "Subtypes" como "Hereda"
#: ../Doc/library/numbers.rst:61
#, fuzzy
msgid ""
"Subtypes :class:`Real` and adds :attr:`~Rational.numerator` and :attr:"
"`~Rational.denominator` properties, which should be in lowest terms. With "
"these, it provides a default for :func:`float`."
msgstr ""
"Hereda de :class:`Real` y agrega las propiedades :attr:`~Rational.numerator` "
"y :attr:`~Rational.denominator`, que deberían estar en los términos más "
"bajos. Con esto, se proporciona un valor predeterminado a :func:`float`."
#: ../Doc/library/numbers.rst:68 ../Doc/library/numbers.rst:72
msgid "Abstract."
msgstr "Abstracto."
#: ../Doc/library/numbers.rst:77
msgid ""
"Subtypes :class:`Rational` and adds a conversion to :class:`int`. Provides "
"defaults for :func:`float`, :attr:`~Rational.numerator`, and :attr:"
"`~Rational.denominator`. Adds abstract methods for ``**`` and bit-string "
"operations: ``<<``, ``>>``, ``&``, ``^``, ``|``, ``~``."
msgstr ""
"Hereda :class:`Rational` y agrega conversión a :class:`int`. Proporciona "
"valores predeterminados para :func:`float`, :attr:`~Rational.numerator`, y :"
"attr:`~Rational.denominator`. Agreda métodos abstractos para operaciones "
"``**`` y operaciones de cadena de bits: ``<<``, ``>>``, ``&``, ``^``, ``|``, "
"``~``."
#: ../Doc/library/numbers.rst:84
msgid "Notes for type implementors"
msgstr "Notas para implementadores de tipos"
# Por aca tengo problemas con esta fracción de la cadena: Implementors should be careful to make equal numbers equal and hash them to the same values
#: ../Doc/library/numbers.rst:86
#, fuzzy
msgid ""
"Implementors should be careful to make equal numbers equal and hash them to "
"the same values. This may be subtle if there are two different extensions of "
"the real numbers. For example, :class:`fractions.Fraction` implements :func:"
"`hash` as follows::"
msgstr ""
"Los implementadores deben tener cuidado de hacer que números iguales sean "
"iguales y hacer *hash* con los mismos valores. Esto puede ser sutil si hay "
"dos extensiones diferentes de los números reales. Por ejemplo: :class:"
"`fractions.Fraction` implementa :func:`hash` de la siguiente manera::"
#: ../Doc/library/numbers.rst:105
msgid "Adding More Numeric ABCs"
msgstr "Agregar más *ABCs* numéricos"
#: ../Doc/library/numbers.rst:107
msgid ""
"There are, of course, more possible ABCs for numbers, and this would be a "
"poor hierarchy if it precluded the possibility of adding those. You can add "
"``MyFoo`` between :class:`Complex` and :class:`Real` with::"
msgstr ""
"Por supuesto, hay más *ABCs* posibles para los números, y esto sería una "
"jerarquía deficiente si se excluye la posibilidad de añadirlos. Puede usar "
"``MyFoo`` entre :class:`Complex` y :class:`Real` así::"
#: ../Doc/library/numbers.rst:119
msgid "Implementing the arithmetic operations"
msgstr "Implementar operaciones aritméticas"
#: ../Doc/library/numbers.rst:121
msgid ""
"We want to implement the arithmetic operations so that mixed-mode operations "
"either call an implementation whose author knew about the types of both "
"arguments, or convert both to the nearest built in type and do the operation "
"there. For subtypes of :class:`Integral`, this means that :meth:`__add__` "
"and :meth:`__radd__` should be defined as::"
msgstr ""
"Queremos implementar las operaciones aritméticas tal que las operaciones de "
"modo mixto llamen a una implementación cuyo autor conocía los tipos de ambos "
"argumentos, o convertir ambos argumentos al tipo incorporado más cercano "
"antes de hacer la operación. Para subtipos de :class:`Integral`, esto "
"significa que :meth:`__add__` y :meth:`__radd__` tienen que ser definidos "
"como::"
# boilerplate -> repetitivo --revisar en todo el archivo
#: ../Doc/library/numbers.rst:152
msgid ""
"There are 5 different cases for a mixed-type operation on subclasses of :"
"class:`Complex`. I'll refer to all of the above code that doesn't refer to "
"``MyIntegral`` and ``OtherTypeIKnowAbout`` as \"boilerplate\". ``a`` will be "
"an instance of ``A``, which is a subtype of :class:`Complex` (``a : A <: "
"Complex``), and ``b : B <: Complex``. I'll consider ``a + b``:"
msgstr ""
"Hay 5 casos diferentes para una operación de tipo mixto en subclases de :"
"class:`Complex`. Se explicará todo el código anterior que no se refiere a "
"``MyIntegral`` y ``OtherTypeIKnowAbout` como \"repetitivo\". ``a`` será una "
"instancia de ``A``, que es un subtipo de :class:`Complex` (``a: A <: "
"Complex`), y ``b : B <: Complex``. Consideraré ``a + b``:"
#: ../Doc/library/numbers.rst:159
msgid "If ``A`` defines an :meth:`__add__` which accepts ``b``, all is well."
msgstr "Si ``A`` define un :meth:`__add__` que acepta ``b``, todo está bien."
#: ../Doc/library/numbers.rst:161
msgid ""
"If ``A`` falls back to the boilerplate code, and it were to return a value "
"from :meth:`__add__`, we'd miss the possibility that ``B`` defines a more "
"intelligent :meth:`__radd__`, so the boilerplate should return :const:"
"`NotImplemented` from :meth:`__add__`. (Or ``A`` may not implement :meth:"
"`__add__` at all.)"
msgstr ""
"Si ``A`` recurre al código repetitivo y retorna un valor de :meth:`__add__`, "
"perderíamos la posibilidad de que B defina un :meth:`__radd __` más "
"inteligente, por lo que el código repetitivo debería retornar :const:"
"`NotImplemented` de :meth:`__add__`. (O ``A`` no puede implementar :meth:"
"`__add__` en absoluto.)"
#: ../Doc/library/numbers.rst:167
msgid ""
"Then ``B``'s :meth:`__radd__` gets a chance. If it accepts ``a``, all is "
"well."
msgstr ""
"Entonces ``B``'s :meth:`__radd__` tiene una oportunidad. Si acepta ``a``, "
"todo esta bien."
#: ../Doc/library/numbers.rst:169
msgid ""
"If it falls back to the boilerplate, there are no more possible methods to "
"try, so this is where the default implementation should live."
msgstr ""
"Si se vuelve a caer en el código repetitivo, no hay más posibles métodos "
"para probar, por lo que acá debería vivir la implementación predeterminada."
#: ../Doc/library/numbers.rst:172
msgid ""
"If ``B <: A``, Python tries ``B.__radd__`` before ``A.__add__``. This is ok, "
"because it was implemented with knowledge of ``A``, so it can handle those "
"instances before delegating to :class:`Complex`."
msgstr ""
"Si ``B <: A``, Python probara ``B.__radd__`` antes que ``A.__add__``. Esto "
"está bien, porque se implementó con conocimiento de ``A``, por lo que puede "
"manejar instancias antes de delegar un :class:`Complex`."
#: ../Doc/library/numbers.rst:177
msgid ""
"If ``A <: Complex`` and ``B <: Real`` without sharing any other knowledge, "
"then the appropriate shared operation is the one involving the built in :"
"class:`complex`, and both :meth:`__radd__` s land there, so ``a+b == b+a``."
msgstr ""
"Si ``A <: Complex`` y ``B <: Real`` sin compartir ningún otro conocimiento,"
"la operación compartida apropiada es la que involucra la clase :class:"
"`complex` incorporada, y ambos :meth:`__radd__` desencadenan allí, entonces "
"``a+b == b+a``."
#: ../Doc/library/numbers.rst:182
msgid ""
"Because most of the operations on any given type will be very similar, it "
"can be useful to define a helper function which generates the forward and "
"reverse instances of any given operator. For example, :class:`fractions."
"Fraction` uses::"
msgstr ""
"Dado que la mayoría de las operaciones en un tipo determinado serán muy "
"similares, puede ser útil definir una función auxiliar que genere las "
"instancias *forward* y *reverse* de cualquier operador dado. Por ejemplo, :"
"class:`fractions.Fraction` así:"