operator.po

# 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: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2023-03-17 20:03-0500\n"
"Last-Translator: Brian Bokser\n"
"Language: 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.13.0\n"

#: ../Doc/library/operator.rst:2
msgid ":mod:`operator` --- Standard operators as functions"
msgstr ":mod:`operator` --- Operadores estándar como funciones"

#: ../Doc/library/operator.rst:9
msgid "**Source code:** :source:`Lib/operator.py`"
msgstr "**Código fuente:** :source:`Lib/operator.py`"

#: ../Doc/library/operator.rst:18
msgid ""
"The :mod:`operator` module exports a set of efficient functions "
"corresponding to the intrinsic operators of Python.  For example, ``operator."
"add(x, y)`` is equivalent to the expression ``x+y``. Many function names are "
"those used for special methods, without the double underscores.  For "
"backward compatibility, many of these have a variant with the double "
"underscores kept. The variants without the double underscores are preferred "
"for clarity."
msgstr ""
"El módulo :mod:`operator` exporta un conjunto de funciones eficientes "
"correspondientes a los operadores intrínsecos de Python.  Por ejemplo, "
"``operator.add(x, y)`` es equivalente a la expresión ``x+y``. Muchos nombres "
"de función son los utilizados para métodos especiales, sin los dobles "
"guiones bajos.  Por compatibilidad con versiones anteriores, muchos de estos "
"tienen una variante que conserva los dobles guiones bajos . Se prefieren las "
"variantes sin los dobles guiones bajos para mayor claridad."

#: ../Doc/library/operator.rst:25
msgid ""
"The functions fall into categories that perform object comparisons, logical "
"operations, mathematical operations and sequence operations."
msgstr ""
"Las funciones se dividen en categorías que realizan comparaciones de "
"objetos, operaciones lógicas, operaciones matemáticas y operaciones sobre "
"secuencias."

#: ../Doc/library/operator.rst:28
msgid ""
"The object comparison functions are useful for all objects, and are named "
"after the rich comparison operators they support:"
msgstr ""
"Las funciones de comparación de objetos son útiles para todos los objetos, y "
"llevan el nombre de los operadores de comparación enriquecida que soportan:"

#: ../Doc/library/operator.rst:45
msgid ""
"Perform \"rich comparisons\" between *a* and *b*. Specifically, ``lt(a, b)`` "
"is equivalent to ``a < b``, ``le(a, b)`` is equivalent to ``a <= b``, "
"``eq(a, b)`` is equivalent to ``a == b``, ``ne(a, b)`` is equivalent to ``a !"
"= b``, ``gt(a, b)`` is equivalent to ``a > b`` and ``ge(a, b)`` is "
"equivalent to ``a >= b``.  Note that these functions can return any value, "
"which may or may not be interpretable as a Boolean value.  See :ref:"
"`comparisons` for more information about rich comparisons."
msgstr ""
"Realiza \"comparaciones enriquecidas\" entre *a* y *b*. Específicamente, "
"``lt(a, b)`` es equivalente a ``a < b``, ``le(a, b)`` es equivalente a ``a "
"<= b``, ``eq(a, b)`` es equivalente a ``a == b``, ``ne(a, b)`` es "
"equivalente a ``a != b``, ``gt(a, b)`` es equivalente a ``a > b`` y ``ge(a, "
"b)`` es equivalente a ``a >= b``.  Tenga en cuenta que estas funciones "
"pueden retornar cualquier valor, que puede o no ser interpretable como un "
"valor booleano.  Consulte :ref:`comparisons` para obtener más información "
"sobre las comparaciones enriquecidas."

#: ../Doc/library/operator.rst:54
msgid ""
"The logical operations are also generally applicable to all objects, and "
"support truth tests, identity tests, and boolean operations:"
msgstr ""
"Las operaciones lógicas también son aplicables a todos los objetos, y "
"admiten pruebas de verdad, pruebas de identidad y operaciones booleanas:"

#: ../Doc/library/operator.rst:61
#, fuzzy
msgid ""
"Return the outcome of :keyword:`not` *obj*.  (Note that there is no :meth:`!"
"__not__` method for object instances; only the interpreter core defines this "
"operation.  The result is affected by the :meth:`~object.__bool__` and :meth:"
"`~object.__len__` methods.)"
msgstr ""
"Retorna el resultado de :keyword:`not` *obj*.  (Tenga en cuenta que no hay "
"ningún método :meth:`__not__` para las instancias de objeto; solo el núcleo "
"del intérprete define esta operación.  El resultado se ve afectado por los "
"métodos :meth:`__bool__` y :meth:`__len__`.)"

#: ../Doc/library/operator.rst:69
msgid ""
"Return :const:`True` if *obj* is true, and :const:`False` otherwise.  This "
"is equivalent to using the :class:`bool` constructor."
msgstr ""
"Retorna :const:`True` si *obj* es verdadero, y :const:`False` de lo "
"contrario.  Esto equivale a usar el constructor :class:`bool`."

#: ../Doc/library/operator.rst:75
msgid "Return ``a is b``.  Tests object identity."
msgstr "Retorna ``a is b``.  Chequea la identidad del objeto."

#: ../Doc/library/operator.rst:80
msgid "Return ``a is not b``.  Tests object identity."
msgstr "Retorna ``a is not b``.  Chequea la identidad del objeto."

#: ../Doc/library/operator.rst:83
msgid "The mathematical and bitwise operations are the most numerous:"
msgstr "Las operaciones matemáticas y a nivel de bits son las más numerosas:"

#: ../Doc/library/operator.rst:89
msgid "Return the absolute value of *obj*."
msgstr "Retorna el valor absoluto de *obj*."

#: ../Doc/library/operator.rst:95
msgid "Return ``a + b``, for *a* and *b* numbers."
msgstr "Retorna ``a + b``,  para los números *a* y *b*."

#: ../Doc/library/operator.rst:101
msgid "Return the bitwise and of *a* and *b*."
msgstr "Retorna la \"conjunción bit a bit\" (*bitwise and*) de *a* y *b*."

#: ../Doc/library/operator.rst:107
msgid "Return ``a // b``."
msgstr "Retorna ``a // b``."

#: ../Doc/library/operator.rst:113
msgid "Return *a* converted to an integer.  Equivalent to ``a.__index__()``."
msgstr ""
"Retorna *a* convertido a un número entero. Equivalente a ``a.__index__()``."

#: ../Doc/library/operator.rst:115
msgid ""
"The result always has exact type :class:`int`.  Previously, the result could "
"have been an instance of a subclass of ``int``."
msgstr ""
"El resultado siempre tiene el tipo exacto :class:`int`. Anteriormente, el "
"resultado podría haber sido una instancia de una subclase de ``int``."

#: ../Doc/library/operator.rst:125
msgid ""
"Return the bitwise inverse of the number *obj*.  This is equivalent to "
"``~obj``."
msgstr ""
"Retorna el \"inverso bit a bit\" (*bitwise inverse*) del número *obj*. Esto "
"es equivalente a ``~obj``."

#: ../Doc/library/operator.rst:131
msgid "Return *a* shifted left by *b*."
msgstr "Retorna *a* desplazado a izquierda (*shift left*) *b* bits."

#: ../Doc/library/operator.rst:137
msgid "Return ``a % b``."
msgstr "Retorna ``a % b``."

#: ../Doc/library/operator.rst:143
msgid "Return ``a * b``, for *a* and *b* numbers."
msgstr "Retorna ``a * b``, para los números  *a* y *b*."

#: ../Doc/library/operator.rst:149
msgid "Return ``a @ b``."
msgstr "Retorna ``a @ b``."

#: ../Doc/library/operator.rst:157
msgid "Return *obj* negated (``-obj``)."
msgstr "Retorna *obj* negado (``-obj``)."

#: ../Doc/library/operator.rst:163
msgid "Return the bitwise or of *a* and *b*."
msgstr "Retorna la \"disyunción bit a bit\" (*bitwise or*) de *a* y *b*."

#: ../Doc/library/operator.rst:169
msgid "Return *obj* positive (``+obj``)."
msgstr "Retorna *obj* positivo (``+obj``)."

#: ../Doc/library/operator.rst:175
msgid "Return ``a ** b``, for *a* and *b* numbers."
msgstr "Retorna ``a ** b``, para los números *a* y *b*."

#: ../Doc/library/operator.rst:181
msgid "Return *a* shifted right by *b*."
msgstr "Retorna *a* desplazado a derecha (*shift right*) *b* bits."

#: ../Doc/library/operator.rst:187
msgid "Return ``a - b``."
msgstr "Retorna ``a - b``."

#: ../Doc/library/operator.rst:193
msgid ""
"Return ``a / b`` where 2/3 is .66 rather than 0.  This is also known as "
"\"true\" division."
msgstr ""
"Retorna  ``a / b`` donde 2/3 es .66 en lugar de 0. Esto también se conoce "
"como división \"real\" (*true division*)."

#: ../Doc/library/operator.rst:200
msgid "Return the bitwise exclusive or of *a* and *b*."
msgstr ""
"Retorna la disyunción exclusiva bit a bit (*bitwise exclusive or*) de *a* y "
"*b*."

#: ../Doc/library/operator.rst:203
msgid ""
"Operations which work with sequences (some of them with mappings too) "
"include:"
msgstr ""
"Las operaciones que funcionan con secuencias (y algunas de ellas también con "
"mapeos) incluyen:"

#: ../Doc/library/operator.rst:208
msgid "Return ``a + b`` for *a* and *b* sequences."
msgstr "Retorna ``a + b`` para las secuencias *a* y *b*."

#: ../Doc/library/operator.rst:214
msgid "Return the outcome of the test ``b in a``. Note the reversed operands."
msgstr ""
"Retorna el resultado del chequeo ``b in a``. Notar que los operandos se "
"invirtieron."

#: ../Doc/library/operator.rst:219
msgid "Return the number of occurrences of *b* in *a*."
msgstr "Retorna el número de ocurrencias de *b* en *a*."

#: ../Doc/library/operator.rst:225
msgid "Remove the value of *a* at index *b*."
msgstr "Remueve el valor de *a* en el índice *b*."

#: ../Doc/library/operator.rst:231
msgid "Return the value of *a* at index *b*."
msgstr "Retorna el valor de *a* en el índice *b*."

#: ../Doc/library/operator.rst:236
msgid "Return the index of the first of occurrence of *b* in *a*."
msgstr "Retorna el índice de la primera ocurrencia de *b* en *a*."

#: ../Doc/library/operator.rst:242
msgid "Set the value of *a* at index *b* to *c*."
msgstr "Establece el valor de *a* en el índice *b* a *c*."

#: ../Doc/library/operator.rst:247
#, fuzzy
msgid ""
"Return an estimated length for the object *obj*. First try to return its "
"actual length, then an estimate using :meth:`object.__length_hint__`, and "
"finally return the default value."
msgstr ""
"Retorna un largo estimativo del objeto *o*. Primero intenta retornar su "
"largo real, luego un estimativo usando :meth:`object.__length_hint__`, y "
"finalmente retorna un valor predeterminado."

#: ../Doc/library/operator.rst:254
msgid "The following operation works with callables:"
msgstr "La siguiente operación funciona con invocables:"

#: ../Doc/library/operator.rst:259
msgid "Return ``obj(*args, **kwargs)``."
msgstr "Retorna ``obj(*args, **kwargs)``."

#: ../Doc/library/operator.rst:264
msgid ""
"The :mod:`operator` module also defines tools for generalized attribute and "
"item lookups.  These are useful for making fast field extractors as "
"arguments for :func:`map`, :func:`sorted`, :meth:`itertools.groupby`, or "
"other functions that expect a function argument."
msgstr ""
"El módulo :mod:`operator` también define herramientas para la obtención "
"generalizada de atributos e ítems. Estas herramientas son útiles para "
"utilizar rápidamente extractores de campos como argumentos de :func:`map`, :"
"func:`sorted`, :meth:`itertools.groupby`, u otras funciones que esperan una "
"función como argumento."

#: ../Doc/library/operator.rst:273
msgid ""
"Return a callable object that fetches *attr* from its operand. If more than "
"one attribute is requested, returns a tuple of attributes. The attribute "
"names can also contain dots. For example:"
msgstr ""
"Retorna un objeto invocable que obtiene *attr* de su operando. Si se "
"solicita más de un atributo, retorna una tupla de los atributos. Los nombres "
"de los atributos también pueden contener puntos. Por ejemplo:"

#: ../Doc/library/operator.rst:277
msgid "After ``f = attrgetter('name')``, the call ``f(b)`` returns ``b.name``."
msgstr ""
"Después de ``f = attrgetter('name')``, la llamada ``f(b)`` retorna ``b."
"name``."

#: ../Doc/library/operator.rst:279
msgid ""
"After ``f = attrgetter('name', 'date')``, the call ``f(b)`` returns ``(b."
"name, b.date)``."
msgstr ""
"Después de ``f = attrgetter('name', 'date')``, la llamada ``f(b)`` retorna "
"``(b.name, b.date)``."

#: ../Doc/library/operator.rst:282
msgid ""
"After ``f = attrgetter('name.first', 'name.last')``, the call ``f(b)`` "
"returns ``(b.name.first, b.name.last)``."
msgstr ""
"Después de ``f = attrgetter('name.first', 'name.last')``, la llamada "
"``f(b)`` retorna ``(b.name.first, b.name.last)``."

#: ../Doc/library/operator.rst:285 ../Doc/library/operator.rst:317
#: ../Doc/library/operator.rst:365
msgid "Equivalent to::"
msgstr "Equivalente a::"

#: ../Doc/library/operator.rst:308
msgid ""
"Return a callable object that fetches *item* from its operand using the "
"operand's :meth:`__getitem__` method.  If multiple items are specified, "
"returns a tuple of lookup values.  For example:"
msgstr ""
"Retorna un objeto invocable que obtiene *item* de su operando utilizando "
"sobre el mismo el método :meth:`__getitem__`. Si se especifican múltiples "
"ítems, retorna una tupla con los valores obtenidos. Por ejemplo:"

#: ../Doc/library/operator.rst:312
msgid "After ``f = itemgetter(2)``, the call ``f(r)`` returns ``r[2]``."
msgstr ""
"Después de ``f = itemgetter(2)``, la llamada ``f(r)`` retorna ``r[2]``."

#: ../Doc/library/operator.rst:314
msgid ""
"After ``g = itemgetter(2, 5, 3)``, the call ``g(r)`` returns ``(r[2], r[5], "
"r[3])``."
msgstr ""
"Después de ``g = itemgetter(2, 5, 3)``, la llamada ``g(r)`` retorna ``(r[2], "
"r[5], r[3])``."

#: ../Doc/library/operator.rst:329
#, fuzzy
msgid ""
"The items can be any type accepted by the operand's :meth:`__getitem__` "
"method.  Dictionaries accept any :term:`hashable` value.  Lists, tuples, and "
"strings accept an index or a slice:"
msgstr ""
"Los ítems pueden ser de cualquier tipo aceptado por el método :meth:"
"`__getitem__` del operando. Los diccionarios aceptan cualquier valor "
"*hasheable*. Las listas, las tuplas y las cadenas de caracteres aceptan un "
"índice o un segmento:"

#: ../Doc/library/operator.rst:343
msgid ""
"Example of using :func:`itemgetter` to retrieve specific fields from a tuple "
"record:"
msgstr ""
"Ejemplos que utilizan :func:`itemgetter` para obtener campos específicos de "
"un registro tupla:"

#: ../Doc/library/operator.rst:356
msgid ""
"Return a callable object that calls the method *name* on its operand.  If "
"additional arguments and/or keyword arguments are given, they will be given "
"to the method as well.  For example:"
msgstr ""
"Retorna un objeto invocable que a su vez invoca al método *name* sobre su "
"operando. Si se pasan argumentos adicionales y/o argumentos por palabra "
"clave, estos serán a su vez pasados al método. Por ejemplo:"

#: ../Doc/library/operator.rst:360
msgid ""
"After ``f = methodcaller('name')``, the call ``f(b)`` returns ``b.name()``."
msgstr ""
"Después de ``f = methodcaller('name')``, la llamada ``f(b)`` retorna ``b."
"name()``."

#: ../Doc/library/operator.rst:362
msgid ""
"After ``f = methodcaller('name', 'foo', bar=1)``, the call ``f(b)`` returns "
"``b.name('foo', bar=1)``."
msgstr ""
"Después de ``f = methodcaller('name', 'foo', bar=1)``, la llamada ``f(b)`` "
"retorna ``b.name('foo', bar=1)``."

#: ../Doc/library/operator.rst:376
msgid "Mapping Operators to Functions"
msgstr "Asignación de operadores a funciones"

#: ../Doc/library/operator.rst:378
msgid ""
"This table shows how abstract operations correspond to operator symbols in "
"the Python syntax and the functions in the :mod:`operator` module."
msgstr ""
"Esta tabla muestra cómo operaciones abstractas se corresponden con "
"operadores simbólicos en la sintaxis de Python y las funciones en el módulo :"
"mod:`operator`."

#: ../Doc/library/operator.rst:382
msgid "Operation"
msgstr "Operación"

#: ../Doc/library/operator.rst:382
msgid "Syntax"
msgstr "Sintaxis"

#: ../Doc/library/operator.rst:382
msgid "Function"
msgstr "Función"

#: ../Doc/library/operator.rst:384
msgid "Addition"
msgstr "Adición"

#: ../Doc/library/operator.rst:384
msgid "``a + b``"
msgstr "``a + b``"

#: ../Doc/library/operator.rst:384
msgid "``add(a, b)``"
msgstr "``add(a, b)``"

#: ../Doc/library/operator.rst:386
msgid "Concatenation"
msgstr "Concatenación"

#: ../Doc/library/operator.rst:386
msgid "``seq1 + seq2``"
msgstr "``seq1 + seq2``"

#: ../Doc/library/operator.rst:386
msgid "``concat(seq1, seq2)``"
msgstr "``concat(seq1, seq2)``"

#: ../Doc/library/operator.rst:388
msgid "Containment Test"
msgstr "Chequeo de pertenencia"

#: ../Doc/library/operator.rst:388
msgid "``obj in seq``"
msgstr "``obj in seq``"

#: ../Doc/library/operator.rst:388
msgid "``contains(seq, obj)``"
msgstr "``contains(seq, obj)``"

#: ../Doc/library/operator.rst:390 ../Doc/library/operator.rst:392
msgid "Division"
msgstr "División"

#: ../Doc/library/operator.rst:390
msgid "``a / b``"
msgstr "``a / b``"

#: ../Doc/library/operator.rst:390
msgid "``truediv(a, b)``"
msgstr "``truediv(a, b)``"

#: ../Doc/library/operator.rst:392
msgid "``a // b``"
msgstr "``a // b``"

#: ../Doc/library/operator.rst:392
msgid "``floordiv(a, b)``"
msgstr "``floordiv(a, b)``"

#: ../Doc/library/operator.rst:394
msgid "Bitwise And"
msgstr "Conjunción lógica bit a bit (*bitwise and*)"

#: ../Doc/library/operator.rst:394
msgid "``a & b``"
msgstr "``a & b``"

#: ../Doc/library/operator.rst:394
msgid "``and_(a, b)``"
msgstr "``and_(a, b)``"

#: ../Doc/library/operator.rst:396
msgid "Bitwise Exclusive Or"
msgstr "Disyunción lógica bit a bit (*bitwise exclusive or*)"

#: ../Doc/library/operator.rst:396
msgid "``a ^ b``"
msgstr "``a ^ b``"

#: ../Doc/library/operator.rst:396
msgid "``xor(a, b)``"
msgstr "``xor(a, b)``"

#: ../Doc/library/operator.rst:398
msgid "Bitwise Inversion"
msgstr "Inversión bit a bit (*bitwise inversion*)"

#: ../Doc/library/operator.rst:398
msgid "``~ a``"
msgstr "``~ a``"

#: ../Doc/library/operator.rst:398
msgid "``invert(a)``"
msgstr "``invert(a)``"

#: ../Doc/library/operator.rst:400
msgid "Bitwise Or"
msgstr "Disyunción lógica bit a bit (*bitwise or*)"

#: ../Doc/library/operator.rst:400
msgid "``a | b``"
msgstr "``a | b``"

#: ../Doc/library/operator.rst:400
msgid "``or_(a, b)``"
msgstr "``or_(a, b)``"

#: ../Doc/library/operator.rst:402
msgid "Exponentiation"
msgstr "Exponenciación"

#: ../Doc/library/operator.rst:402
msgid "``a ** b``"
msgstr "``a ** b``"

#: ../Doc/library/operator.rst:402
msgid "``pow(a, b)``"
msgstr "``pow(a, b)``"

#: ../Doc/library/operator.rst:404 ../Doc/library/operator.rst:406
msgid "Identity"
msgstr "Identidad"

#: ../Doc/library/operator.rst:404
msgid "``a is b``"
msgstr "``a is b``"

#: ../Doc/library/operator.rst:404
msgid "``is_(a, b)``"
msgstr "``is_(a, b)``"

#: ../Doc/library/operator.rst:406
msgid "``a is not b``"
msgstr "``a is not b``"

#: ../Doc/library/operator.rst:406
msgid "``is_not(a, b)``"
msgstr "``is_not(a, b)``"

#: ../Doc/library/operator.rst:408
msgid "Indexed Assignment"
msgstr "Asignación indexada"

#: ../Doc/library/operator.rst:408
msgid "``obj[k] = v``"
msgstr "``obj[k] = v``"

#: ../Doc/library/operator.rst:408
msgid "``setitem(obj, k, v)``"
msgstr "``setitem(obj, k, v)``"

#: ../Doc/library/operator.rst:410
msgid "Indexed Deletion"
msgstr "Eliminación indexada"

#: ../Doc/library/operator.rst:410
msgid "``del obj[k]``"
msgstr "``del obj[k]``"

#: ../Doc/library/operator.rst:410
msgid "``delitem(obj, k)``"
msgstr "``delitem(obj, k)``"

#: ../Doc/library/operator.rst:412
msgid "Indexing"
msgstr "Indexado"

#: ../Doc/library/operator.rst:412
msgid "``obj[k]``"
msgstr "``obj[k]``"

#: ../Doc/library/operator.rst:412
msgid "``getitem(obj, k)``"
msgstr "``getitem(obj, k)``"

#: ../Doc/library/operator.rst:414
msgid "Left Shift"
msgstr "Desplazamiento a izquierda (*left shift*)"

#: ../Doc/library/operator.rst:414
msgid "``a << b``"
msgstr "``a << b``"

#: ../Doc/library/operator.rst:414
msgid "``lshift(a, b)``"
msgstr "``lshift(a, b)``"

#: ../Doc/library/operator.rst:416
msgid "Modulo"
msgstr "Módulo"

#: ../Doc/library/operator.rst:416
msgid "``a % b``"
msgstr "``a % b``"

#: ../Doc/library/operator.rst:416
msgid "``mod(a, b)``"
msgstr "``mod(a, b)``"

#: ../Doc/library/operator.rst:418
msgid "Multiplication"
msgstr "Multiplicación"

#: ../Doc/library/operator.rst:418
msgid "``a * b``"
msgstr "``a * b``"

#: ../Doc/library/operator.rst:418
msgid "``mul(a, b)``"
msgstr "``mul(a, b)``"

#: ../Doc/library/operator.rst:420
msgid "Matrix Multiplication"
msgstr "Multiplicación de matrices"

#: ../Doc/library/operator.rst:420
msgid "``a @ b``"
msgstr "``a @ b``"

#: ../Doc/library/operator.rst:420
msgid "``matmul(a, b)``"
msgstr "``matmul(a, b)``"

#: ../Doc/library/operator.rst:422
msgid "Negation (Arithmetic)"
msgstr "Negación (aritmética)"

#: ../Doc/library/operator.rst:422
msgid "``- a``"
msgstr "``- a``"

#: ../Doc/library/operator.rst:422
msgid "``neg(a)``"
msgstr "``neg(a)``"

#: ../Doc/library/operator.rst:424
msgid "Negation (Logical)"
msgstr "Negación (lógica)"

#: ../Doc/library/operator.rst:424
msgid "``not a``"
msgstr "``not a``"

#: ../Doc/library/operator.rst:424
msgid "``not_(a)``"
msgstr "``not_(a)``"

#: ../Doc/library/operator.rst:426
msgid "Positive"
msgstr "Positivo"

#: ../Doc/library/operator.rst:426
msgid "``+ a``"
msgstr "``+ a``"

#: ../Doc/library/operator.rst:426
msgid "``pos(a)``"
msgstr "``pos(a)``"

#: ../Doc/library/operator.rst:428
msgid "Right Shift"
msgstr "Desplazamiento a derecha (*right shift*)"

#: ../Doc/library/operator.rst:428
msgid "``a >> b``"
msgstr "``a >> b``"

#: ../Doc/library/operator.rst:428
msgid "``rshift(a, b)``"
msgstr "``rshift(a, b)``"

#: ../Doc/library/operator.rst:430
msgid "Slice Assignment"
msgstr "Asignación por segmento"

#: ../Doc/library/operator.rst:430
msgid "``seq[i:j] = values``"
msgstr "``seq[i:j] = values``"

#: ../Doc/library/operator.rst:430
msgid "``setitem(seq, slice(i, j), values)``"
msgstr "``setitem(seq, slice(i, j), values)``"

#: ../Doc/library/operator.rst:432
msgid "Slice Deletion"
msgstr "Eliminación por segmento"

#: ../Doc/library/operator.rst:432
msgid "``del seq[i:j]``"
msgstr "``del seq[i:j]``"

#: ../Doc/library/operator.rst:432
msgid "``delitem(seq, slice(i, j))``"
msgstr "``delitem(seq, slice(i, j))``"

#: ../Doc/library/operator.rst:434
msgid "Slicing"
msgstr "Segmentación"

#: ../Doc/library/operator.rst:434
msgid "``seq[i:j]``"
msgstr "``seq[i:j]``"

#: ../Doc/library/operator.rst:434
msgid "``getitem(seq, slice(i, j))``"
msgstr "``getitem(seq, slice(i, j))``"

#: ../Doc/library/operator.rst:436
msgid "String Formatting"
msgstr "Formateo de cadenas"

#: ../Doc/library/operator.rst:436
#, python-format
msgid "``s % obj``"
msgstr "``s % obj``"

#: ../Doc/library/operator.rst:436
msgid "``mod(s, obj)``"
msgstr "``mod(s, obj)``"

#: ../Doc/library/operator.rst:438
msgid "Subtraction"
msgstr "Sustracción"

#: ../Doc/library/operator.rst:438
msgid "``a - b``"
msgstr "``a - b``"

#: ../Doc/library/operator.rst:438
msgid "``sub(a, b)``"
msgstr "``sub(a, b)``"

#: ../Doc/library/operator.rst:440
msgid "Truth Test"
msgstr "Chequeo de verdad"

#: ../Doc/library/operator.rst:440
msgid "``obj``"
msgstr "``obj``"

#: ../Doc/library/operator.rst:440
msgid "``truth(obj)``"
msgstr "``truth(obj)``"

#: ../Doc/library/operator.rst:442 ../Doc/library/operator.rst:444
#: ../Doc/library/operator.rst:450 ../Doc/library/operator.rst:452
msgid "Ordering"
msgstr "Ordenado"

#: ../Doc/library/operator.rst:442
msgid "``a < b``"
msgstr "``a < b``"

#: ../Doc/library/operator.rst:442
msgid "``lt(a, b)``"
msgstr "``lt(a, b)``"

#: ../Doc/library/operator.rst:444
msgid "``a <= b``"
msgstr "``a <= b``"

#: ../Doc/library/operator.rst:444
msgid "``le(a, b)``"
msgstr "``le(a, b)``"

#: ../Doc/library/operator.rst:446
msgid "Equality"
msgstr "Igualdad"

#: ../Doc/library/operator.rst:446
msgid "``a == b``"
msgstr "``a == b``"

#: ../Doc/library/operator.rst:446
msgid "``eq(a, b)``"
msgstr "``eq(a, b)``"

#: ../Doc/library/operator.rst:448
msgid "Difference"
msgstr "Diferencia"

#: ../Doc/library/operator.rst:448
msgid "``a != b``"
msgstr "``a != b``"

#: ../Doc/library/operator.rst:448
msgid "``ne(a, b)``"
msgstr "``ne(a, b)``"

#: ../Doc/library/operator.rst:450
msgid "``a >= b``"
msgstr "``a >= b``"

#: ../Doc/library/operator.rst:450
msgid "``ge(a, b)``"
msgstr "``ge(a, b)``"

#: ../Doc/library/operator.rst:452
msgid "``a > b``"
msgstr "``a > b``"

#: ../Doc/library/operator.rst:452
msgid "``gt(a, b)``"
msgstr "``gt(a, b)``"

#: ../Doc/library/operator.rst:456
msgid "In-place Operators"
msgstr "Operadores *In-place*"

#: ../Doc/library/operator.rst:458
msgid ""
"Many operations have an \"in-place\" version.  Listed below are functions "
"providing a more primitive access to in-place operators than the usual "
"syntax does; for example, the :term:`statement` ``x += y`` is equivalent to "
"``x = operator.iadd(x, y)``.  Another way to put it is to say that ``z = "
"operator.iadd(x, y)`` is equivalent to the compound statement ``z = x; z += "
"y``."
msgstr ""
"Muchas operaciones tienen una versión *\"in-place\"*. Abajo se listan las "
"funciones que proveen un acceso más primitivo a operadores *in-place* que la "
"sintaxis usual; por ejemplo, el :term:`statement` ``x += y`` es equivalente "
"a ``x = operator.iadd(x, y)``. Otra forma de decirlo es que ``z = operator."
"iadd(x, y)`` es equivalente a la sentencia (*statement*) compuesta ``z = x; "
"z += y``."

#: ../Doc/library/operator.rst:465
msgid ""
"In those examples, note that when an in-place method is called, the "
"computation and assignment are performed in two separate steps.  The in-"
"place functions listed below only do the first step, calling the in-place "
"method.  The second step, assignment, is not handled."
msgstr ""
"En esos ejemplo, notar que cuando se invoca un método *in-place*, el cómputo "
"y la asignación se realizan en dos pasos separados. Las funciones *in-place* "
"que se listan aquí debajo solo hacen el primer paso, llamar al método *in-"
"place*. El segundo paso, la asignación, no se gestiona."

#: ../Doc/library/operator.rst:470
msgid ""
"For immutable targets such as strings, numbers, and tuples, the updated "
"value is computed, but not assigned back to the input variable:"
msgstr ""
"Para objetivos inmutables como cadenas de caracteres, números, y tuplas, el "
"valor actualizado es computado, pero no es asignado de nuevo a la variable "
"de entrada:"

#: ../Doc/library/operator.rst:479
msgid ""
"For mutable targets such as lists and dictionaries, the in-place method will "
"perform the update, so no subsequent assignment is necessary:"
msgstr ""
"Para objetivos mutables como listas y diccionarios, el método *in-place* "
"realiza la actualización, así que no es necesaria una asignación "
"subsiguiente:"

#: ../Doc/library/operator.rst:491
msgid "``a = iadd(a, b)`` is equivalent to ``a += b``."
msgstr "``a = iadd(a, b)`` es equivalente a ``a += b``."

#: ../Doc/library/operator.rst:497
msgid "``a = iand(a, b)`` is equivalent to ``a &= b``."
msgstr "``a = iand(a, b)`` es equivalente a ``a &= b``."

#: ../Doc/library/operator.rst:503
msgid ""
"``a = iconcat(a, b)`` is equivalent to ``a += b`` for *a* and *b* sequences."
msgstr ""
"``a = iconcat(a, b)`` es equivalente a ``a += b`` para dos *a* y *b* "
"secuencias."

#: ../Doc/library/operator.rst:509
msgid "``a = ifloordiv(a, b)`` is equivalent to ``a //= b``."
msgstr "``a = ifloordiv(a, b)`` es equivalente a ``a //= b``."

#: ../Doc/library/operator.rst:515
msgid "``a = ilshift(a, b)`` is equivalent to ``a <<= b``."
msgstr "``a = ilshift(a, b)`` es equivalente a ``a <<= b``."

#: ../Doc/library/operator.rst:521
msgid "``a = imod(a, b)`` is equivalent to ``a %= b``."
msgstr "``a = imod(a, b)`` es equivalente a ``a %= b``."

#: ../Doc/library/operator.rst:527
msgid "``a = imul(a, b)`` is equivalent to ``a *= b``."
msgstr "``a = imul(a, b)`` es equivalente a ``a *= b``."

#: ../Doc/library/operator.rst:533
msgid "``a = imatmul(a, b)`` is equivalent to ``a @= b``."
msgstr "``a = imul(a, b)`` es equivalente a ``a *= b``."

#: ../Doc/library/operator.rst:541
msgid "``a = ior(a, b)`` is equivalent to ``a |= b``."
msgstr "``a = ior(a, b)`` es equivalente a ``a |= b``."

#: ../Doc/library/operator.rst:547
msgid "``a = ipow(a, b)`` is equivalent to ``a **= b``."
msgstr "``a = ipow(a, b)`` es equivalente a ``a **= b``."

#: ../Doc/library/operator.rst:553
msgid "``a = irshift(a, b)`` is equivalent to ``a >>= b``."
msgstr "``a = irshift(a, b)`` es equivalente a ``a >>= b``."

#: ../Doc/library/operator.rst:559
msgid "``a = isub(a, b)`` is equivalent to ``a -= b``."
msgstr "``a = isub(a, b)`` es equivalente a ``a -= b``."

#: ../Doc/library/operator.rst:565
msgid "``a = itruediv(a, b)`` is equivalent to ``a /= b``."
msgstr "``a = itruediv(a, b)`` es equivalente a ``a /= b``."

#: ../Doc/library/operator.rst:571
msgid "``a = ixor(a, b)`` is equivalent to ``a ^= b``."
msgstr "``a = ixor(a, b)`` es equivalente a ``a ^= b``."