re.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-01-04 17:03-0300\n"
"Last-Translator: Francisco Mora <fr.morac@duocuc.cl>\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/re.rst:2
msgid ":mod:`re` --- Regular expression operations"
msgstr ":mod:`re` --- Operaciones con expresiones regulares"

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

#: ../Doc/library/re.rst:14
msgid ""
"This module provides regular expression matching operations similar to those "
"found in Perl."
msgstr ""
"Este módulo proporciona operaciones de coincidencia de expresiones regulares "
"similares a las encontradas en Perl."

#: ../Doc/library/re.rst:17
msgid ""
"Both patterns and strings to be searched can be Unicode strings (:class:"
"`str`) as well as 8-bit strings (:class:`bytes`). However, Unicode strings "
"and 8-bit strings cannot be mixed: that is, you cannot match a Unicode "
"string with a byte pattern or vice-versa; similarly, when asking for a "
"substitution, the replacement string must be of the same type as both the "
"pattern and the search string."
msgstr ""
"Tanto los patrones como las cadenas de texto a buscar pueden ser cadenas de "
"Unicode (:class:`str`) así como cadenas de 8 bits (:class:`bytes`). Sin "
"embargo, las cadenas Unicode y las cadenas de 8 bits no se pueden mezclar: "
"es decir, no se puede hacer coincidir una cadena Unicode con un patrón de "
"bytes o viceversa; del mismo modo, al pedir una sustitución, la cadena de "
"sustitución debe ser del mismo tipo que el patrón y la cadena de búsqueda."

#: ../Doc/library/re.rst:24
msgid ""
"Regular expressions use the backslash character (``'\\'``) to indicate "
"special forms or to allow special characters to be used without invoking "
"their special meaning.  This collides with Python's usage of the same "
"character for the same purpose in string literals; for example, to match a "
"literal backslash, one might have to write ``'\\\\\\\\'`` as the pattern "
"string, because the regular expression must be ``\\\\``, and each backslash "
"must be expressed as ``\\\\`` inside a regular Python string literal. Also, "
"please note that any invalid escape sequences in Python's usage of the "
"backslash in string literals now generate a :exc:`SyntaxWarning` and in the "
"future this will become a :exc:`SyntaxError`. This behaviour will happen "
"even if it is a valid escape sequence for a regular expression."
msgstr ""
"Las expresiones regulares usan el carácter de barra inversa (``'\\'``) para "
"indicar formas especiales o para permitir el uso de caracteres especiales "
"sin invocar su significado especial.  Esto choca con el uso de Python de "
"este carácter para el mismo propósito con los literales de cadena; por "
"ejemplo, para hacer coincidir una barra inversa literal, se podría escribir "
"``'\\\\\\\\'`` como patrón, porque la expresión regular debe ser ``\\\\``, y "
"cada barra inversa debe ser expresada como ``\\\\`` dentro de un literal de "
"cadena regular de Python.  También, notar que cualquier secuencia de escape "
"inválida mientras se use la barra inversa de Python en los literales de "
"cadena ahora genera un :exc:`SyntaxWarning` y en el futuro esto se "
"convertirá en un :exc:`SyntaxError`.  Este comportamiento ocurrirá incluso "
"si es una secuencia de escape válida para una expresión regular."

#: ../Doc/library/re.rst:36
msgid ""
"The solution is to use Python's raw string notation for regular expression "
"patterns; backslashes are not handled in any special way in a string literal "
"prefixed with ``'r'``.  So ``r\"\\n\"`` is a two-character string containing "
"``'\\'`` and ``'n'``, while ``\"\\n\"`` is a one-character string containing "
"a newline.  Usually patterns will be expressed in Python code using this raw "
"string notation."
msgstr ""
"La solución es usar la notación de cadena *raw* de Python para los patrones "
"de expresiones regulares; las barras inversas no se manejan de ninguna "
"manera especial en un literal de cadena prefijado con ``'r'``.  Así que "
"``r\"\\n\"`` es una cadena de dos caracteres que contiene ``'\\'`` y "
"``'n'``, mientras que ``\"\\n\"`` es una cadena de un carácter que contiene "
"una nueva línea.  Normalmente los patrones se expresan en código Python "
"usando esta notación de cadena *raw*."

#: ../Doc/library/re.rst:43
msgid ""
"It is important to note that most regular expression operations are "
"available as module-level functions and methods on :ref:`compiled regular "
"expressions <re-objects>`.  The functions are shortcuts that don't require "
"you to compile a regex object first, but miss some fine-tuning parameters."
msgstr ""
"Es importante señalar que la mayoría de las operaciones de expresiones "
"regulares están disponibles como funciones y métodos a nivel de módulo en :"
"ref:`expresiones regulares compiladas <re-objects>` (expresiones regulares "
"compiladas).  Las funciones son atajos que no requieren de compilar un "
"objeto regex primero, aunque pasan por alto algunos parámetros de ajuste."

#: ../Doc/library/re.rst:51
msgid ""
"The third-party `regex <https://pypi.org/project/regex/>`_ module, which has "
"an API compatible with the standard library :mod:`re` module, but offers "
"additional functionality and a more thorough Unicode support."
msgstr ""
"El módulo de terceros `regex <https://pypi.org/project/regex/>`_ , cuenta "
"con una API compatible con el módulo de la biblioteca estándar :mod:`re`, el "
"cual ofrece una funcionalidad adicional y un soporte Unicode más completo."

#: ../Doc/library/re.rst:59
msgid "Regular Expression Syntax"
msgstr "Sintaxis de expresiones regulares"

#: ../Doc/library/re.rst:61
msgid ""
"A regular expression (or RE) specifies a set of strings that matches it; the "
"functions in this module let you check if a particular string matches a "
"given regular expression (or if a given regular expression matches a "
"particular string, which comes down to the same thing)."
msgstr ""
"Una expresión regular (o RE, por sus siglas en inglés) especifica un "
"conjunto de cadenas que coinciden con ella; las funciones de este módulo "
"permiten comprobar si una determinada cadena coincide con una expresión "
"regular dada (o si una expresión regular dada coincide con una determinada "
"cadena, que se reduce a lo mismo)."

#: ../Doc/library/re.rst:66
msgid ""
"Regular expressions can be concatenated to form new regular expressions; if "
"*A* and *B* are both regular expressions, then *AB* is also a regular "
"expression. In general, if a string *p* matches *A* and another string *q* "
"matches *B*, the string *pq* will match AB.  This holds unless *A* or *B* "
"contain low precedence operations; boundary conditions between *A* and *B*; "
"or have numbered group references.  Thus, complex expressions can easily be "
"constructed from simpler primitive expressions like the ones described "
"here.  For details of the theory and implementation of regular expressions, "
"consult the Friedl book [Frie09]_, or almost any textbook about compiler "
"construction."
msgstr ""
"Las expresiones regulares pueden ser concatenadas para formar nuevas "
"expresiones regulares; si *A* y *B* son ambas expresiones regulares, "
"entonces *AB* es también una expresión regular. En general, si una cadena "
"*p* coincide con *A* y otra cadena *q* coincide con *B*, la cadena *porque* "
"coincidirá con AB.  Esto se mantiene a menos que *A* o *B* contengan "
"operaciones de baja precedencia; condiciones límite entre *A* y *B*; o "
"tengan referencias de grupo numeradas.  Así, las expresiones complejas "
"pueden construirse fácilmente a partir de expresiones primitivas más simples "
"como las que se describen aquí.  Para detalles de la teoría e implementación "
"de las expresiones regulares, consulte el libro de Friedl [Frie09]_, o casi "
"cualquier libro de texto sobre la construcción de compiladores."

#: ../Doc/library/re.rst:76
msgid ""
"A brief explanation of the format of regular expressions follows.  For "
"further information and a gentler presentation, consult the :ref:`regex-"
"howto`."
msgstr ""
"A continuación se explica brevemente el formato de las expresiones "
"regulares.  Para más información y una presentación más amena, consultar la :"
"ref:`regex-howto`."

#: ../Doc/library/re.rst:79
msgid ""
"Regular expressions can contain both special and ordinary characters. Most "
"ordinary characters, like ``'A'``, ``'a'``, or ``'0'``, are the simplest "
"regular expressions; they simply match themselves.  You can concatenate "
"ordinary characters, so ``last`` matches the string ``'last'``.  (In the "
"rest of this section, we'll write RE's in ``this special style``, usually "
"without quotes, and strings to be matched ``'in single quotes'``.)"
msgstr ""
"Las expresiones regulares pueden contener tanto caracteres especiales como "
"ordinarios. La mayoría de los caracteres ordinarios, como ``'A'``, ``'a'``, "
"o ``'0'`` son las expresiones regulares más sencillas; simplemente se "
"ajustan a sí mismas.  Se pueden concatenar caracteres ordinarios, así que "
"``last`` coincide con la cadena ``'last'``.  (En el resto de esta sección, "
"se escribirán los RE en ``este estilo especial``, normalmente sin comillas, "
"y las cadenas que deban coincidir ``'entre comillas simples'``.)"

#: ../Doc/library/re.rst:86
msgid ""
"Some characters, like ``'|'`` or ``'('``, are special. Special characters "
"either stand for classes of ordinary characters, or affect how the regular "
"expressions around them are interpreted."
msgstr ""
"Algunos caracteres, como ``'|'`` o ``'('``, son especiales. Los caracteres "
"especiales representan clases de caracteres ordinarios, o afectan a la forma "
"en que se interpretan las expresiones regulares que los rodean."

#: ../Doc/library/re.rst:90
msgid ""
"Repetition operators or quantifiers (``*``, ``+``, ``?``, ``{m,n}``, etc) "
"cannot be directly nested. This avoids ambiguity with the non-greedy "
"modifier suffix ``?``, and with other modifiers in other implementations. To "
"apply a second repetition to an inner repetition, parentheses may be used. "
"For example, the expression ``(?:a{6})*`` matches any multiple of six "
"``'a'`` characters."
msgstr ""
"Los operadores de repetición o cuantificadores (``*``, ``+``, ``?``, ``{m,n}"
"``, etc.) no pueden ser anidados directamente. Esto evita la ambigüedad con "
"el sufijo modificador no codicioso ``?``, y con otros modificadores en otras "
"implementaciones. Para aplicar una segunda repetición a una repetición "
"interna, se pueden usar paréntesis. Por ejemplo, la expresión ``(?:a{6})*`` "
"coincide con cualquier múltiplo de seis caracteres ``'a'``."

#: ../Doc/library/re.rst:97
msgid "The special characters are:"
msgstr "Los caracteres especiales son:"

#: ../Doc/library/re.rst:104 ../Doc/library/re.rst:1552
msgid "``.``"
msgstr "``.``"

#: ../Doc/library/re.rst:102
msgid ""
"(Dot.)  In the default mode, this matches any character except a newline.  "
"If the :const:`DOTALL` flag has been specified, this matches any character "
"including a newline."
msgstr ""
"(Punto.) En el modo predeterminado, esto coincide con cualquier carácter "
"excepto con una nueva línea.  Si se ha especificado el indicador :const:"
"`DOTALL`, esto coincide con cualquier carácter que incluya una nueva línea."

#: ../Doc/library/re.rst:110
msgid "``^``"
msgstr "``^``"

#: ../Doc/library/re.rst:109
msgid ""
"(Caret.)  Matches the start of the string, and in :const:`MULTILINE` mode "
"also matches immediately after each newline."
msgstr ""
"(Circunflejo.)  Coincide con el comienzo de la cadena, y en modo :const:"
"`MULTILINE` también coincide inmediatamente después de cada nueva línea."

#: ../Doc/library/re.rst:121
msgid "``$``"
msgstr "``$``"

#: ../Doc/library/re.rst:115
msgid ""
"Matches the end of the string or just before the newline at the end of the "
"string, and in :const:`MULTILINE` mode also matches before a newline.  "
"``foo`` matches both 'foo' and 'foobar', while the regular expression "
"``foo$`` matches only 'foo'.  More interestingly, searching for ``foo.$`` in "
"``'foo1\\nfoo2\\n'`` matches 'foo2' normally, but 'foo1' in :const:"
"`MULTILINE` mode; searching for a single ``$`` in ``'foo\\n'`` will find two "
"(empty) matches: one just before the newline, and one at the end of the "
"string."
msgstr ""
"Coincide con el final de la cadena o justo antes de la nueva línea al final "
"de la cadena, y en modo :const:`MULTILINE` también coincide antes de una "
"nueva línea.  ``foo`` coincide con 'foo' y 'foobar', mientras que la "
"expresión regular ``foo$`` sólo coincide con 'foo'.  Más interesante aún, al "
"buscar ``foo.$`` en ``'foo1\\nfoo2\\n'`` coincide con 'foo2' normalmente, "
"pero solo 'foo1' en :const:`MULTILINE``; si busca un solo ``$`` en "
"``'foo\\n'`` encontrará dos coincidencias (vacías): una justo antes de una "
"nueva línea, y otra al final de la cadena."

#: ../Doc/library/re.rst:128
msgid "``*``"
msgstr "``*``"

#: ../Doc/library/re.rst:126
msgid ""
"Causes the resulting RE to match 0 or more repetitions of the preceding RE, "
"as many repetitions as are possible.  ``ab*`` will match 'a', 'ab', or 'a' "
"followed by any number of 'b's."
msgstr ""
"Hace que el RE resultante coincida con 0 o más repeticiones del RE "
"precedente, tantas repeticiones como sean posibles.  ``ab*`` coincidirá con "
"'a', 'ab' o 'a' seguido de cualquier número de 'b'."

#: ../Doc/library/re.rst:135
msgid "``+``"
msgstr "``+``"

#: ../Doc/library/re.rst:133
msgid ""
"Causes the resulting RE to match 1 or more repetitions of the preceding RE. "
"``ab+`` will match 'a' followed by any non-zero number of 'b's; it will not "
"match just 'a'."
msgstr ""
"Hace que la RE resultante coincida con 1 o más repeticiones de la RE "
"precedente. ``ab+`` coincidirá con 'a' seguido de cualquier número distinto "
"de cero de 'b'; no coincidirá solo con 'a'."

#: ../Doc/library/re.rst:141
msgid "``?``"
msgstr "``?``"

#: ../Doc/library/re.rst:140
msgid ""
"Causes the resulting RE to match 0 or 1 repetitions of the preceding RE. "
"``ab?`` will match either 'a' or 'ab'."
msgstr ""
"Hace que la RE resultante coincida con 0 o 1 repeticiones de la RE "
"precedente. ``ab?`` coincidirá con 'a' o 'ab'."

#: ../Doc/library/re.rst:155
msgid "``*?``, ``+?``, ``??``"
msgstr "``*?``, ``+?``, ``??``"

#: ../Doc/library/re.rst:149
msgid ""
"The ``'*'``, ``'+'``, and ``'?'`` quantifiers are all :dfn:`greedy`; they "
"match as much text as possible.  Sometimes this behaviour isn't desired; if "
"the RE ``<.*>`` is matched against ``'<a> b <c>'``, it will match the entire "
"string, and not just ``'<a>'``.  Adding ``?`` after the quantifier makes it "
"perform the match in :dfn:`non-greedy` or :dfn:`minimal` fashion; as *few* "
"characters as possible will be matched.  Using the RE ``<.*?>`` will match "
"only ``'<a>'``."
msgstr ""
"Los delimitadores ``'*'``, ``'+'``, y ``'?'`` son todos :dfn:`greedy`; "
"coinciden con la mayor cantidad de texto posible.  A veces este "
"comportamiento no es deseado; si el RE ``<.*>`` se utiliza para coincidir "
"con ``'<a> b <c>'``, coincidirá con toda la cadena, y no sólo con "
"``'<a>'``.  Añadiendo ``?`` después del delimitador hace que se realice la "
"coincidencia de manera :dfn:`non-greedy` o :dfn:`minimal`; coincidirá la "
"*mínima* cantidad de caracteres como sea posible.  Usando el RE ``<.*?>`` "
"sólo coincidirá con ``'<a>'``."

#: ../Doc/library/re.rst:179
msgid "``*+``, ``++``, ``?+``"
msgstr "``*+``, ``++``, ``?+``"

#: ../Doc/library/re.rst:163
msgid ""
"Like the ``'*'``, ``'+'``, and ``'?'`` quantifiers, those where ``'+'`` is "
"appended also match as many times as possible. However, unlike the true "
"greedy quantifiers, these do not allow back-tracking when the expression "
"following it fails to match. These are known as :dfn:`possessive` "
"quantifiers. For example, ``a*a`` will match ``'aaaa'`` because the ``a*`` "
"will match all 4 ``'a'``\\ s, but, when the final ``'a'`` is encountered, "
"the expression is backtracked so that in the end the ``a*`` ends up matching "
"3 ``'a'``\\ s total, and the fourth ``'a'`` is matched by the final ``'a'``. "
"However, when ``a*+a`` is used to match ``'aaaa'``, the ``a*+`` will match "
"all 4 ``'a'``, but when the final ``'a'`` fails to find any more characters "
"to match, the expression cannot be backtracked and will thus fail to match. "
"``x*+``, ``x++`` and ``x?+`` are equivalent to ``(?>x*)``, ``(?>x+)`` and "
"``(?>x?)`` correspondingly."
msgstr ""
"Como los cuantificadores ``'*'``, ``'+'``, y ``'?'`` , aquellos en los que "
"se agrega ``'+'`` también coinciden tantas veces como sea posible. Sin "
"embargo, a diferencia de los verdaderos cuantificadores codiciosos, estos no "
"permiten retroceder cuando la expresión que le sigue no coincide. Estos se "
"conocen como cuantificadores :dfn:`possessive`. Por ejemplo, ``a*a`` "
"coincidirá con ``'aaaa'`` porque la ``a*`` coincidirá con los 4 ``'a'``\\ s, "
"pero, cuando se encuentra la ``'a'`` final, la expresión retrocede de modo "
"que al final la ``a*`` termina coincidiendo con 3 ``'a'``\\ s total, y la "
"cuarta ``'a'`` coincide con la final ``'a'``. Sin embargo, cuando ``a*+a`` "
"se usa para que coincida con ``'aaaa'``, el ``a*+`` coincidirá con los 4 "
"``'a'``, pero cuando el ``'a'`` final no encuentra más caracteres para "
"coincidir, la expresión no puede retroceder y, por lo tanto, no coincidirá. "
"``x*+``, ``x++`` and ``x?+`` son equivalentes a ``(?>x*)``, ``(?>x+)`` and "
"``(?>x?)`` correspondientemente."

#: ../Doc/library/re.rst:187
msgid "``{m}``"
msgstr "``{m}``"

#: ../Doc/library/re.rst:185
msgid ""
"Specifies that exactly *m* copies of the previous RE should be matched; "
"fewer matches cause the entire RE not to match.  For example, ``a{6}`` will "
"match exactly six ``'a'`` characters, but not five."
msgstr ""
"Especifica que exactamente *m* copias de la RE anterior deben coincidir; "
"menos coincidencias hacen que la RE entera no coincida.  Por ejemplo, ``a{6}"
"`` coincidirá exactamente con seis caracteres ``'a'``, pero no con cinco."

#: ../Doc/library/re.rst:196
msgid "``{m,n}``"
msgstr "``{m,n}``"

#: ../Doc/library/re.rst:190
msgid ""
"Causes the resulting RE to match from *m* to *n* repetitions of the "
"preceding RE, attempting to match as many repetitions as possible.  For "
"example, ``a{3,5}`` will match from 3 to 5 ``'a'`` characters.  Omitting *m* "
"specifies a lower bound of zero,  and omitting *n* specifies an infinite "
"upper bound.  As an example, ``a{4,}b`` will match ``'aaaab'`` or a thousand "
"``'a'`` characters followed by a ``'b'``, but not ``'aaab'``. The comma may "
"not be omitted or the modifier would be confused with the previously "
"described form."
msgstr ""
"Hace que el RE resultante coincida de *m* a *n* repeticiones del RE "
"precedente, tratando de coincidir con el mayor número de repeticiones "
"posible.  Por ejemplo, ``a{3,5}`` coincidirá de 3 a 5 caracteres ``'a'``.  "
"Omitiendo *m* se especifica un límite inferior de cero, y omitiendo *n* se "
"especifica un límite superior infinito.  Por ejemplo, ``a{4,}b`` coincidirá "
"con ``'aaaab'`` o mil caracteres ``'a'`` seguidos de una ``'b'``, pero no "
"``'aaab'``. La coma no puede ser omitida o el modificador se confundiría con "
"la forma descrita anteriormente."

#: ../Doc/library/re.rst:203
msgid "``{m,n}?``"
msgstr "``{m,n}?``"

#: ../Doc/library/re.rst:199
msgid ""
"Causes the resulting RE to match from *m* to *n* repetitions of the "
"preceding RE, attempting to match as *few* repetitions as possible.  This is "
"the non-greedy version of the previous quantifier.  For example, on the 6-"
"character string ``'aaaaaa'``, ``a{3,5}`` will match 5 ``'a'`` characters, "
"while ``a{3,5}?`` will only match 3 characters."
msgstr ""
"Hace que el RE resultante coincida de *m* a *n* repeticiones del RE "
"precedente, tratando de coincidir con el *mínimo de* repeticiones posible.  "
"Esta es la versión *non-greedy* (no codiciosa) del delimitador anterior.  "
"Por ejemplo, en la cadena de 6 caracteres ``'aaaaaa'``, ``a{3,5}`` "
"coincidirá con 5 caracteres ``'a'``, mientras que ``a{3,5}?`` solo "
"coincidirá con 3 caracteres."

#: ../Doc/library/re.rst:218
msgid "``{m,n}+``"
msgstr "``{m,n}+``"

#: ../Doc/library/re.rst:206
msgid ""
"Causes the resulting RE to match from *m* to *n* repetitions of the "
"preceding RE, attempting to match as many repetitions as possible *without* "
"establishing any backtracking points. This is the possessive version of the "
"quantifier above. For example, on the 6-character string ``'aaaaaa'``, "
"``a{3,5}+aa`` attempt to match 5 ``'a'`` characters, then, requiring 2 more "
"``'a'``\\ s, will need more characters than available and thus fail, while "
"``a{3,5}aa`` will match with ``a{3,5}`` capturing 5, then 4 ``'a'``\\ s by "
"backtracking and then the final 2 ``'a'``\\ s are matched by the final "
"``aa`` in the pattern. ``x{m,n}+`` is equivalent to ``(?>x{m,n})``."
msgstr ""
"Hace que el RE resultante coincida de *m* a *n* repeticiones del RE "
"anterior, intentando hacer coincidir tantas repeticiones como sea posible "
"*sin* establecer ningún punto de retroceso. Esta es la versión posesiva del "
"cuantificador anterior. Por ejemplo, en la cadena de 6 caracteres "
"``'aaaaaa'``, ``a{3,5}+aa`` intenta hacer coincidir 5 caracteres ``'a'``, "
"entonces, al requerir 2 más ``'a'``\\ s, necesitará más caracteres de los "
"disponibles y, por lo tanto, fallará, mientras que ``a{3,5}aa`` coincidirá "
"con ``a{3,5}`` capturando 5, luego 4 ``'a'``\\ s por retroceso y luego los "
"últimos 2 ``'a'``\\ s son emparejados por el ``aa`` final en el patrón. "
"``x{m,n}+`` es equivalente a ``(?>x{m,n})``."

#: ../Doc/library/re.rst:233
msgid "``\\``"
msgstr "``\\``"

#: ../Doc/library/re.rst:223
msgid ""
"Either escapes special characters (permitting you to match characters like "
"``'*'``, ``'?'``, and so forth), or signals a special sequence; special "
"sequences are discussed below."
msgstr ""
"O bien se escapan a los caracteres especiales (lo que le permite hacer "
"coincidir caracteres como ``'*'``, ``'?'``, y así sucesivamente), o se "
"señala una secuencia especial; las secuencias especiales se explican más "
"adelante."

#: ../Doc/library/re.rst:227
msgid ""
"If you're not using a raw string to express the pattern, remember that "
"Python also uses the backslash as an escape sequence in string literals; if "
"the escape sequence isn't recognized by Python's parser, the backslash and "
"subsequent character are included in the resulting string.  However, if "
"Python would recognize the resulting sequence, the backslash should be "
"repeated twice.  This is complicated and hard to understand, so it's highly "
"recommended that you use raw strings for all but the simplest expressions."
msgstr ""
"Si no se utiliza una cadena *raw* para expresar el patrón, recuerde que "
"Python también utiliza la barra inversa como secuencia de escape en los "
"literales de la cadena; si el analizador sintáctico de Python no reconoce la "
"secuencia de escape, la barra inversa y el carácter subsiguiente se incluyen "
"en la cadena resultante.  Sin embargo, si Python quisiera reconocer la "
"secuencia resultante, la barra inversa debería repetirse dos veces.  Esto es "
"complicado y difícil de entender, por lo que se recomienda encarecidamente "
"utilizar cadenas *raw* para todas las expresiones salvo las más simples."

#: ../Doc/library/re.rst:294
msgid "``[]``"
msgstr "``[]``"

#: ../Doc/library/re.rst:239
msgid "Used to indicate a set of characters.  In a set:"
msgstr "Se utiliza para indicar un conjunto de caracteres.  En un conjunto:"

#: ../Doc/library/re.rst:241
msgid ""
"Characters can be listed individually, e.g. ``[amk]`` will match ``'a'``, "
"``'m'``, or ``'k'``."
msgstr ""
"Los caracteres pueden ser listados individualmente, ej. ``[amk]`` coincidirá "
"con ``'a'``, ``'m'``, o ``'k'``."

#: ../Doc/library/re.rst:246
msgid ""
"Ranges of characters can be indicated by giving two characters and "
"separating them by a ``'-'``, for example ``[a-z]`` will match any lowercase "
"ASCII letter, ``[0-5][0-9]`` will match all the two-digits numbers from "
"``00`` to ``59``, and ``[0-9A-Fa-f]`` will match any hexadecimal digit.  If "
"``-`` is escaped (e.g. ``[a\\-z]``) or if it's placed as the first or last "
"character (e.g. ``[-a]`` or ``[a-]``), it will match a literal ``'-'``."
msgstr ""
"Los rangos de caracteres se pueden indicar mediante dos caracteres y "
"separándolos con un ``'-'``. Por ejemplo, ``[a-z]`` coincidirá con cualquier "
"letra ASCII en minúscula, ``[0-5][0-9]`` coincidirá con todos los números de "
"dos dígitos desde el ``00`` hasta el ``59``, y ``[0-9A-Fa-f]`` coincidirá "
"con cualquier dígito hexadecimal.  Si se escapa ``-`` (por ejemplo, ``[a\\-"
"z]``) o si se coloca como el primer o el último carácter (por ejemplo, ``[-"
"a]`` o ``[a-]``), coincidirá con un literal ``'-'``."

#: ../Doc/library/re.rst:253
msgid ""
"Special characters lose their special meaning inside sets.  For example, "
"``[(+*)]`` will match any of the literal characters ``'('``, ``'+'``, "
"``'*'``, or ``')'``."
msgstr ""
"Los caracteres especiales pierden su significado especial dentro de los "
"sets.  Por ejemplo, ``[(+*)]`` coincidirá con cualquiera de los caracteres "
"literales ``'('``, ``'+'``, ``'*'``, o ``')'``."

#: ../Doc/library/re.rst:259
msgid ""
"Character classes such as ``\\w`` or ``\\S`` (defined below) are also "
"accepted inside a set, although the characters they match depends on "
"whether :const:`ASCII` or :const:`LOCALE` mode is in force."
msgstr ""
"Las clases de caracteres como ``\\w`` o ``\\S`` (definidas más adelante) "
"también se aceptan dentro de un conjunto, aunque los caracteres que "
"coinciden dependen de si el modo :const:`ASCII` o :const:`LOCALE` está "
"activo."

#: ../Doc/library/re.rst:265
msgid ""
"Characters that are not within a range can be matched by :dfn:"
"`complementing` the set.  If the first character of the set is ``'^'``, all "
"the characters that are *not* in the set will be matched.  For example, "
"``[^5]`` will match any character except ``'5'``, and ``[^^]`` will match "
"any character except ``'^'``.  ``^`` has no special meaning if it's not the "
"first character in the set."
msgstr ""
"Los caracteres que no están dentro de un rango pueden ser coincidentes con :"
"dfn:`complementing` el conjunto. Si el primer carácter del conjunto es "
"``'^'``, todos los caracteres que *no* están en el conjunto coincidirán. Por "
"ejemplo, ``[^5]`` coincidirá con cualquier carácter excepto con ``'5'``, y "
"``[^^]`` coincidirá con cualquier carácter excepto con ``'^'``. ``^`` no "
"tiene un significado especial si no es el primer carácter del conjunto."

#: ../Doc/library/re.rst:272
msgid ""
"To match a literal ``']'`` inside a set, precede it with a backslash, or "
"place it at the beginning of the set.  For example, both ``[()[\\]{}]`` and "
"``[]()[{}]`` will match a right bracket, as well as left bracket, braces, "
"and parentheses."
msgstr ""
"Para coincidir con un ``']'`` literal dentro de un set, se debe preceder con "
"una barra inversa, o colocarlo al principio del set. Por ejemplo, tanto ``[()"
"[\\]{}]`` como ``[]()[{}]`` coincidirá con los paréntesis, corchetes y "
"llaves."

#: ../Doc/library/re.rst:282
msgid ""
"Support of nested sets and set operations as in `Unicode Technical Standard "
"#18`_ might be added in the future.  This would change the syntax, so to "
"facilitate this change a :exc:`FutureWarning` will be raised in ambiguous "
"cases for the time being. That includes sets starting with a literal ``'['`` "
"or containing literal character sequences ``'--'``, ``'&&'``, ``'~~'``, and "
"``'||'``.  To avoid a warning escape them with a backslash."
msgstr ""
"El soporte de conjuntos anidados y operaciones de conjuntos como en `Unicode "
"Technical Standard #18`_ podría ser añadido en el futuro. Esto cambiaría la "
"sintaxis, así que por el momento se planteará un :exc:`FutureWarning` en "
"casos ambiguos para facilitar este cambio. Ello incluye conjuntos que "
"empiecen con un literal ``'['`` o que contengan secuencias de caracteres "
"literales ``'—'``, ``'&&'``, ``'~~'`` y ``'||'``. Para evitar una "
"advertencia, utilizar el código de escape con una barra inversa."

#: ../Doc/library/re.rst:292
msgid ""
":exc:`FutureWarning` is raised if a character set contains constructs that "
"will change semantically in the future."
msgstr ""
":exc:`FutureWarning` se genera si un conjunto de caracteres contiene "
"construcciones que cambiarán semánticamente en el futuro."

#: ../Doc/library/re.rst:307
msgid "``|``"
msgstr "``|``"

#: ../Doc/library/re.rst:299
msgid ""
"``A|B``, where *A* and *B* can be arbitrary REs, creates a regular "
"expression that will match either *A* or *B*.  An arbitrary number of REs "
"can be separated by the ``'|'`` in this way.  This can be used inside groups "
"(see below) as well.  As the target string is scanned, REs separated by "
"``'|'`` are tried from left to right. When one pattern completely matches, "
"that branch is accepted. This means that once *A* matches, *B* will not be "
"tested further, even if it would produce a longer overall match.  In other "
"words, the ``'|'`` operator is never greedy.  To match a literal ``'|'``, "
"use ``\\|``, or enclose it inside a character class, as in ``[|]``."
msgstr ""
"``A|B``, donde *A* y *B* pueden ser RE arbitrarias, crea una expresión "
"regular que coincidirá con *A* or *B*. Un número arbitrario de RE puede ser "
"separado por ``'|'`` de esta manera. Esto puede también ser usado dentro de "
"grupos (ver más adelante). Cuando la cadena de destino es procesada, los RE "
"separados por ``'|'`` son probados de izquierda a derecha. Cuando un patrón "
"coincide completamente, esa rama es aceptada. Esto significa que una vez que "
"*A* coincida, *B* no se comprobará más, incluso si se produce una "
"coincidencia general más larga. En otras palabras, el operador de ``'|'`` "
"nunca es codicioso. Para emparejar un literal ``'|'``, se usa ``\\|``, o se "
"envuelve dentro de una clase de caracteres, como en ``[|]``."

#: ../Doc/library/re.rst:317
msgid "``(...)``"
msgstr "``(...)``"

#: ../Doc/library/re.rst:313
msgid ""
"Matches whatever regular expression is inside the parentheses, and indicates "
"the start and end of a group; the contents of a group can be retrieved after "
"a match has been performed, and can be matched later in the string with the "
"``\\number`` special sequence, described below.  To match the literals "
"``'('`` or ``')'``, use ``\\(`` or ``\\)``, or enclose them inside a "
"character class: ``[(]``, ``[)]``."
msgstr ""
"Coincide con cualquier expresión regular que esté dentro de los paréntesis, "
"e indica el comienzo y el final de un grupo; el contenido de un grupo puede "
"ser recuperado después de que se haya realizado una coincidencia, y puede "
"coincidir más adelante en la cadena con la secuencia especial ``\\number``, "
"que se describe más adelante. Para hacer coincidir los literales ```'('`` o "
"``')'``, se usa ``\\(`` o ``\\)``, o se envuelve dentro de una clase de "
"caracteres: ``[(]``, ``[)]``."

#: ../Doc/library/re.rst:326
msgid "``(?...)``"
msgstr "``(?...)``"

#: ../Doc/library/re.rst:322
msgid ""
"This is an extension notation (a ``'?'`` following a ``'('`` is not "
"meaningful otherwise).  The first character after the ``'?'`` determines "
"what the meaning and further syntax of the construct is. Extensions usually "
"do not create a new group; ``(?P<name>...)`` is the only exception to this "
"rule. Following are the currently supported extensions."
msgstr ""
"Esta es una notación de extensión (un ``'?'`` después de un ``'('`` no tiene "
"ningún otro significado). El primer carácter después de ``'?'`` determina el "
"significado y la sintaxis de la construcción. Las extensiones normalmente no "
"crean un nuevo grupo; ``(?P<name>…)`` es la única excepción a esta regla. A "
"continuación se muestran las extensiones actualmente soportadas."

#: ../Doc/library/re.rst:343
msgid "``(?aiLmsux)``"
msgstr "``(?aiLmsux)``"

#: ../Doc/library/re.rst:329
msgid ""
"(One or more letters from the set ``'a'``, ``'i'``, ``'L'``, ``'m'``, "
"``'s'``, ``'u'``, ``'x'``.)  The group matches the empty string; the letters "
"set the corresponding flags: :const:`re.A` (ASCII-only matching), :const:`re."
"I` (ignore case), :const:`re.L` (locale dependent), :const:`re.M` (multi-"
"line), :const:`re.S` (dot matches all), :const:`re.U` (Unicode matching), "
"and :const:`re.X` (verbose), for the entire regular expression. (The flags "
"are described in :ref:`contents-of-module-re`.) This is useful if you wish "
"to include the flags as part of the regular expression, instead of passing a "
"*flag* argument to the :func:`re.compile` function.  Flags should be used "
"first in the expression string."
msgstr ""
"(Una o más letras del conjunto ``'a'``, ``'i'``, ``'L'``, ``'m'``, ``'s'``, "
"``'u'``, ``'x'``.) El grupo coincide con la cadena vacía; las letras ponen "
"los indicadores correspondientes: :const:`re.A` (coincidencia sólo en "
"ASCII), :const:`re.I` (ignorar mayúsculas o minúsculas), :const:`re. L` "
"(dependiente de la configuración regional), :const:`re.M` (multilínea), :"
"const:`re.S` (el punto coincide con todo), :const:`re.U` (coincidencia con "
"Unicode), y :const:`re.X` (modo *verbose*), para toda la expresión regular. "
"(Los indicadores se describen en :ref:`contents-of-module-re`.) Esto es útil "
"si se desea incluir los indicadores como parte de la expresión regular, en "
"lugar de pasar un argumento *flag* (indicador) a la función :func:`re."
"compile`. Los indicadores deben ser usados primero en la cadena de expresión."

#: ../Doc/library/re.rst:342
msgid "This construction can only be used at the start of the expression."
msgstr "Esta construcción solo se puede usar al comienzo de la expresión."

#: ../Doc/library/re.rst:351
msgid "``(?:...)``"
msgstr "``(?:...)``"

#: ../Doc/library/re.rst:348
msgid ""
"A non-capturing version of regular parentheses.  Matches whatever regular "
"expression is inside the parentheses, but the substring matched by the group "
"*cannot* be retrieved after performing a match or referenced later in the "
"pattern."
msgstr ""
"Una versión no capturable de los paréntesis regulares. Hace coincidir "
"cualquier expresión regular que esté dentro de los paréntesis, pero la "
"subcadena coincidente con el grupo *no puede* ser recuperada después de "
"realizar una coincidencia o referenciada más adelante en el patrón."

#: ../Doc/library/re.rst:377
msgid "``(?aiLmsux-imsx:...)``"
msgstr "``(?aiLmsux-imsx:...)``"

#: ../Doc/library/re.rst:354
msgid ""
"(Zero or more letters from the set ``'a'``, ``'i'``, ``'L'``, ``'m'``, "
"``'s'``, ``'u'``, ``'x'``, optionally followed by ``'-'`` followed by one or "
"more letters from the ``'i'``, ``'m'``, ``'s'``, ``'x'``.) The letters set "
"or remove the corresponding flags: :const:`re.A` (ASCII-only matching), :"
"const:`re.I` (ignore case), :const:`re.L` (locale dependent), :const:`re.M` "
"(multi-line), :const:`re.S` (dot matches all), :const:`re.U` (Unicode "
"matching), and :const:`re.X` (verbose), for the part of the expression. (The "
"flags are described in :ref:`contents-of-module-re`.)"
msgstr ""
"(Cero o más letras del conjunto ``'a'``, ``'i'``, ``'L'``, ``'m'``, ``'s'``, "
"``'u'``, ``'x'``, opcionalmente seguido de ``'-'`` seguido de una o más "
"letras de ``'i'``, ``'m'``, ``'s'``, ``'x'``.) Las letras ponen o quitan los "
"indicadores correspondientes: :const:`re.A` (coincidencia sólo en ASCII), :"
"const:`re.I` (ignorar mayúsculas o minúsculas), :const:`re. L` (dependiente "
"de la configuración regional), :const:`re.M` (multilínea), :const:`re.S` (el "
"punto coincide con todo), :const:`re.U` (coincidencia con Unicode), y :const:"
"`re.X` (modo *verbose*) para la parte de la expresión. (Los indicadores se "
"describen en :ref:`contents-of-module-re`.)"

#: ../Doc/library/re.rst:364
msgid ""
"The letters ``'a'``, ``'L'`` and ``'u'`` are mutually exclusive when used as "
"inline flags, so they can't be combined or follow ``'-'``.  Instead, when "
"one of them appears in an inline group, it overrides the matching mode in "
"the enclosing group.  In Unicode patterns ``(?a:...)`` switches to ASCII-"
"only matching, and ``(?u:...)`` switches to Unicode matching (default).  In "
"byte pattern ``(?L:...)`` switches to locale depending matching, and ``(?"
"a:...)`` switches to ASCII-only matching (default). This override is only in "
"effect for the narrow inline group, and the original matching mode is "
"restored outside of the group."
msgstr ""
"Las letras ``'a'``, ``'L'`` y ``'u'`` se excluyen mutuamente cuando se usan "
"como indicadores en línea, así que no pueden combinarse o ser seguidos por "
"``'-'``. En cambio, cuando uno de ellos aparece en un grupo dentro de la "
"línea, anula el modo de coincidencia en el grupo que lo rodea. En los "
"patrones Unicode, ``(?a:…)`` cambia al modo de concordancia sólo en ASCII, y "
"``(?u:…)`` cambia al modo de concordancia Unicode (por defecto). En el "
"patrón de bytes ``(?L:…)`` se cambia a una correspondencia en función de la "
"configuración regional, y ``(?a:…)`` se cambia a una correspondencia sólo en "
"ASCII (predeterminado). Esta anulación sólo tiene efecto para el grupo de "
"línea restringida, y el modo de coincidencia original se restaura fuera del "
"grupo."

#: ../Doc/library/re.rst:376
msgid "The letters ``'a'``, ``'L'`` and ``'u'`` also can be used in a group."
msgstr ""
"Las letras ``'a'``, ``'L'`` y ``'u'`` también pueden ser usadas en un grupo."

#: ../Doc/library/re.rst:392
msgid "``(?>...)``"
msgstr "``(?>...)``"

#: ../Doc/library/re.rst:380
msgid ""
"Attempts to match ``...`` as if it was a separate regular expression, and if "
"successful, continues to match the rest of the pattern following it. If the "
"subsequent pattern fails to match, the stack can only be unwound to a point "
"*before* the ``(?>...)`` because once exited, the expression, known as an :"
"dfn:`atomic group`, has thrown away all stack points within itself. Thus, "
"``(?>.*).`` would never match anything because first the ``.*`` would match "
"all characters possible, then, having nothing left to match, the final ``.`` "
"would fail to match. Since there are no stack points saved in the Atomic "
"Group, and there is no stack point before it, the entire expression would "
"thus fail to match."
msgstr ""
"Intenta hacer coincidir ``...`` como si fuera una expresión regular "
"separada, y si tiene éxito, continúa coincidiendo con el resto del patrón "
"que la sigue. Si el patrón posterior no coincide, la pila solo se puede "
"desenrollar a un punto *antes* del ``(?>...)`` Porque una vez que salió, la "
"expresión, conocida como :dfn:`grupo atomico <atomic group>`, ha desechado "
"todos los puntos de pila dentro de sí misma. Por lo tanto, ``(?>.*).`` nunca "
"coincidiría con nada porque primero el ``.*`` coincidiría con todos los "
"caracteres posibles, luego, al no tener nada que igualar, el ``.`` final no "
"coincidiría. Dado que no hay puntos de pila guardados en el Grupo Atómico, y "
"no hay ningún punto de pila antes de él, toda la expresión no coincidiría."

#: ../Doc/library/re.rst:424
msgid "``(?P<name>...)``"
msgstr "``(?P<name>...)``"

#: ../Doc/library/re.rst:397
msgid ""
"Similar to regular parentheses, but the substring matched by the group is "
"accessible via the symbolic group name *name*.  Group names must be valid "
"Python identifiers, and in :class:`bytes` patterns they can only contain "
"bytes in the ASCII range.  Each group name must be defined only once within "
"a regular expression.  A symbolic group is also a numbered group, just as if "
"the group were not named."
msgstr ""
"Similar a los paréntesis regulares, pero la subcadena coincidente con el "
"grupo es accesible a través del nombre simbólico del grupo, *name*. Los "
"nombres de grupo deben ser identificadores válidos de Python, y en los "
"patrones de :class:`bytes` solo pueden contener bytes en el rango ASCII.  "
"Cada nombre de grupo debe ser definido sólo una vez dentro de una expresión "
"regular.  Un grupo simbólico es también un grupo numerado, del mismo modo "
"que si el grupo no tuviera nombre."

#: ../Doc/library/re.rst:404
msgid ""
"Named groups can be referenced in three contexts.  If the pattern is ``(?"
"P<quote>['\"]).*?(?P=quote)`` (i.e. matching a string quoted with either "
"single or double quotes):"
msgstr ""
"Los grupos con nombre pueden ser referenciados en tres contextos. Si el "
"patrón es ``(?P<quote>['\"]).*?(?P=quote)`` (es decir, hacer coincidir una "
"cadena citada con comillas simples o dobles):"

#: ../Doc/library/re.rst:409
msgid "Context of reference to group \"quote\""
msgstr "Contexto de la referencia al grupo *quote* (cita)"

#: ../Doc/library/re.rst:409
msgid "Ways to reference it"
msgstr "Formas de hacer referencia"

#: ../Doc/library/re.rst:411
msgid "in the same pattern itself"
msgstr "en el mismo patrón en sí mismo"

#: ../Doc/library/re.rst:411
msgid "``(?P=quote)`` (as shown)"
msgstr "``(?P=quote)`` (como se muestra)"

#: ../Doc/library/re.rst:412 ../Doc/library/re.rst:419
msgid "``\\1``"
msgstr "``\\1``"

#: ../Doc/library/re.rst:414
msgid "when processing match object *m*"
msgstr "cuando se procesa el objeto de la coincidencia *m*"

#: ../Doc/library/re.rst:414
msgid "``m.group('quote')``"
msgstr "``m.group('quote')``"

#: ../Doc/library/re.rst:415
msgid "``m.end('quote')`` (etc.)"
msgstr "``m.end('quote')`` (etc.)"

#: ../Doc/library/re.rst:417
msgid "in a string passed to the *repl* argument of ``re.sub()``"
msgstr "en una cadena pasada al argumento *repl* de ``re.sub()``"

#: ../Doc/library/re.rst:417
msgid "``\\g<quote>``"
msgstr "``\\g<quote>``"

#: ../Doc/library/re.rst:418
msgid "``\\g<1>``"
msgstr "``\\g<1>``"

#: ../Doc/library/re.rst:422
msgid ""
"In :class:`bytes` patterns, group *name* can only contain bytes in the ASCII "
"range (``b'\\x00'``-``b'\\x7f'``)."
msgstr ""
"En patrones de tipo :class:`bytes`, el nombre del grupo *name* solo puede "
"contener bytes en el rango ASCII (``b'\\x00'``-``b'\\x7f'``)."

#: ../Doc/library/re.rst:430
msgid "``(?P=name)``"
msgstr "``(?P=name)``"

#: ../Doc/library/re.rst:429
msgid ""
"A backreference to a named group; it matches whatever text was matched by "
"the earlier group named *name*."
msgstr ""
"Una referencia inversa a un grupo nombrado; coincide con cualquier texto "
"correspondido por el grupo anterior llamado *name*."

#: ../Doc/library/re.rst:435
msgid "``(?#...)``"
msgstr "``(?#...)``"

#: ../Doc/library/re.rst:435
msgid "A comment; the contents of the parentheses are simply ignored."
msgstr "Un comentario; el contenido de los paréntesis es simplemente ignorado."

#: ../Doc/library/re.rst:442
msgid "``(?=...)``"
msgstr "``(?=...)``"

#: ../Doc/library/re.rst:440
msgid ""
"Matches if ``...`` matches next, but doesn't consume any of the string.  "
"This is called a :dfn:`lookahead assertion`.  For example, ``Isaac (?"
"=Asimov)`` will match ``'Isaac '`` only if it's followed by ``'Asimov'``."
msgstr ""
"Coincide si ``…`` coincide con el siguiente patrón, pero no procesa nada de "
"la cadena. Esto se llama una :dfn:`lookahead assertion` (aserción de "
"búsqueda anticipada). Por ejemplo, ``Isaac (?=Asimov)`` coincidirá con "
"``'Isaac '`` sólo si va seguido de ``'Asimov'``."

#: ../Doc/library/re.rst:449
msgid "``(?!...)``"
msgstr "``(?!...)``"

#: ../Doc/library/re.rst:447
msgid ""
"Matches if ``...`` doesn't match next.  This is a :dfn:`negative lookahead "
"assertion`. For example, ``Isaac (?!Asimov)`` will match ``'Isaac '`` only "
"if it's *not* followed by ``'Asimov'``."
msgstr ""
"Coincide si ``…`` no coincide con el siguiente. Esta es una :dfn:`negative "
"lookahead assertion` (aserción negativa de búsqueda anticipada). Por "
"ejemplo, ``Isaac (?!Asimov)`` coincidirá con ``'Isaac '`` sólo si *no* es "
"seguido por ``'Asimov'``."

#: ../Doc/library/re.rst:476
msgid "``(?<=...)``"
msgstr "``(?<=...)``"

#: ../Doc/library/re.rst:454
msgid ""
"Matches if the current position in the string is preceded by a match for "
"``...`` that ends at the current position.  This is called a :dfn:`positive "
"lookbehind assertion`. ``(?<=abc)def`` will find a match in ``'abcdef'``, "
"since the lookbehind will back up 3 characters and check if the contained "
"pattern matches. The contained pattern must only match strings of some fixed "
"length, meaning that ``abc`` or ``a|b`` are allowed, but ``a*`` and ``a{3,4}"
"`` are not.  Note that patterns which start with positive lookbehind "
"assertions will not match at the beginning of the string being searched; you "
"will most likely want to use the :func:`search` function rather than the :"
"func:`match` function:"
msgstr ""
"Coincide si la posición actual en la cadena es precedida por una "
"coincidencia para ``…`` que termina en la posición actual.  Esto se llama "
"una :dfn:`positive lookbehind assertion` (aserciones positivas de búsqueda "
"tardía). ``(?<=abc)def`` encontrará una coincidencia en ``'abcdef'``, ya que "
"la búsqueda tardía hará una copia de seguridad de 3 caracteres y comprobará "
"si el patrón contenido coincide. El patrón contenido sólo debe coincidir con "
"cadenas de alguna longitud fija, lo que significa que ``abc`` o ``a|b`` "
"están permitidas, pero ``a*`` y ``a{3,4}`` no lo están.  Hay que tener en "
"cuenta que los patrones que empiezan con aserciones positivas de búsqueda "
"tardía no coincidirán con el principio de la cadena que se está buscando; lo "
"más probable es que se quiera usar la función :func:`search` en lugar de la "
"función :func:`match`:"

#: ../Doc/library/re.rst:469
msgid "This example looks for a word following a hyphen:"
msgstr "Este ejemplo busca una palabra seguida de un guión:"

#: ../Doc/library/re.rst:475
msgid "Added support for group references of fixed length."
msgstr "Se añadió soporte a las referencias de grupo de longitud fija."

#: ../Doc/library/re.rst:485
msgid "``(?<!...)``"
msgstr "``(?<!...)``"

#: ../Doc/library/re.rst:481
msgid ""
"Matches if the current position in the string is not preceded by a match for "
"``...``.  This is called a :dfn:`negative lookbehind assertion`.  Similar to "
"positive lookbehind assertions, the contained pattern must only match "
"strings of some fixed length.  Patterns which start with negative lookbehind "
"assertions may match at the beginning of the string being searched."
msgstr ""
"Coincide si la posición actual en la cadena no está precedida por una "
"coincidencia de \"…\".  Esto se llama una :dfn:`negative lookbehind "
"assertion` (Aserciones negativas de búsqueda tardía).  Similar a las "
"aserciones positivas de búsqueda tardía, el patrón contenido sólo debe "
"coincidir con cadenas de alguna longitud fija.  Los patrones que empiezan "
"con aserciones negativas pueden coincidir al principio de la cadena que se "
"busca."

#: ../Doc/library/re.rst:502
msgid "``(?(id/name)yes-pattern|no-pattern)``"
msgstr "``(?(id/name)yes-pattern|no-pattern)``"

#: ../Doc/library/re.rst:491
msgid ""
"Will try to match with ``yes-pattern`` if the group with given *id* or "
"*name* exists, and with ``no-pattern`` if it doesn't. ``no-pattern`` is "
"optional and can be omitted. For example, ``(<)?(\\w+@\\w+(?:\\.\\w+)+)(?"
"(1)>|$)`` is a poor email matching pattern, which will match with "
"``'<user@host.com>'`` as well as ``'user@host.com'``, but not with "
"``'<user@host.com'`` nor ``'user@host.com>'``."
msgstr ""
"Tratará de coincidir con el ``yes-pattern`` (con patrón) si el grupo con un "
"*id* o  *nombre* existe, y con el ``no-pattern`` (sin patrón) si no existe. "
"El ``no-pattern`` es opcional y puede ser omitido. Por ejemplo, ``(<)?"
"(\\w+@\\w+(?:\\.\\w+)+)(?(1)>||$)`` es un patrón de coincidencia de correo "
"electrónico deficiente, ya que coincidirá con ``'<user@host.com>'`` así como "
"con ``'user@host.com'``, pero no con ``'<user@host.com'`` ni con "
"``'user@host.com>'``."

#: ../Doc/library/re.rst:498
msgid ""
"Group *id* can only contain ASCII digits. In :class:`bytes` patterns, group "
"*name* can only contain bytes in the ASCII range (``b'\\x00'``-``b'\\x7f'``)."
msgstr ""
"El *id* del grupo solo puede contener dígitos ASCII. En patrones de tipo :"
"class:`bytes`, el *name* del grupo solo puede contener bytes en el rango "
"ASCII (``b'\\x00'``-``b'\\x7f'``)."

#: ../Doc/library/re.rst:506
msgid ""
"The special sequences consist of ``'\\'`` and a character from the list "
"below. If the ordinary character is not an ASCII digit or an ASCII letter, "
"then the resulting RE will match the second character.  For example, ``\\$`` "
"matches the character ``'$'``."
msgstr ""
"Las secuencias especiales consisten en ``'\\'`` y un carácter de la lista "
"que aparece más adelante. Si el carácter ordinario no es un dígito ASCII o "
"una letra ASCII, entonces el RE resultante coincidirá con el segundo "
"carácter.  Por ejemplo, ``\\$`` coincide con el carácter ``'$'``."

#: ../Doc/library/re.rst:521
msgid "``\\number``"
msgstr "``\\number``"

#: ../Doc/library/re.rst:514
msgid ""
"Matches the contents of the group of the same number.  Groups are numbered "
"starting from 1.  For example, ``(.+) \\1`` matches ``'the the'`` or ``'55 "
"55'``, but not ``'thethe'`` (note the space after the group).  This special "
"sequence can only be used to match one of the first 99 groups.  If the first "
"digit of *number* is 0, or *number* is 3 octal digits long, it will not be "
"interpreted as a group match, but as the character with octal value "
"*number*. Inside the ``'['`` and ``']'`` of a character class, all numeric "
"escapes are treated as characters."
msgstr ""
"Coincide con el contenido del grupo del mismo número.  Los grupos se numeran "
"empezando por el 1. Por ejemplo, ``(.+) \\1`` coincide con ``'el el'`` o "
"``'55 55'``, pero no con ``'elel'`` (notar el espacio después del grupo).  "
"Esta secuencia especial sólo puede ser usada para hacer coincidir uno de los "
"primeros 99 grupos.  Si el primer dígito del *número* es 0, o el *número* "
"tiene 3 dígitos octales, no se interpretará como una coincidencia de grupo, "
"sino como el carácter con valor octal *número*. Dentro de los ``'['`` y "
"``']'`` de una clase de caracteres, todos los escapes numéricos son tratados "
"como caracteres."

#: ../Doc/library/re.rst:526
msgid "``\\A``"
msgstr "``\\A``"

#: ../Doc/library/re.rst:526
msgid "Matches only at the start of the string."
msgstr "Coincide sólo al principio de la cadena."

#: ../Doc/library/re.rst:542
msgid "``\\b``"
msgstr "``\\b``"

#: ../Doc/library/re.rst:531
msgid ""
"Matches the empty string, but only at the beginning or end of a word. A word "
"is defined as a sequence of word characters.  Note that formally, ``\\b`` is "
"defined as the boundary between a ``\\w`` and a ``\\W`` character (or vice "
"versa), or between ``\\w`` and the beginning/end of the string. This means "
"that ``r'\\bfoo\\b'`` matches ``'foo'``, ``'foo.'``, ``'(foo)'``, ``'bar foo "
"baz'`` but not ``'foobar'`` or ``'foo3'``."
msgstr ""
"Coincide con la cadena vacía, pero sólo al principio o al final de una "
"palabra. Una palabra se define como una secuencia de caracteres de "
"palabras.  Notar que formalmente, ``\\b`` se define como el límite entre un "
"carácter ``\\w`` y un carácter ``\\W`` (o viceversa), o entre ``\\w`` y el "
"principio/fin de la cadena. Esto significa que ``r'\\bfoo\\b'`` coincide con "
"``'foo'``, ``'foo.'``, ``'(foo)'``, ``'bar foo baz'`` pero no ``'foobar'`` o "
"``'foo3'``."

#: ../Doc/library/re.rst:538
msgid ""
"By default Unicode alphanumerics are the ones used in Unicode patterns, but "
"this can be changed by using the :const:`ASCII` flag.  Word boundaries are "
"determined by the current locale if the :const:`LOCALE` flag is used. Inside "
"a character range, ``\\b`` represents the backspace character, for "
"compatibility with Python's string literals."
msgstr ""
"Por defecto, los alfanuméricos Unicode son los que se usan en los patrones "
"Unicode, pero esto se puede cambiar usando el indicador :const:`ASCII`.  Los "
"límites de las palabras están determinados por la configuración regional "
"actual si se usa el indicador :const:`LOCALE`. Dentro de un rango de "
"caracteres, ``\\b`` representa el carácter de retroceso (*backspace*), para "
"compatibilidad con los literales de las cadenas de Python."

#: ../Doc/library/re.rst:553
msgid "``\\B``"
msgstr "``\\B``"

#: ../Doc/library/re.rst:547
msgid ""
"Matches the empty string, but only when it is *not* at the beginning or end "
"of a word.  This means that ``r'py\\B'`` matches ``'python'``, ``'py3'``, "
"``'py2'``, but not ``'py'``, ``'py.'``, or ``'py!'``. ``\\B`` is just the "
"opposite of ``\\b``, so word characters in Unicode patterns are Unicode "
"alphanumerics or the underscore, although this can be changed by using the :"
"const:`ASCII` flag.  Word boundaries are determined by the current locale if "
"the :const:`LOCALE` flag is used."
msgstr ""
"Coincide con la cadena vacía, pero sólo cuando *no* está al principio o al "
"final de una palabra.  Esto significa que ``r'py\\B'`` coincide con "
"``'python'``, ``'py3'``, ``'py2'``, pero no con ``'py'``, ``'py.'`` o "
"``'py!'``. ``\\B`` es justo lo opuesto a ``\\b``, por lo que los caracteres "
"de las palabras en los patrones de Unicode son alfanuméricos o el subrayado, "
"aunque esto puede ser cambiado usando el indicador :const:`ASCII`.  Los "
"límites de las palabras están determinados por la configuración regional "
"actual si se usa el indicador :const:`LOCALE`."

#: ../Doc/library/re.rst:565
msgid "``\\d``"
msgstr "``\\d``"

#: ../Doc/library/re.rst:562 ../Doc/library/re.rst:582
#: ../Doc/library/re.rst:601
msgid "For Unicode (str) patterns:"
msgstr "Para los patrones de Unicode (str):"

#: ../Doc/library/re.rst:559
msgid ""
"Matches any Unicode decimal digit (that is, any character in Unicode "
"character category [Nd]).  This includes ``[0-9]``, and also many other "
"digit characters.  If the :const:`ASCII` flag is used only ``[0-9]`` is "
"matched."
msgstr ""
"Coincide con cualquier dígito decimal de Unicode (es decir, cualquier "
"carácter de la categoría de caracteres de Unicode [Nd]).  Esto incluye a "
"``[0-9]``, y también muchos otros caracteres de dígitos.  Si se usa el "
"indicador :const:`ASCII`, sólo coincide con ``[0-9]``."

#: ../Doc/library/re.rst:565 ../Doc/library/re.rst:586
#: ../Doc/library/re.rst:607
msgid "For 8-bit (bytes) patterns:"
msgstr "Para patrones de 8 bits (bytes):"

#: ../Doc/library/re.rst:565
msgid "Matches any decimal digit; this is equivalent to ``[0-9]``."
msgstr "Coincide con cualquier dígito decimal; esto equivale a ``[0-9]``."

#: ../Doc/library/re.rst:572
msgid "``\\D``"
msgstr "``\\D``"

#: ../Doc/library/re.rst:570
msgid ""
"Matches any character which is not a decimal digit. This is the opposite of "
"``\\d``. If the :const:`ASCII` flag is used this becomes the equivalent of "
"``[^0-9]``."
msgstr ""
"Coincide con cualquier carácter que no sea un dígito decimal. Esto es lo "
"opuesto a ``\\d``. Si se usa el indicador :const:`ASCII` esto se convierte "
"en el equivalente a ``[^0-9]``."

#: ../Doc/library/re.rst:586
msgid "``\\s``"
msgstr "``\\s``"

#: ../Doc/library/re.rst:578
msgid ""
"Matches Unicode whitespace characters (which includes "
"``[ \\t\\n\\r\\f\\v]``, and also many other characters, for example the non-"
"breaking spaces mandated by typography rules in many languages). If the :"
"const:`ASCII` flag is used, only ``[ \\t\\n\\r\\f\\v]`` is matched."
msgstr ""
"Coincide con los caracteres de los espacios en blanco de Unicode (que "
"incluye ``[ \\t\\n\\r\\f\\v]``, y también muchos otros caracteres, por "
"ejemplo los espacios duros exigidos por las reglas tipográficas en muchos "
"idiomas). Si se usa el indicador :const:`ASCII``, sólo "
"``[ \\t\\n\\r\\f\\v]`` coincide."

#: ../Doc/library/re.rst:585
msgid ""
"Matches characters considered whitespace in the ASCII character set; this is "
"equivalent to ``[ \\t\\n\\r\\f\\v]``."
msgstr ""
"Coincide con los caracteres considerados como espacios en blanco en el "
"conjunto de caracteres ASCII, lo que equivale a ``[ \\t\\n\\r\\f\\v]``."

#: ../Doc/library/re.rst:593
msgid "``\\S``"
msgstr "``\\S``"

#: ../Doc/library/re.rst:591
msgid ""
"Matches any character which is not a whitespace character. This is the "
"opposite of ``\\s``. If the :const:`ASCII` flag is used this becomes the "
"equivalent of ``[^ \\t\\n\\r\\f\\v]``."
msgstr ""
"Coincide con cualquier carácter que no sea un carácter de espacio en blanco. "
"Esto es lo opuesto a ``\\s``. Si se usa el indicador :const:`ASCII` se "
"convierte en el equivalente a `[^ \\t\\n\\r\\f\\v]`."

#: ../Doc/library/re.rst:607
msgid "``\\w``"
msgstr "``\\w``"

#: ../Doc/library/re.rst:599
msgid ""
"Matches Unicode word characters; this includes alphanumeric characters (as "
"defined by :meth:`str.isalnum`) as well as the underscore (``_``). If the :"
"const:`ASCII` flag is used, only ``[a-zA-Z0-9_]`` is matched."
msgstr ""
"Coincide con los caracteres de palabras Unicode; esto incluye los caracteres "
"alfanuméricos (como se define por :meth:`str.isalnum`) así como el guión "
"bajo (``_``). Si se utiliza la bandera :const:`ASCII`, sólo coincide con "
"``[a-zA-Z0-9_]``."

#: ../Doc/library/re.rst:604
msgid ""
"Matches characters considered alphanumeric in the ASCII character set; this "
"is equivalent to ``[a-zA-Z0-9_]``.  If the :const:`LOCALE` flag is used, "
"matches characters considered alphanumeric in the current locale and the "
"underscore."
msgstr ""
"Coincide con los caracteres considerados alfanuméricos en el conjunto de "
"caracteres ASCII; esto equivale a ``[a-zA-Z0-9_]``.  Si se usa el indicador :"
"const:`LOCALE`, coincide con los caracteres considerados alfanuméricos en la "
"configuración regional actual y el guión bajo."

#: ../Doc/library/re.rst:616
msgid "``\\W``"
msgstr "``\\W``"

#: ../Doc/library/re.rst:612
msgid ""
"Matches any character which is not a word character. This is the opposite of "
"``\\w``. If the :const:`ASCII` flag is used this becomes the equivalent of "
"``[^a-zA-Z0-9_]``.  If the :const:`LOCALE` flag is used, matches characters "
"which are neither alphanumeric in the current locale nor the underscore."
msgstr ""
"Coincide con cualquier carácter que no sea un carácter de una palabra. Esto "
"es lo opuesto a ``\\w``. Si se usa el indicador :const:`ASCII` esto se "
"convierte en el equivalente a ``[^a-zA-Z0-9_]``.  Si se usa el indicador :"
"const:`LOCALE`, coincide con los caracteres que no son ni alfanuméricos en "
"la configuración regional actual ni con el guión bajo."

#: ../Doc/library/re.rst:621
msgid "``\\Z``"
msgstr "``\\Z``"

#: ../Doc/library/re.rst:621
msgid "Matches only at the end of the string."
msgstr "Coincide sólo el final de la cadena."

#: ../Doc/library/re.rst:637
msgid ""
"Most of the :ref:`escape sequences <escape-sequences>` supported by Python "
"string literals are also accepted by the regular expression parser::"
msgstr ""
"La mayoría de las :ref:`secuencias de escape <escape-sequences>` soportadas "
"por los literales de cadena de Python también son aceptadas por el "
"analizador de expresiones regulares::"

#: ../Doc/library/re.rst:644
msgid ""
"(Note that ``\\b`` is used to represent word boundaries, and means "
"\"backspace\" only inside character classes.)"
msgstr ""
"(Notar que ``\\b`` se usa para representar los límites de las palabras, y "
"significa \"retroceso\" (*backspace*) sólo dentro de las clases de "
"caracteres.)"

#: ../Doc/library/re.rst:647
msgid ""
"``'\\u'``, ``'\\U'``, and ``'\\N'`` escape sequences are only recognized in "
"Unicode patterns.  In bytes patterns they are errors.  Unknown escapes of "
"ASCII letters are reserved for future use and treated as errors."
msgstr ""
"Las secuencias de escape ``'\\u'``, ``'\\U'`` y ``'\\N'`` sólo se reconocen "
"en los patrones Unicode.  En los patrones de bytes son errores.  Los escapes "
"desconocidos de las letras ASCII se reservan para su uso posterior y se "
"consideran errores."

#: ../Doc/library/re.rst:651
msgid ""
"Octal escapes are included in a limited form.  If the first digit is a 0, or "
"if there are three octal digits, it is considered an octal escape. "
"Otherwise, it is a group reference.  As for string literals, octal escapes "
"are always at most three digits in length."
msgstr ""
"Los escapes octales se incluyen en una forma limitada.  Si el primer dígito "
"es un 0, o si hay tres dígitos octales, se considera un escape octal. De lo "
"contrario, es una referencia de grupo.  En cuanto a los literales de cadena, "
"los escapes octales siempre tienen como máximo tres dígitos de longitud."

#: ../Doc/library/re.rst:656
msgid "The ``'\\u'`` and ``'\\U'`` escape sequences have been added."
msgstr "Se han añadido las secuencias de escape ``'\\u'`` y ``'\\U'``."

#: ../Doc/library/re.rst:659
msgid ""
"Unknown escapes consisting of ``'\\'`` and an ASCII letter now are errors."
msgstr ""
"Los escapes desconocidos que consisten en ``'\\'`` y una letra ASCII ahora "
"son errores."

#: ../Doc/library/re.rst:662
msgid ""
"The :samp:`'\\\\N\\\\{{name}\\\\}'` escape sequence has been added. As in "
"string literals, it expands to the named Unicode character (e.g. ``'\\N{EM "
"DASH}'``)."
msgstr ""
"Se añadió la secuencia de escape :samp:`'\\\\N\\\\{{name}\\\\}'`. Como en "
"los literales de cadena, se expande al carácter Unicode nombrado (p. ej. "
"``'\\N{EM DASH}'``)."

#: ../Doc/library/re.rst:670
msgid "Module Contents"
msgstr "Contenidos del módulo"

#: ../Doc/library/re.rst:672
msgid ""
"The module defines several functions, constants, and an exception. Some of "
"the functions are simplified versions of the full featured methods for "
"compiled regular expressions.  Most non-trivial applications always use the "
"compiled form."
msgstr ""
"El módulo define varias funciones, constantes y una excepción. Algunas de "
"las funciones son versiones simplificadas de los métodos completos de las "
"expresiones regulares compiladas.  La mayoría de las aplicaciones no "
"triviales utilizan siempre la forma compilada."

#: ../Doc/library/re.rst:679
msgid "Flags"
msgstr "Indicadores"

#: ../Doc/library/re.rst:681
msgid ""
"Flag constants are now instances of :class:`RegexFlag`, which is a subclass "
"of :class:`enum.IntFlag`."
msgstr ""
"Ahora las constantes de indicadores son instancias de :class:`RegexFlag`, "
"que es una subclase de :class:`enum.IntFlag`."

#: ../Doc/library/re.rst:688
msgid ""
"An :class:`enum.IntFlag` class containing the regex options listed below."
msgstr ""
"Una clase :class:`enum.IntFlag` contiene las opciones regex que se enumeran "
"a continuación."

#: ../Doc/library/re.rst:690
msgid "- added to ``__all__``"
msgstr "- agregado a ``__all__``"

#: ../Doc/library/re.rst:695
msgid ""
"Make ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\d``, ``\\D``, ``\\s`` and "
"``\\S`` perform ASCII-only matching instead of full Unicode matching.  This "
"is only meaningful for Unicode patterns, and is ignored for byte patterns. "
"Corresponds to the inline flag ``(?a)``."
msgstr ""
"Hace que ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\d``, ``\\D``, ``\\s`` y "
"``\\S`` realicen una coincidencia ASCII en lugar de una concordancia "
"Unicode.  Esto sólo tiene sentido para los patrones de Unicode, y se ignora "
"para los patrones de bytes. Corresponde al indicador en línea ``(?a)``."

#: ../Doc/library/re.rst:700
msgid ""
"Note that for backward compatibility, the :const:`re.U` flag still exists "
"(as well as its synonym :const:`re.UNICODE` and its embedded counterpart ``(?"
"u)``), but these are redundant in Python 3 since matches are Unicode by "
"default for strings (and Unicode matching isn't allowed for bytes)."
msgstr ""
"Notar que para la compatibilidad con versiones anteriores, el indicador :"
"const:`re.U` todavía existe (así como su sinónimo :const:`re.UNICODE` y su "
"contraparte incrustada ``(?u)``), pero estos son redundantes en Python 3 ya "
"que las coincidencias son Unicode por defecto para las cadenas (y no se "
"permite la coincidencia Unicode para los bytes)."

#: ../Doc/library/re.rst:709
msgid ""
"Display debug information about compiled expression. No corresponding inline "
"flag."
msgstr ""
"Muestra información de depuración (*debug*) sobre la expresión compilada. No "
"hay un indicador en línea que corresponda."

#: ../Doc/library/re.rst:716
msgid ""
"Perform case-insensitive matching; expressions like ``[A-Z]`` will also "
"match lowercase letters.  Full Unicode matching (such as ``Ü`` matching "
"``ü``) also works unless the :const:`re.ASCII` flag is used to disable non-"
"ASCII matches.  The current locale does not change the effect of this flag "
"unless the :const:`re.LOCALE` flag is also used. Corresponds to the inline "
"flag ``(?i)``."
msgstr ""
"Realiza una coincidencia insensible a las mayúsculas y minúsculas; "
"expresiones como ``[A-Z]`` también coincidirán con las minúsculas.  La "
"coincidencia completa de Unicode (como ``Ü`` coincidencia ``ü``) también "
"funciona a menos que el indicador :const:`re.ASCII` se utilice para "
"desactivar las coincidencias que no sean ASCII.  La configuración regional "
"vigente no cambia el efecto de este indicador a menos que también se use el "
"indicador :const:`re.LOCALE`. Corresponde al indicador en línea ``(?i)``."

#: ../Doc/library/re.rst:723
msgid ""
"Note that when the Unicode patterns ``[a-z]`` or ``[A-Z]`` are used in "
"combination with the :const:`IGNORECASE` flag, they will match the 52 ASCII "
"letters and 4 additional non-ASCII letters: 'İ' (U+0130, Latin capital "
"letter I with dot above), 'ı' (U+0131, Latin small letter dotless i), "
"'ſ' (U+017F, Latin small letter long s) and 'K' (U+212A, Kelvin sign). If "
"the :const:`ASCII` flag is used, only letters 'a' to 'z' and 'A' to 'Z' are "
"matched."
msgstr ""
"Notar que cuando los patrones Unicode ``[a-z]`` o ``[A-Z]`` se usan en "
"combinación con el flag :const:`IGNORECASE``, coincidirán con las 52 letras "
"ASCII y 4 letras adicionales no ASCII: 'İ' (U+0130, letra mayúscula latina I "
"con punto arriba), 'ı' (U+0131, letra minúscula latina sin punto i), "
"'ſ' (U+017F, letra minúscula latina s larga) y 'K' (U+212A, signo Kelvin). "
"Si se usa el indicador :const:`ASCII`, sólo las letras de la 'a' a la 'z' y "
"de la 'A' a la 'Z' coinciden."

#: ../Doc/library/re.rst:734
msgid ""
"Make ``\\w``, ``\\W``, ``\\b``, ``\\B`` and case-insensitive matching "
"dependent on the current locale.  This flag can be used only with bytes "
"patterns.  The use of this flag is discouraged as the locale mechanism is "
"very unreliable, it only handles one \"culture\" at a time, and it only "
"works with 8-bit locales.  Unicode matching is already enabled by default in "
"Python 3 for Unicode (str) patterns, and it is able to handle different "
"locales/languages. Corresponds to the inline flag ``(?L)``."
msgstr ""
"Hace que las coincidencias ``\\w``, ``\\W``, ``\\b``, ``\\B`` y las "
"coincidencias insensibles a mayúsculas y minúsculas dependan de la "
"configuración regional vigente.  Este indicador sólo puede ser usado con "
"patrones de bytes.  Se desaconseja su uso ya que el mecanismo de "
"configuración regional no es fiable, sólo maneja una \"cultura\" a la vez, y "
"sólo funciona con localizaciones de 8 bits.  La coincidencia Unicode ya está "
"activada por defecto en Python 3 para los patrones Unicode (str), y es capaz "
"de manejar diferentes localizaciones/idiomas. Corresponde al indicador en "
"línea ``(?L)``."

#: ../Doc/library/re.rst:743
msgid ""
":const:`re.LOCALE` can be used only with bytes patterns and is not "
"compatible with :const:`re.ASCII`."
msgstr ""
":const:`re.LOCALE` sólo se puede usar con patrones de bytes y no es "
"compatible con :const:`re.ASCII`."

#: ../Doc/library/re.rst:747
msgid ""
"Compiled regular expression objects with the :const:`re.LOCALE` flag no "
"longer depend on the locale at compile time.  Only the locale at matching "
"time affects the result of matching."
msgstr ""
"Los objetos expresión regular compilados con el indicador :const:`re.LOCALE` "
"ya no dependen del lugar en el momento de la compilación.  Sólo la "
"configuración regional durante la coincidencia afecta al resultado obtenido."

#: ../Doc/library/re.rst:756
msgid ""
"When specified, the pattern character ``'^'`` matches at the beginning of "
"the string and at the beginning of each line (immediately following each "
"newline); and the pattern character ``'$'`` matches at the end of the string "
"and at the end of each line (immediately preceding each newline).  By "
"default, ``'^'`` matches only at the beginning of the string, and ``'$'`` "
"only at the end of the string and immediately before the newline (if any) at "
"the end of the string. Corresponds to the inline flag ``(?m)``."
msgstr ""
"Cuando se especifica, el patrón de caracteres ``'^'`` coincide al principio "
"de la cadena y al principio de cada línea (inmediatamente después de cada "
"nueva línea); y el patrón de caracteres ``'$'`` coincide al final de la "
"cadena y al final de cada línea (inmediatamente antes de cada nueva línea).  "
"Por defecto, ``'^'`` coincide sólo al principio de la cadena, y ``'$'`` sólo "
"al final de la cadena e inmediatamente antes de la nueva línea (si la hay) "
"al final de la cadena. Corresponde al indicador en línea ``(?m)``."

#: ../Doc/library/re.rst:766
msgid ""
"Indicates no flag being applied, the value is ``0``.  This flag may be used "
"as a default value for a function keyword argument or as a base value that "
"will be conditionally ORed with other flags.  Example of use as a default "
"value::"
msgstr ""
"Indica que no se aplica ninguna bandera, el valor es ``0``. Esta bandera "
"puede ser utilizada como valor predeterminado para un argumento de palabra "
"clave de función o como un valor que será condicionalmente combinado con "
"otras banderas usando el operador binario OR. Ejemplo de uso como valor "
"predeterminado::"

#: ../Doc/library/re.rst:779
msgid ""
"Make the ``'.'`` special character match any character at all, including a "
"newline; without this flag, ``'.'`` will match anything *except* a newline. "
"Corresponds to the inline flag ``(?s)``."
msgstr ""
"Hace que el carácter especial ``'.'`` coincida con cualquier carácter, "
"incluyendo una nueva línea. Sin este indicador, ``'.'`` coincidirá con "
"cualquier cosa, *excepto* con una nueva línea. Corresponde al indicador en "
"línea ``(?s)``."

#: ../Doc/library/re.rst:787
msgid ""
"In Python 2, this flag made :ref:`special sequences <re-special-sequences>` "
"include Unicode characters in matches. Since Python 3, Unicode characters "
"are matched by default."
msgstr ""
"En Python 2, esta bandera hacía que :ref:`secuencias especiales <re-special-"
"sequences>` incluyeran caracteres Unicode en las coincidencias. Desde Python "
"3, los caracteres Unicode se coinciden por defecto."

#: ../Doc/library/re.rst:791
msgid "See :const:`A` for restricting matching on ASCII characters instead."
msgstr ""
"Ver :const:`A` para restringir la coincidencia a caracteres ASCII en su "
"lugar."

#: ../Doc/library/re.rst:793
msgid "This flag is only kept for backward compatibility."
msgstr "Esta bandera se mantiene solo por retrocompatibilidad."

#: ../Doc/library/re.rst:800
msgid ""
"This flag allows you to write regular expressions that look nicer and are "
"more readable by allowing you to visually separate logical sections of the "
"pattern and add comments. Whitespace within the pattern is ignored, except "
"when in a character class, or when preceded by an unescaped backslash, or "
"within tokens like ``*?``, ``(?:`` or ``(?P<...>``. For example, ``(? :`` "
"and ``* ?`` are not allowed. When a line contains a ``#`` that is not in a "
"character class and is not preceded by an unescaped backslash, all "
"characters from the leftmost such ``#`` through the end of the line are "
"ignored."
msgstr ""
"Esta bandera permite escribir expresiones regulares que se ven mejor y son "
"más legibles, facilitando la separación visual de las secciones lógicas del "
"patrón y la adición de comentarios. Los espacios en blanco dentro del patrón "
"se ignoran, excepto cuando están en una clase de caracteres, o cuando están "
"precedidos por una barra inversa sin escapar, o dentro de tokens como ``*?"
"``, ``(?:`` o ``(?P<...>``. Por ejemplo, ``(? :`` y ``* ?`` no están "
"permitidos. Cuando una línea contiene un ``#`` que no está en una clase de "
"caracteres y no está precedida por una barra inversa sin escapar, todos los "
"caracteres desde el ``#`` más a la izquierda hasta el final de la línea son "
"ignorados."

#: ../Doc/library/re.rst:810
msgid ""
"This means that the two following regular expression objects that match a "
"decimal number are functionally equal::"
msgstr ""
"Esto significa que los dos siguientes objetos expresión regular que "
"coinciden con un número decimal son funcionalmente iguales::"

#: ../Doc/library/re.rst:818
msgid "Corresponds to the inline flag ``(?x)``."
msgstr "Corresponde al indicador en línea ``(?x)``."

#: ../Doc/library/re.rst:822
msgid "Functions"
msgstr "Funciones"

#: ../Doc/library/re.rst:826
msgid ""
"Compile a regular expression pattern into a :ref:`regular expression object "
"<re-objects>`, which can be used for matching using its :func:`~Pattern."
"match`, :func:`~Pattern.search` and other methods, described below."
msgstr ""
"Compila un patrón de expresión regular en un :ref:`objeto de expresión "
"regular <re-objects>`, que puede ser usado para las coincidencias usando :"
"func:`~Pattern.match`, :func:`~Pattern.search` y otros métodos, descritos "
"más adelante."

#: ../Doc/library/re.rst:831
msgid ""
"The expression's behaviour can be modified by specifying a *flags* value. "
"Values can be any of the following variables, combined using bitwise OR (the "
"``|`` operator)."
msgstr ""
"El comportamiento de la expresión puede modificarse especificando un valor "
"de *indicadores*. Los valores pueden ser cualquiera de las siguientes "
"variables, combinadas usando el operador OR (el operador ``|``)."

#: ../Doc/library/re.rst:835
msgid "The sequence ::"
msgstr "La secuencia ::"

#: ../Doc/library/re.rst:840
msgid "is equivalent to ::"
msgstr "es equivalente a ::"

#: ../Doc/library/re.rst:844
msgid ""
"but using :func:`re.compile` and saving the resulting regular expression "
"object for reuse is more efficient when the expression will be used several "
"times in a single program."
msgstr ""
"pero usando :func:`re.compile` y guardando el objeto resultante de la "
"expresión regular para su reutilización es más eficiente cuando la expresión "
"será usada varias veces en un solo programa."

#: ../Doc/library/re.rst:850
msgid ""
"The compiled versions of the most recent patterns passed to :func:`re."
"compile` and the module-level matching functions are cached, so programs "
"that use only a few regular expressions at a time needn't worry about "
"compiling regular expressions."
msgstr ""
"Las versiones compiladas de los patrones más recientes pasaron a :func:`re."
"compile` y las funciones de coincidencia a nivel de módulo están en caché, "
"así que los programas que usan sólo unas pocas expresiones regulares a la "
"vez no tienen que preocuparse de compilar expresiones regulares."

#: ../Doc/library/re.rst:858
msgid ""
"Scan through *string* looking for the first location where the regular "
"expression *pattern* produces a match, and return a corresponding :class:"
"`~re.Match`. Return ``None`` if no position in the string matches the "
"pattern; note that this is different from finding a zero-length match at "
"some point in the string."
msgstr ""
"Explora la cadena de caracteres *string* en busca de la primera ubicación "
"donde el patrón *pattern* de la expresión regular produce una coincidencia, "
"y retorna un :class:`~re.Match` correspondiente. Retorna ``None`` si ninguna "
"posición en la cadena coincide con el patrón; nota que esto es diferente a "
"encontrar una coincidencia de longitud cero en algún punto de la cadena."

#: ../Doc/library/re.rst:866
msgid ""
"If zero or more characters at the beginning of *string* match the regular "
"expression *pattern*, return a corresponding :class:`~re.Match`.  Return "
"``None`` if the string does not match the pattern; note that this is "
"different from a zero-length match."
msgstr ""
"Si cero o más caracteres al principio de la cadena *string* coinciden con el "
"patrón *pattern* de la expresión regular, retorna un :class:`~re.Match` "
"correspondiente. Retorna ``None`` si la cadena no coincide con el patrón; "
"notar que esto es diferente de una coincidencia de longitud cero."

#: ../Doc/library/re.rst:871
msgid ""
"Note that even in :const:`MULTILINE` mode, :func:`re.match` will only match "
"at the beginning of the string and not at the beginning of each line."
msgstr ""
"Notar que incluso en el modo :const:`MULTILINE`, :func:`re.match` sólo "
"coincidirá al principio de la cadena y no al principio de cada línea."

#: ../Doc/library/re.rst:874
msgid ""
"If you want to locate a match anywhere in *string*, use :func:`search` "
"instead (see also :ref:`search-vs-match`)."
msgstr ""
"Si se quiere localizar una coincidencia en cualquier lugar de la *string* "
"(\"cadena\"), se utiliza :func:`search` en su lugar (ver también :ref:"
"`search-vs-match`)."

#: ../Doc/library/re.rst:880
msgid ""
"If the whole *string* matches the regular expression *pattern*, return a "
"corresponding :class:`~re.Match`.  Return ``None`` if the string does not "
"match the pattern; note that this is different from a zero-length match."
msgstr ""
"Si toda la cadena *string* coincide con el patrón *pattern* de la expresión "
"regular, retorna un :class:`~re.Match` correspondiente. Retorna ``None`` si "
"la cadena no coincide con el patrón; notar que esto es diferente de una "
"coincidencia de longitud cero."

#: ../Doc/library/re.rst:889
msgid ""
"Split *string* by the occurrences of *pattern*.  If capturing parentheses "
"are used in *pattern*, then the text of all groups in the pattern are also "
"returned as part of the resulting list. If *maxsplit* is nonzero, at most "
"*maxsplit* splits occur, and the remainder of the string is returned as the "
"final element of the list. ::"
msgstr ""
"Divide la *string* (\"cadena\") por el número de ocurrencias del *pattern* "
"(\"patrón\").  Si se utilizan paréntesis de captura en *pattern*, entonces "
"el texto de todos los grupos en el patrón también se retornan como parte de "
"la lista resultante. Si *maxsplit* (máxima divisibilidad) es distinta de "
"cero, como mucho se producen *maxsplit* divisiones, y el resto de la cadena "
"se retorna como elemento final de la lista. ::"

#: ../Doc/library/re.rst:904
msgid ""
"If there are capturing groups in the separator and it matches at the start "
"of the string, the result will start with an empty string.  The same holds "
"for the end of the string::"
msgstr ""
"Si hay grupos de captura en el separador y coincide al principio de la "
"cadena, el resultado comenzará con una cadena vacía.  Lo mismo ocurre con el "
"final de la cadena::"

#: ../Doc/library/re.rst:911
msgid ""
"That way, separator components are always found at the same relative indices "
"within the result list."
msgstr ""
"De esa manera, los componentes de los separadores se encuentran siempre en "
"los mismos índices relativos dentro de la lista de resultados."

#: ../Doc/library/re.rst:914
msgid ""
"Empty matches for the pattern split the string only when not adjacent to a "
"previous empty match."
msgstr ""
"Las coincidencias vacías para el patrón dividen la cadena sólo cuando no "
"están adyacentes a una coincidencia vacía anterior."

#: ../Doc/library/re.rst:924 ../Doc/library/re.rst:1015
#: ../Doc/library/re.rst:1044
msgid "Added the optional flags argument."
msgstr "Se añadió el argumento de los indicadores opcionales."

#: ../Doc/library/re.rst:927
msgid ""
"Added support of splitting on a pattern that could match an empty string."
msgstr ""
"Se añadió el soporte de la división en un patrón que podría coincidir con "
"una cadena vacía."

#: ../Doc/library/re.rst:933
msgid ""
"Return all non-overlapping matches of *pattern* in *string*, as a list of "
"strings or tuples.  The *string* is scanned left-to-right, and matches are "
"returned in the order found.  Empty matches are included in the result."
msgstr ""
"Retorna todas las coincidencias no superpuestas de *pattern* en *string*, "
"como una lista de strings o tuplas. El *string* se escanea de izquierda a "
"derecha y las coincidencias se retornan en el orden en que se encuentran. "
"Las coincidencias vacías se incluyen en el resultado."

#: ../Doc/library/re.rst:937
msgid ""
"The result depends on the number of capturing groups in the pattern. If "
"there are no groups, return a list of strings matching the whole pattern.  "
"If there is exactly one group, return a list of strings matching that "
"group.  If multiple groups are present, return a list of tuples of strings "
"matching the groups.  Non-capturing groups do not affect the form of the "
"result."
msgstr ""
"El resultado depende del número de grupos detectados en el patrón. Si no hay "
"grupos, retorna una lista de strings que coincidan con el patrón completo. "
"Si existe exactamente un grupo, retorna una lista de strings que coincidan "
"con ese grupo. Si hay varios grupos presentes, retorna una lista de tuplas "
"de strings que coinciden con los grupos. Los grupos que no son detectados no "
"afectan la forma del resultado."

#: ../Doc/library/re.rst:949 ../Doc/library/re.rst:960
msgid "Non-empty matches can now start just after a previous empty match."
msgstr ""
"Las coincidencias no vacías ahora pueden empezar justo después de una "
"coincidencia vacía anterior."

#: ../Doc/library/re.rst:955
msgid ""
"Return an :term:`iterator` yielding :class:`~re.Match` objects over all non-"
"overlapping matches for the RE *pattern* in *string*.  The *string* is "
"scanned left-to-right, and matches are returned in the order found.  Empty "
"matches are included in the result."
msgstr ""
"Retorna un :term:`iterador <iterator>` que produce objetos :class:`~re."
"Match` sobre todas las coincidencias no superpuestas para el patrón de RE "
"*pattern* en la *string*. La *string* es examinada de izquierda a derecha, y "
"las coincidencias son retornadas en el orden en que se encuentran. Las "
"coincidencias vacías se incluyen en el resultado."

#: ../Doc/library/re.rst:966
msgid ""
"Return the string obtained by replacing the leftmost non-overlapping "
"occurrences of *pattern* in *string* by the replacement *repl*.  If the "
"pattern isn't found, *string* is returned unchanged.  *repl* can be a string "
"or a function; if it is a string, any backslash escapes in it are "
"processed.  That is, ``\\n`` is converted to a single newline character, "
"``\\r`` is converted to a carriage return, and so forth.  Unknown escapes of "
"ASCII letters are reserved for future use and treated as errors.  Other "
"unknown escapes such as ``\\&`` are left alone. Backreferences, such as "
"``\\6``, are replaced with the substring matched by group 6 in the pattern. "
"For example::"
msgstr ""
"Retorna la cadena obtenida reemplazando las ocurrencias no superpuestas del "
"*pattern* (\"patrón\") en la *string* (\"cadena\") por el reemplazo de "
"*repl*.  Si el patrón no se encuentra, se retorna *string* sin cambios.  "
"*repl* puede ser una cadena o una función; si es una cadena, cualquier barra "
"inversa escapada en ella es procesada.  Es decir, ``\\n`` se convierte en un "
"carácter de una sola línea nueva, ``\\r`` se convierte en un retorno de "
"carro, y así sucesivamente.  Los escapes desconocidos de las letras ASCII se "
"reservan para un uso futuro y se tratan como errores.  Otros escapes "
"desconocidos como ``\\&`` no se utilizan. Las referencias inversas, como "
"``\\6``, se reemplazan por la subcadena que corresponde al grupo 6 del "
"patrón. Por ejemplo::"

#: ../Doc/library/re.rst:982
msgid ""
"If *repl* is a function, it is called for every non-overlapping occurrence "
"of *pattern*.  The function takes a single :class:`~re.Match` argument, and "
"returns the replacement string.  For example::"
msgstr ""
"Si *repl* es una función, se llama para cada ocurrencia no superpuesta de "
"*pattern*.  La función toma un solo argumento :class:`~re.Match`, y retorna "
"la cadena de sustitución.  Por ejemplo::"

#: ../Doc/library/re.rst:995
msgid "The pattern may be a string or a :class:`~re.Pattern`."
msgstr "El patrón puede ser una cadena o un :class:`~re.Pattern`."

#: ../Doc/library/re.rst:997
msgid ""
"The optional argument *count* is the maximum number of pattern occurrences "
"to be replaced; *count* must be a non-negative integer.  If omitted or zero, "
"all occurrences will be replaced. Empty matches for the pattern are replaced "
"only when not adjacent to a previous empty match, so ``sub('x*', '-', "
"'abxd')`` returns ``'-a-b--d-'``."
msgstr ""
"El argumento opcional *count* (\"recuento\") es el número máximo de "
"ocurrencias de patrones a ser reemplazados; *count* debe ser un número "
"entero no negativo.  Si se omite o es cero, todas las ocurrencias serán "
"reemplazadas. Las coincidencias vacías del patrón se reemplazan sólo cuando "
"no están adyacentes a una coincidencia vacía anterior, así que ``sub('x*', "
"'-', 'abxd')`` retorna ``'-a-b--d-'``."

#: ../Doc/library/re.rst:1005
msgid ""
"In string-type *repl* arguments, in addition to the character escapes and "
"backreferences described above, ``\\g<name>`` will use the substring matched "
"by the group named ``name``, as defined by the ``(?P<name>...)`` syntax. "
"``\\g<number>`` uses the corresponding group number; ``\\g<2>`` is therefore "
"equivalent to ``\\2``, but isn't ambiguous in a replacement such as "
"``\\g<2>0``.  ``\\20`` would be interpreted as a reference to group 20, not "
"a reference to group 2 followed by the literal character ``'0'``.  The "
"backreference ``\\g<0>`` substitutes in the entire substring matched by the "
"RE."
msgstr ""
"En los argumentos *repl* de tipo cadena, además de los escapes de caracteres "
"y las referencias inversas descritas anteriormente, ``\\g<name>`` usará la "
"subcadena coincidente con el grupo llamado ``name``, como se define en la "
"sintaxis ``(?P<name>...)``. ``\\g<number>`` utiliza el número de grupo "
"correspondiente; ``\\g<2>`` es por lo tanto equivalente a ``\\2``, pero no "
"es ambiguo en un reemplazo como sucede con ``\\g<2>0``.  ``\\20`` se "
"interpretaría como una referencia al grupo 20, no como una referencia al "
"grupo 2 seguido del carácter literal ``'0'``.  La referencia inversa "
"``\\g<0>`` sustituye en toda la subcadena coincidente con la RE."

#: ../Doc/library/re.rst:1018 ../Doc/library/re.rst:1047
#: ../Doc/library/re.rst:1290
msgid "Unmatched groups are replaced with an empty string."
msgstr "Los grupos no coincidentes son reemplazados por una cadena vacía."

#: ../Doc/library/re.rst:1021
msgid ""
"Unknown escapes in *pattern* consisting of ``'\\'`` and an ASCII letter now "
"are errors."
msgstr ""
"Los escapes desconocidos en el *pattern* que consisten en ``'\\'`` y una "
"letra ASCII ahora son errores."

#: ../Doc/library/re.rst:1025
msgid ""
"Unknown escapes in *repl* consisting of ``'\\'`` and an ASCII letter now are "
"errors."
msgstr ""
"Los escapes desconocidos en *repl* que consisten en ``'\\'`` y una letra "
"ASCII ahora son errores."

#: ../Doc/library/re.rst:1029
msgid ""
"Empty matches for the pattern are replaced when adjacent to a previous non-"
"empty match."
msgstr ""
"Las coincidencias vacías para el patrón se reemplazan cuando están "
"adyacentes a una coincidencia anterior no vacía."

#: ../Doc/library/re.rst:1033
msgid ""
"Group *id* can only contain ASCII digits. In :class:`bytes` replacement "
"strings, group *name* can only contain bytes in the ASCII range "
"(``b'\\x00'``-``b'\\x7f'``)."
msgstr ""
"El *id* del grupo solo puede contener dígitos ASCII. En las cadenas de "
"reemplazo :class:`bytes`, el nombre del grupo *name* solo puede contener "
"bytes en el rango ASCII (``b'\\x00'``-``b'\\x7f'``)."

#: ../Doc/library/re.rst:1041
msgid ""
"Perform the same operation as :func:`sub`, but return a tuple ``(new_string, "
"number_of_subs_made)``."
msgstr ""
"Realiza la misma operación que :func:`sub`, pero retorna una tupla "
"``(new_string, number_of_subs_made)``."

#: ../Doc/library/re.rst:1053
msgid ""
"Escape special characters in *pattern*. This is useful if you want to match "
"an arbitrary literal string that may have regular expression metacharacters "
"in it.  For example::"
msgstr ""
"Caracteres de escape especiales en *pattern* (\" patrón\"). Esto es útil si "
"quieres hacer coincidir una cadena literal arbitraria que puede tener "
"metacaracteres de expresión regular en ella.  Por ejemplo::"

#: ../Doc/library/re.rst:1068
msgid ""
"This function must not be used for the replacement string in :func:`sub` "
"and :func:`subn`, only backslashes should be escaped.  For example::"
msgstr ""
"Esta función no debe usarse para la cadena de reemplazo en :func:`sub` y :"
"func:`subn`, sólo deben escaparse las barras inversas.  Por ejemplo::"

#: ../Doc/library/re.rst:1076
msgid "The ``'_'`` character is no longer escaped."
msgstr "El carácter de ``'_'`` ya no se escapa."

#: ../Doc/library/re.rst:1079
msgid ""
"Only characters that can have special meaning in a regular expression are "
"escaped. As a result, ``'!'``, ``'\"'``, ``'%'``, ``\"'\"``, ``','``, "
"``'/'``, ``':'``, ``';'``, ``'<'``, ``'='``, ``'>'``, ``'@'``, and ``\"`\"`` "
"are no longer escaped."
msgstr ""
"Sólo se escapan los caracteres que pueden tener un significado especial en "
"una expresión regular. Como resultado, ``'!'``, ``'\"'``, ``'%'``, "
"``\"'\"``, ``','``, ``'/'``, ``':'``, ``';'``, ``'<'``, ``'='``, ``'>'``, "
"``'@'`` y ``\"`\"`` ya no se escapan."

#: ../Doc/library/re.rst:1088
msgid "Clear the regular expression cache."
msgstr "Despeja la caché de expresión regular."

#: ../Doc/library/re.rst:1092
msgid "Exceptions"
msgstr "Excepciones"

#: ../Doc/library/re.rst:1096
msgid ""
"Exception raised when a string passed to one of the functions here is not a "
"valid regular expression (for example, it might contain unmatched "
"parentheses) or when some other error occurs during compilation or "
"matching.  It is never an error if a string contains no match for a "
"pattern.  The error instance has the following additional attributes:"
msgstr ""
"Excepción señalada cuando una cadena enviada a una de las funciones "
"descritas aquí no es una expresión regular válida (por ejemplo, podría "
"contener paréntesis no coincidentes) o cuando se produce algún otro error "
"durante la compilación o la coincidencia.  Nunca es un error si una cadena "
"no contiene ninguna coincidencia para un patrón.  La instancia de error "
"tiene los siguientes atributos adicionales:"

#: ../Doc/library/re.rst:1104
msgid "The unformatted error message."
msgstr "El mensaje de error sin formato."

#: ../Doc/library/re.rst:1108
msgid "The regular expression pattern."
msgstr "El patrón de expresión regular."

#: ../Doc/library/re.rst:1112
msgid "The index in *pattern* where compilation failed (may be ``None``)."
msgstr ""
"El índice en *pattern* (\"patrón\") donde la compilación falló (puede ser "
"``None``)."

#: ../Doc/library/re.rst:1116
msgid "The line corresponding to *pos* (may be ``None``)."
msgstr "La línea correspondiente a *pos* (puede ser ``None``)."

#: ../Doc/library/re.rst:1120
msgid "The column corresponding to *pos* (may be ``None``)."
msgstr "La columna correspondiente a *pos* (puede ser ``None``)."

#: ../Doc/library/re.rst:1122
msgid "Added additional attributes."
msgstr "Se añadieron atributos adicionales."

#: ../Doc/library/re.rst:1128
msgid "Regular Expression Objects"
msgstr "Objetos expresión regular"

#: ../Doc/library/re.rst:1132
msgid "Compiled regular expression object returned by :func:`re.compile`."
msgstr "Objeto de expresión regular compilada devuelto por :func:`re.compile`."

#: ../Doc/library/re.rst:1134
msgid ""
":py:class:`re.Pattern` supports ``[]`` to indicate a Unicode (str) or bytes "
"pattern. See :ref:`types-genericalias`."
msgstr ""
":py:class:`re.Pattern` soporta ``[]`` para indicar un patrón Unicode (str) o "
"de bytes. Ver :ref:`types-genericalias`."

#: ../Doc/library/re.rst:1140
msgid ""
"Scan through *string* looking for the first location where this regular "
"expression produces a match, and return a corresponding :class:`~re.Match`. "
"Return ``None`` if no position in the string matches the pattern; note that "
"this is different from finding a zero-length match at some point in the "
"string."
msgstr ""
"Escanea a través de la cadena *string* buscando la primera ubicación donde "
"esta expresión regular produce una coincidencia, y retorna un :class:`~re."
"Match` correspondiente.  Retorna ``None`` si ninguna posición en la cadena "
"coincide con el patrón; notar que esto es diferente a encontrar una "
"coincidencia de longitud cero en algún punto de la cadena."

#: ../Doc/library/re.rst:1145
msgid ""
"The optional second parameter *pos* gives an index in the string where the "
"search is to start; it defaults to ``0``.  This is not completely equivalent "
"to slicing the string; the ``'^'`` pattern character matches at the real "
"beginning of the string and at positions just after a newline, but not "
"necessarily at the index where the search is to start."
msgstr ""
"El segundo parámetro opcional *pos* proporciona un índice en la cadena donde "
"la búsqueda debe comenzar; por defecto es ``0``.  Esto no es completamente "
"equivalente a dividir la cadena; el patrón de carácter ``'^'`` coincide en "
"el inicio real de la cadena y en las posiciones justo después de una nueva "
"línea, pero no necesariamente en el índice donde la búsqueda va a comenzar."

#: ../Doc/library/re.rst:1151
msgid ""
"The optional parameter *endpos* limits how far the string will be searched; "
"it will be as if the string is *endpos* characters long, so only the "
"characters from *pos* to ``endpos - 1`` will be searched for a match.  If "
"*endpos* is less than *pos*, no match will be found; otherwise, if *rx* is a "
"compiled regular expression object, ``rx.search(string, 0, 50)`` is "
"equivalent to ``rx.search(string[:50], 0)``. ::"
msgstr ""
"El parámetro opcional *endpos* limita hasta dónde se buscará la cadena; será "
"como si la cadena fuera de *endpos* caracteres de largo, por lo que sólo se "
"buscará una coincidencia entre los caracteres de *pos* a ``endpos - 1``.  Si "
"*endpos* es menor que *pos*, no se encontrará ninguna coincidencia; de lo "
"contrario, si *rx* es un objeto de expresión regular compilado, ``rx."
"search(string, 0, 50)`` es equivalente a ``rx.search(string[:50], 0)``. ::"

#: ../Doc/library/re.rst:1166
msgid ""
"If zero or more characters at the *beginning* of *string* match this regular "
"expression, return a corresponding :class:`~re.Match`. Return ``None`` if "
"the string does not match the pattern; note that this is different from a "
"zero-length match."
msgstr ""
"Si cero o más caracteres en el comienzo *beginning* de la cadena *string* "
"coinciden con esta expresión regular, retorna un :class:`~re.Match` "
"correspondiente. Retorna ``None`` si la cadena no coincide con el patrón; "
"notar que esto es diferente de una coincidencia de longitud cero."

#: ../Doc/library/re.rst:1171 ../Doc/library/re.rst:1189
msgid ""
"The optional *pos* and *endpos* parameters have the same meaning as for the :"
"meth:`~Pattern.search` method. ::"
msgstr ""
"Los parámetros opcionales *pos* y *endpos* tienen el mismo significado que "
"para el método :meth:`~Pattern.search`. ::"

#: ../Doc/library/re.rst:1179
msgid ""
"If you want to locate a match anywhere in *string*, use :meth:`~Pattern."
"search` instead (see also :ref:`search-vs-match`)."
msgstr ""
"Si se quiere encontrar una coincidencia en cualquier lugar de *string*, "
"utilizar :meth:`~Pattern.search` en su lugar (ver también :ref:`search-vs-"
"match`)."

#: ../Doc/library/re.rst:1185
msgid ""
"If the whole *string* matches this regular expression, return a "
"corresponding :class:`~re.Match`.  Return ``None`` if the string does not "
"match the pattern; note that this is different from a zero-length match."
msgstr ""
"Si toda la cadena *string* coincide con esta expresión regular, retorna un :"
"class:`~re.Match` correspondiente.  Retorna ``None`` si la cadena no "
"coincide con el patrón; notar que esto es diferente de una coincidencia de "
"longitud cero."

#: ../Doc/library/re.rst:1203
msgid "Identical to the :func:`split` function, using the compiled pattern."
msgstr "Idéntico a la función :func:`split`, usando el patrón compilado."

#: ../Doc/library/re.rst:1208
msgid ""
"Similar to the :func:`findall` function, using the compiled pattern, but "
"also accepts optional *pos* and *endpos* parameters that limit the search "
"region like for :meth:`search`."
msgstr ""
"Similar a la función :func:`findall`, usando el patrón compilado, pero "
"también acepta parámetros opcionales *pos* y *endpos* que limitan la región "
"de búsqueda como para :meth:`search`."

#: ../Doc/library/re.rst:1215
msgid ""
"Similar to the :func:`finditer` function, using the compiled pattern, but "
"also accepts optional *pos* and *endpos* parameters that limit the search "
"region like for :meth:`search`."
msgstr ""
"Similar a la función :func:`finditer`, usando el patrón compilado, pero "
"también acepta parámetros opcionales *pos* y *endpos* que limitan la región "
"de búsqueda como para :meth:`search`."

#: ../Doc/library/re.rst:1222
msgid "Identical to the :func:`sub` function, using the compiled pattern."
msgstr "Idéntico a la función :func:`sub`, usando el patrón compilado."

#: ../Doc/library/re.rst:1227
msgid "Identical to the :func:`subn` function, using the compiled pattern."
msgstr "Idéntico a la función :func:`subn`, usando el patrón compilado."

#: ../Doc/library/re.rst:1232
msgid ""
"The regex matching flags.  This is a combination of the flags given to :func:"
"`.compile`, any ``(?...)`` inline flags in the pattern, and implicit flags "
"such as :data:`UNICODE` if the pattern is a Unicode string."
msgstr ""
"Los indicadores regex de coincidencia. Esta es una combinación de los "
"indicadores dados a :func:`.compile`, cualquier indicador ``(?...)`` en "
"línea en el patrón, y los indicadores implícitos como :data:`UNICODE` si el "
"patrón es una cadena de Unicode."

#: ../Doc/library/re.rst:1239
msgid "The number of capturing groups in the pattern."
msgstr "El número de grupos de captura en el patrón."

#: ../Doc/library/re.rst:1244
msgid ""
"A dictionary mapping any symbolic group names defined by ``(?P<id>)`` to "
"group numbers.  The dictionary is empty if no symbolic groups were used in "
"the pattern."
msgstr ""
"Un diccionario que mapea cualquier nombre de grupo simbólico definido por "
"``(?P<id>)`` para agrupar números.  El diccionario está vacío si no se "
"utilizaron grupos simbólicos en el patrón."

#: ../Doc/library/re.rst:1251
msgid "The pattern string from which the pattern object was compiled."
msgstr ""
"La cadena de patrones a partir de la cual el objeto de patrón fue compilado."

#: ../Doc/library/re.rst:1254
msgid ""
"Added support of :func:`copy.copy` and :func:`copy.deepcopy`.  Compiled "
"regular expression objects are considered atomic."
msgstr ""
"Se añadió el soporte de :func:`copy.copy` y :func:`copy.deepcopy`.  Los "
"objetos expresión regular compilados se consideran atómicos."

#: ../Doc/library/re.rst:1262
msgid "Match Objects"
msgstr "Objetos de coincidencia"

#: ../Doc/library/re.rst:1264
msgid ""
"Match objects always have a boolean value of ``True``. Since :meth:`~Pattern."
"match` and :meth:`~Pattern.search` return ``None`` when there is no match, "
"you can test whether there was a match with a simple ``if`` statement::"
msgstr ""
"Los objetos de coincidencia siempre tienen un valor booleano de ``True`` "
"(\"Verdadero\"). Ya que :meth:`~Pattern.match` y :meth:`~Pattern.search` "
"retornan ``None`` cuando no hay coincidencia. Se puede probar si hubo una "
"coincidencia con una simple declaración ``if``::"

#: ../Doc/library/re.rst:1275
msgid "Match object returned by successful ``match``\\ es and ``search``\\ es."
msgstr "Objeto Match devuelto por llamadas exitosas a ``match`` y ``search``."

#: ../Doc/library/re.rst:1277
msgid ""
":py:class:`re.Match` supports ``[]`` to indicate a Unicode (str) or bytes "
"match. See :ref:`types-genericalias`."
msgstr ""
":py:class:`re.Match` soporta ``[]`` para indicar una coincidencia Unicode "
"(str) o de bytes. Ver :ref:`types-genericalias`."

#: ../Doc/library/re.rst:1283
msgid ""
"Return the string obtained by doing backslash substitution on the template "
"string *template*, as done by the :meth:`~Pattern.sub` method. Escapes such "
"as ``\\n`` are converted to the appropriate characters, and numeric "
"backreferences (``\\1``, ``\\2``) and named backreferences (``\\g<1>``, "
"``\\g<name>``) are replaced by the contents of the corresponding group."
msgstr ""
"Retorna la cadena obtenida al hacer la sustitución de la barra inversa en la "
"cadena de la plantilla *template*, como se hace con el método :meth:"
"`~Pattern.sub`. Escapes como ``\\n`` son convertidos a los caracteres "
"apropiados, y las referencias inversas numéricas (``\\1``, ``\\2``) y las "
"referencias inversas con nombre (``\\g<1>``, ``\\g<name>``) son reemplazadas "
"por el contenido del grupo correspondiente."

#: ../Doc/library/re.rst:1295
msgid ""
"Returns one or more subgroups of the match.  If there is a single argument, "
"the result is a single string; if there are multiple arguments, the result "
"is a tuple with one item per argument. Without arguments, *group1* defaults "
"to zero (the whole match is returned). If a *groupN* argument is zero, the "
"corresponding return value is the entire matching string; if it is in the "
"inclusive range [1..99], it is the string matching the corresponding "
"parenthesized group.  If a group number is negative or larger than the "
"number of groups defined in the pattern, an :exc:`IndexError` exception is "
"raised. If a group is contained in a part of the pattern that did not match, "
"the corresponding result is ``None``. If a group is contained in a part of "
"the pattern that matched multiple times, the last match is returned. ::"
msgstr ""
"Retorna uno o más subgrupos de la coincidencia.  Si hay un solo argumento, "
"el resultado es una sola cadena; si hay múltiples argumentos, el resultado "
"es una tupla con un elemento por argumento. Sin argumentos, *group1* tiene "
"un valor por defecto de cero (se retorna la coincidencia completa). Si un "
"argumento *groupN* es cero, el valor de retorno correspondiente es toda la "
"cadena coincidente; si está en el rango inclusivo [1..99], es la cadena "
"coincidente con el grupo correspondiente entre paréntesis.  Si un número de "
"grupo es negativo o mayor que el número de grupos definidos en el patrón, se "
"produce una excepción :exc:`IndexError`. Si un grupo está contenido en una "
"parte del patrón que no coincidió, el resultado correspondiente es ``None``. "
"Si un grupo está contenido en una parte del patrón que coincidió varias "
"veces, se retorna la última coincidencia. ::"

#: ../Doc/library/re.rst:1317
msgid ""
"If the regular expression uses the ``(?P<name>...)`` syntax, the *groupN* "
"arguments may also be strings identifying groups by their group name.  If a "
"string argument is not used as a group name in the pattern, an :exc:"
"`IndexError` exception is raised."
msgstr ""
"Si la expresión regular usa la sintaxis ``(?P<name>...)``, los argumentos "
"*groupN* también pueden ser cadenas que identifican a los grupos por su "
"nombre de grupo.  Si un argumento de cadena no se usa como nombre de grupo "
"en el patrón, se produce una excepción :exc:`IndexError`."

#: ../Doc/library/re.rst:1322
msgid "A moderately complicated example::"
msgstr "Un ejemplo moderadamente complicado::"

#: ../Doc/library/re.rst:1330
msgid "Named groups can also be referred to by their index::"
msgstr "Los grupos nombrados también pueden ser referidos por su índice::"

#: ../Doc/library/re.rst:1337
msgid "If a group matches multiple times, only the last match is accessible::"
msgstr ""
"Si un grupo coincide varias veces, sólo se puede acceder a la última "
"coincidencia::"

#: ../Doc/library/re.rst:1346
msgid ""
"This is identical to ``m.group(g)``.  This allows easier access to an "
"individual group from a match::"
msgstr ""
"Esto es idéntico a ``m.group(g)``.  Esto permite un acceso más fácil a un "
"grupo individual de una coincidencia::"

#: ../Doc/library/re.rst:1357
msgid "Named groups are supported as well::"
msgstr "Los grupos con nombre también son compatibles::"

#: ../Doc/library/re.rst:1370
msgid ""
"Return a tuple containing all the subgroups of the match, from 1 up to "
"however many groups are in the pattern.  The *default* argument is used for "
"groups that did not participate in the match; it defaults to ``None``."
msgstr ""
"Retorna una tupla que contenga todos los subgrupos de la coincidencia, desde "
"1 hasta tantos grupos como haya en el patrón.  El argumento *default* (\"por "
"defecto\") se utiliza para los grupos que no participaron en la "
"coincidencia; por defecto es ``None``."

#: ../Doc/library/re.rst:1374 ../Doc/library/re.rst:1599
msgid "For example::"
msgstr "Por ejemplo::"

#: ../Doc/library/re.rst:1380
msgid ""
"If we make the decimal place and everything after it optional, not all "
"groups might participate in the match.  These groups will default to "
"``None`` unless the *default* argument is given::"
msgstr ""
"Si hacemos que el decimal y todo lo que sigue sea opcional, no todos los "
"grupos podrían participar en la coincidencia.  Estos grupos serán por "
"defecto ``None`` a menos que se utilice el argumento *default*::"

#: ../Doc/library/re.rst:1393
msgid ""
"Return a dictionary containing all the *named* subgroups of the match, keyed "
"by the subgroup name.  The *default* argument is used for groups that did "
"not participate in the match; it defaults to ``None``.  For example::"
msgstr ""
"Retorna un diccionario que contiene todos los subgrupos *nombrados* de la "
"coincidencia, tecleado por el nombre del subgrupo.  El argumento *por "
"defecto* se usa para los grupos que no participaron en la coincidencia; por "
"defecto es ``None``.  Por ejemplo::"

#: ../Doc/library/re.rst:1405
msgid ""
"Return the indices of the start and end of the substring matched by *group*; "
"*group* defaults to zero (meaning the whole matched substring). Return "
"``-1`` if *group* exists but did not contribute to the match.  For a match "
"object *m*, and a group *g* that did contribute to the match, the substring "
"matched by group *g* (equivalent to ``m.group(g)``) is ::"
msgstr ""
"Retorna los índices del comienzo y el final de la subcadena coincidiendo con "
"el *group*; el *group* por defecto es cero (es decir, toda la subcadena "
"coincidente). Retorna ``-1`` si *grupo* existe pero no ha contribuido a la "
"coincidencia.  Para un objeto coincidente *m*, y un grupo *g* que sí "
"contribuyó a la coincidencia, la subcadena coincidente con el grupo *g* "
"(equivalente a ``m.group(g)``) es ::"

#: ../Doc/library/re.rst:1413
msgid ""
"Note that ``m.start(group)`` will equal ``m.end(group)`` if *group* matched "
"a null string.  For example, after ``m = re.search('b(c?)', 'cba')``, ``m."
"start(0)`` is 1, ``m.end(0)`` is 2, ``m.start(1)`` and ``m.end(1)`` are both "
"2, and ``m.start(2)`` raises an :exc:`IndexError` exception."
msgstr ""
"Notar que ``m.start(group)`` será igual a ``m.end(group)`` si *group* "
"coincidió con una cadena nula.  Por ejemplo, después de ``m = re."
"search('b(c?)', 'cba')``, ``m.start(0)`` es 1, ``m.end(0)`` es 2, ``m."
"start(1)`` y ``m.end(1)`` son ambos 2, y ``m.start(2)`` produce una "
"excepción :exc:`IndexError`."

#: ../Doc/library/re.rst:1418
msgid "An example that will remove *remove_this* from email addresses::"
msgstr ""
"Un ejemplo que eliminará *remove_this* (\"quita esto\") de las direcciones "
"de correo electrónico::"

#: ../Doc/library/re.rst:1428
msgid ""
"For a match *m*, return the 2-tuple ``(m.start(group), m.end(group))``. Note "
"that if *group* did not contribute to the match, this is ``(-1, -1)``. "
"*group* defaults to zero, the entire match."
msgstr ""
"Para una coincidencia *m*, retorna la tupla-2 ``(m.inicio(grupo), m."
"fin(grupo))``. Notar que si *group* no contribuyó a la coincidencia, esto es "
"``(-1, -1)``. *group* por se convierte a cero para toda la coincidencia."

#: ../Doc/library/re.rst:1435
msgid ""
"The value of *pos* which was passed to the :meth:`~Pattern.search` or :meth:"
"`~Pattern.match` method of a :ref:`regex object <re-objects>`.  This is the "
"index into the string at which the RE engine started looking for a match."
msgstr ""
"El valor de *pos* que fue pasado al método :meth:`~Pattern.search` o :meth:"
"`~Pattern.match` de un :ref:`objeto regex <re-objects>`.  Este es el índice "
"de la cadena en la que el motor RE comenzó a buscar una coincidencia."

#: ../Doc/library/re.rst:1442
msgid ""
"The value of *endpos* which was passed to the :meth:`~Pattern.search` or :"
"meth:`~Pattern.match` method of a :ref:`regex object <re-objects>`.  This is "
"the index into the string beyond which the RE engine will not go."
msgstr ""
"El valor de *endpos* que se pasó al método :meth:`~Pattern.search` o :meth:"
"`~Pattern.match` de un :ref:`objeto regex <re-objects>`.  Este es el índice "
"de la cadena más allá de la cual el motor RE no irá."

#: ../Doc/library/re.rst:1449
msgid ""
"The integer index of the last matched capturing group, or ``None`` if no "
"group was matched at all. For example, the expressions ``(a)b``, ``((a)"
"(b))``, and ``((ab))`` will have ``lastindex == 1`` if applied to the string "
"``'ab'``, while the expression ``(a)(b)`` will have ``lastindex == 2``, if "
"applied to the same string."
msgstr ""
"El índice entero del último grupo de captura coincidente, o``None`` si no "
"hay ningún grupo coincidente. Por ejemplo, las expresiones ``(a)b``, ``((a)"
"(b))`` y ``((ab))`` tendrán ``lastindex == 1`` si se aplican a la cadena "
"``'ab'``, mientras que la expresión ``(a)(b)`` tendrá ``lastindex == 2``, si "
"se aplica a la misma cadena."

#: ../Doc/library/re.rst:1458
msgid ""
"The name of the last matched capturing group, or ``None`` if the group "
"didn't have a name, or if no group was matched at all."
msgstr ""
"El nombre del último grupo capturador coincidente, o``None`` si el grupo no "
"tenía nombre, o si no había ningún grupo coincidente."

#: ../Doc/library/re.rst:1464
msgid ""
"The :ref:`regular expression object <re-objects>` whose :meth:`~Pattern."
"match` or :meth:`~Pattern.search` method produced this match instance."
msgstr ""
"El :ref:`objeto de expresión regular <re-objects>` cuyo método :meth:"
"`~Pattern.match` o :meth:`~Pattern.search` produce esta instancia de "
"coincidencia."

#: ../Doc/library/re.rst:1470
msgid "The string passed to :meth:`~Pattern.match` or :meth:`~Pattern.search`."
msgstr "La cadena pasada a :meth:`~Pattern.match` o :meth:`~Pattern.search`."

#: ../Doc/library/re.rst:1473
msgid ""
"Added support of :func:`copy.copy` and :func:`copy.deepcopy`.  Match objects "
"are considered atomic."
msgstr ""
"Se añadió el soporte de :func:`copy.copy` y :func:`copy.deepcopy`.  Los "
"objetos de coincidencia se consideran atómicos."

#: ../Doc/library/re.rst:1481
msgid "Regular Expression Examples"
msgstr "Ejemplos de expresiones regulares"

#: ../Doc/library/re.rst:1485
msgid "Checking for a Pair"
msgstr "Buscando un par"

#: ../Doc/library/re.rst:1487
msgid ""
"In this example, we'll use the following helper function to display match "
"objects a little more gracefully::"
msgstr ""
"En este ejemplo, se utilizará la siguiente función de ayuda para mostrar los "
"objetos de coincidencia con un poco más de elegancia::"

#: ../Doc/library/re.rst:1495
msgid ""
"Suppose you are writing a poker program where a player's hand is represented "
"as a 5-character string with each character representing a card, \"a\" for "
"ace, \"k\" for king, \"q\" for queen, \"j\" for jack, \"t\" for 10, and "
"\"2\" through \"9\" representing the card with that value."
msgstr ""
"Supongamos que se está escribiendo un programa de póquer en el que la mano "
"de un jugador se representa como una cadena de 5 caracteres en la que cada "
"carácter representa una carta, \"a\" para el as, \"k\" para el rey, \"q\" "
"para la reina, \"j\" para la jota, \"t\" para el 10, y del \" 2\" al \"9\" "
"representando la carta con ese valor."

#: ../Doc/library/re.rst:1500
msgid "To see if a given string is a valid hand, one could do the following::"
msgstr ""
"Para ver si una cadena dada es una mano válida, se podría hacer lo "
"siguiente::"

#: ../Doc/library/re.rst:1510
msgid ""
"That last hand, ``\"727ak\"``, contained a pair, or two of the same valued "
"cards. To match this with a regular expression, one could use backreferences "
"as such::"
msgstr ""
"Esa última mano, ``\"727ak\"``, contenía un par, o dos de las mismas cartas "
"de valor. Para igualar esto con una expresión regular, se podrían usar "
"referencias inversas como tales::"

#: ../Doc/library/re.rst:1520
msgid ""
"To find out what card the pair consists of, one could use the :meth:`~Match."
"group` method of the match object in the following manner::"
msgstr ""
"Para averiguar en qué carta consiste el par, se podría utilizar el método :"
"meth:`~Match.group` del objeto de coincidencia de la siguiente manera::"

#: ../Doc/library/re.rst:1539
msgid "Simulating scanf()"
msgstr "Simular scanf()"

#: ../Doc/library/re.rst:1543
msgid ""
"Python does not currently have an equivalent to :c:func:`!scanf`.  Regular "
"expressions are generally more powerful, though also more verbose, than :c:"
"func:`!scanf` format strings.  The table below offers some more-or-less "
"equivalent mappings between :c:func:`!scanf` format tokens and regular "
"expressions."
msgstr ""
"Actualmente, Python no tiene un equivalente a :c:func:`!scanf`. Las "
"expresiones regulares son generalmente más poderosas, aunque también más "
"detalladas, que las cadenas de formato de :c:func:`!scanf`. La tabla "
"siguiente ofrece algunas correspondencias más o menos equivalentes entre los "
"tokens de formato de :c:func:`!scanf` y expresiones regulares."

#: ../Doc/library/re.rst:1550
msgid ":c:func:`!scanf` Token"
msgstr "Token :c:func:`!scanf`"

#: ../Doc/library/re.rst:1550
msgid "Regular Expression"
msgstr "Expresión regular"

#: ../Doc/library/re.rst:1552
#, python-format
msgid "``%c``"
msgstr "``%c``"

#: ../Doc/library/re.rst:1554
#, python-format
msgid "``%5c``"
msgstr "``%5c``"

#: ../Doc/library/re.rst:1554
msgid "``.{5}``"
msgstr "``.{5}``"

#: ../Doc/library/re.rst:1556
#, python-format
msgid "``%d``"
msgstr "``%d``"

#: ../Doc/library/re.rst:1556
msgid "``[-+]?\\d+``"
msgstr "``[-+]?\\d+``"

#: ../Doc/library/re.rst:1558
#, python-format
msgid "``%e``, ``%E``, ``%f``, ``%g``"
msgstr "``%e``, ``%E``, ``%f``, ``%g``"

#: ../Doc/library/re.rst:1558
msgid "``[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?``"
msgstr "``[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?``"

#: ../Doc/library/re.rst:1560
#, python-format
msgid "``%i``"
msgstr "``%i``"

#: ../Doc/library/re.rst:1560
msgid "``[-+]?(0[xX][\\dA-Fa-f]+|0[0-7]*|\\d+)``"
msgstr "``[-+]?(0[xX][\\dA-Fa-f]+|0[0-7]*|\\d+)``"

#: ../Doc/library/re.rst:1562
#, python-format
msgid "``%o``"
msgstr "``%o``"

#: ../Doc/library/re.rst:1562
msgid "``[-+]?[0-7]+``"
msgstr "``[-+]?[0-7]+``"

#: ../Doc/library/re.rst:1564
#, python-format
msgid "``%s``"
msgstr "``%s``"

#: ../Doc/library/re.rst:1564
msgid "``\\S+``"
msgstr "``\\S+``"

#: ../Doc/library/re.rst:1566
#, python-format
msgid "``%u``"
msgstr "``%u``"

#: ../Doc/library/re.rst:1566
msgid "``\\d+``"
msgstr "``\\d+``"

#: ../Doc/library/re.rst:1568
#, python-format
msgid "``%x``, ``%X``"
msgstr "``%x``, ``%X``"

#: ../Doc/library/re.rst:1568
msgid "``[-+]?(0[xX])?[\\dA-Fa-f]+``"
msgstr "``[-+]?(0[xX])?[\\dA-Fa-f]+``"

#: ../Doc/library/re.rst:1571
msgid "To extract the filename and numbers from a string like ::"
msgstr "Para extraer el nombre de archivo y los números de una cadena como ::"

#: ../Doc/library/re.rst:1575
msgid "you would use a :c:func:`!scanf` format like ::"
msgstr "utilizaría un formato :c:func:`!scanf` como ::"

#: ../Doc/library/re.rst:1579
msgid "The equivalent regular expression would be ::"
msgstr "La expresión regular equivalente sería ::"

#: ../Doc/library/re.rst:1587
msgid "search() vs. match()"
msgstr "search() vs. match()"

#: ../Doc/library/re.rst:1591
msgid ""
"Python offers different primitive operations based on regular expressions:"
msgstr ""
"Python ofrece diferentes operaciones primitivas basadas en expresiones "
"regulares:"

#: ../Doc/library/re.rst:1593
msgid ":func:`re.match` checks for a match only at the beginning of the string"
msgstr ""
":func:`re.match` verifica una coincidencia solo al principio de la cadena"

#: ../Doc/library/re.rst:1594
msgid ""
":func:`re.search` checks for a match anywhere in the string (this is what "
"Perl does by default)"
msgstr ""
":func:`re.search` busca una coincidencia en cualquier parte de la cadena "
"(esto es lo que Perl hace por defecto)"

#: ../Doc/library/re.rst:1596
msgid ":func:`re.fullmatch` checks for entire string to be a match"
msgstr ""
":func:`re.fullmatch` verifica si la cadena completa es una coincidencia"

#: ../Doc/library/re.rst:1608
msgid ""
"Regular expressions beginning with ``'^'`` can be used with :func:`search` "
"to restrict the match at the beginning of the string::"
msgstr ""
"Las expresiones regulares que comienzan con ``'^'`` pueden ser usadas con :"
"func:`search` para restringir la coincidencia al principio de la cadena::"

#: ../Doc/library/re.rst:1616
msgid ""
"Note however that in :const:`MULTILINE` mode :func:`match` only matches at "
"the beginning of the string, whereas using :func:`search` with a regular "
"expression beginning with ``'^'`` will match at the beginning of each "
"line. ::"
msgstr ""
"Notar, sin embargo, que en el modo :const:`MULTILINE` :func:`match` sólo "
"coincide al principio de la cadena, mientras que usando :func:`search` con "
"una expresión regular que comienza con ``'^'`` coincidirá al principio de "
"cada línea. ::"

#: ../Doc/library/re.rst:1626
msgid "Making a Phonebook"
msgstr "Haciendo una guía telefónica"

#: ../Doc/library/re.rst:1628
msgid ""
":func:`split` splits a string into a list delimited by the passed pattern.  "
"The method is invaluable for converting textual data into data structures "
"that can be easily read and modified by Python as demonstrated in the "
"following example that creates a phonebook."
msgstr ""
":func:`split` divide una cadena en una lista delimitada por el patrón "
"recibido.  El método es muy útil para convertir datos textuales en "
"estructuras de datos que pueden ser fácilmente leídas y modificadas por "
"Python, como se demuestra en el siguiente ejemplo en el que se crea una guía "
"telefónica."

#: ../Doc/library/re.rst:1633
msgid ""
"First, here is the input.  Normally it may come from a file, here we are "
"using triple-quoted string syntax"
msgstr ""
"Primero, aquí está la información.  Normalmente puede venir de un archivo, "
"aquí se usa la sintaxis de cadena de triple comilla"

#: ../Doc/library/re.rst:1646
msgid ""
"The entries are separated by one or more newlines. Now we convert the string "
"into a list with each nonempty line having its own entry:"
msgstr ""
"Las entradas (*entries*) están separadas por una o más líneas nuevas. Ahora "
"se convierte la cadena en una lista en la que cada línea no vacía tiene su "
"propia entrada:"

#: ../Doc/library/re.rst:1659
msgid ""
"Finally, split each entry into a list with first name, last name, telephone "
"number, and address.  We use the ``maxsplit`` parameter of :func:`split` "
"because the address has spaces, our splitting pattern, in it:"
msgstr ""
"Finalmente, se divide cada entrada en una lista con nombre, apellido, número "
"de teléfono y dirección.  Se utiliza el parámetro ``maxsplit`` (división "
"máxima) de :func:`split` porque la dirección tiene espacios dentro del "
"patrón de división:"

#: ../Doc/library/re.rst:1672
msgid ""
"The ``:?`` pattern matches the colon after the last name, so that it does "
"not occur in the result list.  With a ``maxsplit`` of ``4``, we could "
"separate the house number from the street name:"
msgstr ""
"El patrón ``:?`` coincide con los dos puntos después del apellido, de manera "
"que no aparezca en la lista de resultados.  Con ``maxsplit`` de ``4``, se "
"podría separar el número de casa del nombre de la calle:"

#: ../Doc/library/re.rst:1687
msgid "Text Munging"
msgstr "Mungear texto"

#: ../Doc/library/re.rst:1689
msgid ""
":func:`sub` replaces every occurrence of a pattern with a string or the "
"result of a function.  This example demonstrates using :func:`sub` with a "
"function to \"munge\" text, or randomize the order of all the characters in "
"each word of a sentence except for the first and last characters::"
msgstr ""
":func:`sub` reemplaza cada ocurrencia de un patrón con una cadena o el "
"resultado de una función.  Este ejemplo demuestra el uso de :func:`sub` con "
"una función para \"mungear\" (*munge*) el texto, o aleatorizar el orden de "
"todos los caracteres en cada palabra de una frase excepto el primer y último "
"carácter::"

#: ../Doc/library/re.rst:1707
msgid "Finding all Adverbs"
msgstr "Encontrar todos los adverbios"

#: ../Doc/library/re.rst:1709
msgid ""
":func:`findall` matches *all* occurrences of a pattern, not just the first "
"one as :func:`search` does.  For example, if a writer wanted to find all of "
"the adverbs in some text, they might use :func:`findall` in the following "
"manner::"
msgstr ""
":func:`findall` coincide con *todas* las ocurrencias de un patrón, no sólo "
"con la primera, como lo hace :func:`search`.  Por ejemplo, si un escritor "
"quisiera encontrar todos los adverbios en algún texto, podría usar :func:"
"`findall` de la siguiente manera::"

#: ../Doc/library/re.rst:1720
msgid "Finding all Adverbs and their Positions"
msgstr "Encontrar todos los adverbios y sus posiciones"

#: ../Doc/library/re.rst:1722
msgid ""
"If one wants more information about all matches of a pattern than the "
"matched text, :func:`finditer` is useful as it provides :class:`~re.Match` "
"objects instead of strings.  Continuing with the previous example, if a "
"writer wanted to find all of the adverbs *and their positions* in some text, "
"they would use :func:`finditer` in the following manner::"
msgstr ""
"Si se desea obtener más información sobre todas las coincidencias de un "
"patrón en lugar del texto coincidente, :func:`finditer` es útil ya que "
"proporciona :class:`~re.Match` objetos en lugar de cadenas. Continuando con "
"el ejemplo anterior, si un escritor quisiera encontrar todos los adverbios "
"*y sus posiciones* en algún texto, usaría :func:`finditer` de la siguiente "
"manera::"

#: ../Doc/library/re.rst:1736
msgid "Raw String Notation"
msgstr "Notación de cadena *raw*"

#: ../Doc/library/re.rst:1738
msgid ""
"Raw string notation (``r\"text\"``) keeps regular expressions sane.  Without "
"it, every backslash (``'\\'``) in a regular expression would have to be "
"prefixed with another one to escape it.  For example, the two following "
"lines of code are functionally identical::"
msgstr ""
"La notación de cadena *raw* (``r \"text\"``) permite escribir expresiones "
"regulares razonables.  Sin ella, para \"escapar\" cada barra inversa "
"(``'\\'``) en una expresión regular tendría que ser precedida por otra.  Por "
"ejemplo, las dos siguientes líneas de código son funcionalmente idénticas::"

#: ../Doc/library/re.rst:1748
msgid ""
"When one wants to match a literal backslash, it must be escaped in the "
"regular expression.  With raw string notation, this means ``r\"\\\\\"``.  "
"Without raw string notation, one must use ``\"\\\\\\\\\"``, making the "
"following lines of code functionally identical::"
msgstr ""
"Cuando uno quiere igualar una barra inversa literal, debe escaparse en la "
"expresión regular.  Con la notación de cadena *raw*, esto significa ``r\"\\\\"
"\"``.  Sin la notación de cadena, uno debe usar ``\"\\\\\\\\\"``, haciendo "
"que las siguientes líneas de código sean funcionalmente idénticas::"

#: ../Doc/library/re.rst:1760
msgid "Writing a Tokenizer"
msgstr "Escribir un Tokenizador"

#: ../Doc/library/re.rst:1762
msgid ""
"A `tokenizer or scanner <https://en.wikipedia.org/wiki/Lexical_analysis>`_ "
"analyzes a string to categorize groups of characters.  This is a useful "
"first step in writing a compiler or interpreter."
msgstr ""
"Un `tokenizador o analizador léxico <https://es.wikipedia.org/wiki/"
"Analizador_léxico>`_ analiza una cadena para categorizar grupos de "
"caracteres.  Este es un primer paso útil para escribir un compilador o "
"intérprete."

#: ../Doc/library/re.rst:1766
msgid ""
"The text categories are specified with regular expressions.  The technique "
"is to combine those into a single master regular expression and to loop over "
"successive matches::"
msgstr ""
"Las categorías de texto se especifican con expresiones regulares.  La "
"técnica consiste en combinarlas en una única expresión regular maestra y en "
"hacer un bucle sobre las sucesivas coincidencias::"

#: ../Doc/library/re.rst:1822
msgid "The tokenizer produces the following output::"
msgstr "El tokenizador produce el siguiente resultado::"

#: ../Doc/library/re.rst:1845
msgid ""
"Friedl, Jeffrey. Mastering Regular Expressions. 3rd ed., O'Reilly Media, "
"2009. The third edition of the book no longer covers Python at all, but the "
"first edition covered writing good regular expression patterns in great "
"detail."
msgstr ""
"Friedl, Jeffrey. *Mastering Regular Expressions*. 3a ed., O'Reilly Media, "
"2009. La tercera edición del libro ya no abarca a Python en absoluto, pero "
"la primera edición cubría la escritura de buenos patrones de expresiones "
"regulares con gran detalle."

#: ../Doc/library/re.rst:99
msgid ". (dot)"
msgstr ". (dot)"

#: ../Doc/library/re.rst:99 ../Doc/library/re.rst:106 ../Doc/library/re.rst:112
#: ../Doc/library/re.rst:123 ../Doc/library/re.rst:130
#: ../Doc/library/re.rst:137 ../Doc/library/re.rst:143
#: ../Doc/library/re.rst:157 ../Doc/library/re.rst:181
#: ../Doc/library/re.rst:220 ../Doc/library/re.rst:235
#: ../Doc/library/re.rst:244 ../Doc/library/re.rst:257
#: ../Doc/library/re.rst:263 ../Doc/library/re.rst:296
#: ../Doc/library/re.rst:309 ../Doc/library/re.rst:319
#: ../Doc/library/re.rst:345 ../Doc/library/re.rst:394
#: ../Doc/library/re.rst:426 ../Doc/library/re.rst:432
#: ../Doc/library/re.rst:437 ../Doc/library/re.rst:444
#: ../Doc/library/re.rst:451 ../Doc/library/re.rst:478
#: ../Doc/library/re.rst:488 ../Doc/library/re.rst:511
#: ../Doc/library/re.rst:523 ../Doc/library/re.rst:528
#: ../Doc/library/re.rst:544 ../Doc/library/re.rst:555
#: ../Doc/library/re.rst:567 ../Doc/library/re.rst:574
#: ../Doc/library/re.rst:588 ../Doc/library/re.rst:595
#: ../Doc/library/re.rst:609 ../Doc/library/re.rst:618
#: ../Doc/library/re.rst:623 ../Doc/library/re.rst:798
#: ../Doc/library/re.rst:1003
msgid "in regular expressions"
msgstr "en expresiones regulares"

#: ../Doc/library/re.rst:106 ../Doc/library/re.rst:263
msgid "^ (caret)"
msgstr "^ (caret)"

#: ../Doc/library/re.rst:112
msgid "$ (dollar)"
msgstr "$ (dólar)"

#: ../Doc/library/re.rst:123
msgid "* (asterisk)"
msgstr "* (asterisco)"

#: ../Doc/library/re.rst:130
msgid "+ (plus)"
msgstr "+ (mas)"

#: ../Doc/library/re.rst:137
msgid "? (question mark)"
msgstr "? (signo de interrogación)"

#: ../Doc/library/re.rst:143
msgid "*?"
msgstr "*?"

#: ../Doc/library/re.rst:143
msgid "+?"
msgstr "+?"

#: ../Doc/library/re.rst:143
msgid "??"
msgstr "??"

#: ../Doc/library/re.rst:157
msgid "*+"
msgstr "*+"

#: ../Doc/library/re.rst:157
msgid "++"
msgstr "++"

#: ../Doc/library/re.rst:157
msgid "?+"
msgstr "?+"

#: ../Doc/library/re.rst:181
msgid "{} (curly brackets)"
msgstr "{} (llaves o corchetes curvos)"

#: ../Doc/library/re.rst:220 ../Doc/library/re.rst:257
#: ../Doc/library/re.rst:511
msgid "\\ (backslash)"
msgstr "\\ (barra inversa)"

#: ../Doc/library/re.rst:235
msgid "[] (square brackets)"
msgstr "[] (corchetes)"

#: ../Doc/library/re.rst:244
msgid "- (minus)"
msgstr "- (menos)"

#: ../Doc/library/re.rst:296
msgid "| (vertical bar)"
msgstr "| (barra vertical)"

#: ../Doc/library/re.rst:309
msgid "() (parentheses)"
msgstr "() (paréntesis)"

#: ../Doc/library/re.rst:319
msgid "(?"
msgstr "(?"

#: ../Doc/library/re.rst:345
msgid "(?:"
msgstr "(?:"

#: ../Doc/library/re.rst:394
msgid "(?P<"
msgstr "(?P<"

#: ../Doc/library/re.rst:426
msgid "(?P="
msgstr "(?P="

#: ../Doc/library/re.rst:432
msgid "(?#"
msgstr "(?#"

#: ../Doc/library/re.rst:437
msgid "(?="
msgstr "(?="

#: ../Doc/library/re.rst:444
msgid "(?!"
msgstr "(?!"

#: ../Doc/library/re.rst:451
msgid "(?<="
msgstr "(?<="

#: ../Doc/library/re.rst:478
msgid "(?<!"
msgstr "(?<!"

#: ../Doc/library/re.rst:488
msgid "(?("
msgstr "(?("

#: ../Doc/library/re.rst:523
msgid "\\A"
msgstr "\\A"

#: ../Doc/library/re.rst:528 ../Doc/library/re.rst:623
msgid "\\b"
msgstr "\\b"

#: ../Doc/library/re.rst:544
msgid "\\B"
msgstr "\\B"

#: ../Doc/library/re.rst:555
msgid "\\d"
msgstr "\\d"

#: ../Doc/library/re.rst:567
msgid "\\D"
msgstr "\\D"

#: ../Doc/library/re.rst:574
msgid "\\s"
msgstr "\\s"

#: ../Doc/library/re.rst:588
msgid "\\S"
msgstr "\\S"

#: ../Doc/library/re.rst:595
msgid "\\w"
msgstr "\\w"

#: ../Doc/library/re.rst:609
msgid "\\W"
msgstr "\\W"

#: ../Doc/library/re.rst:618
msgid "\\Z"
msgstr "\\Z"

#: ../Doc/library/re.rst:623
msgid "\\a"
msgstr "\\a"

#: ../Doc/library/re.rst:623
msgid "\\f"
msgstr "\\f"

#: ../Doc/library/re.rst:623
msgid "\\n"
msgstr "\\n"

#: ../Doc/library/re.rst:623
msgid "\\N"
msgstr "\\N"

#: ../Doc/library/re.rst:623
msgid "\\r"
msgstr "\\r"

#: ../Doc/library/re.rst:623
msgid "\\t"
msgstr "\\t"

#: ../Doc/library/re.rst:623
msgid "\\u"
msgstr "\\u"

#: ../Doc/library/re.rst:623
msgid "\\U"
msgstr "\\U"

#: ../Doc/library/re.rst:623
msgid "\\v"
msgstr "\\v"

#: ../Doc/library/re.rst:623
msgid "\\x"
msgstr "\\x"

#: ../Doc/library/re.rst:623
msgid "\\\\"
msgstr "\\\\"

#: ../Doc/library/re.rst:798
msgid "# (hash)"
msgstr "# (hash)"

#: ../Doc/library/re.rst:1003
msgid "\\g"
msgstr "\\g"

#: ../Doc/library/re.rst:1541
msgid "scanf()"
msgstr "scanf()"

#~ msgid "Group names containing non-ASCII characters in bytes patterns."
#~ msgstr "Nombres de grupo contiene caracteres no-ASCII en patrones de bytes."

#~ msgid "Group *id* containing anything except ASCII digits."
#~ msgstr "Grupo *id* que contenga cualquier cosa excepto dígitos ASCII."

#~ msgid ""
#~ "Group *id* containing anything except ASCII digits. Group names "
#~ "containing non-ASCII characters in bytes replacement strings."
#~ msgstr ""
#~ "Grupo *id* que contengan cualquier cosa excepto dígitos ASCII. Nombres de "
#~ "grupo que contengan caracteres no ASCII en cadenas de reemplazo de bytes."

#~ msgid ""
#~ "Compiled regular expression objects support the following methods and "
#~ "attributes:"
#~ msgstr ""
#~ "Los objetos expresión regular compilados soportan los siguientes métodos "
#~ "y atributos:"

#~ msgid "Match objects support the following methods and attributes:"
#~ msgstr ""
#~ "Los objetos de coincidencia admiten los siguientes métodos y atributos:"

#~ msgid ""
#~ "Python offers two different primitive operations based on regular "
#~ "expressions: :func:`re.match` checks for a match only at the beginning of "
#~ "the string, while :func:`re.search` checks for a match anywhere in the "
#~ "string (this is what Perl does by default)."
#~ msgstr ""
#~ "Python ofrece dos operaciones primitivas diferentes basadas en "
#~ "expresiones regulares: :func:`re.match` comprueba si hay una coincidencia "
#~ "sólo al principio de la cadena, mientras que :func:`re.search` comprueba "
#~ "si hay una coincidencia en cualquier parte de la cadena (esto es lo que "
#~ "hace Perl por defecto)."