diff --git a/dict b/dict index 46b1dc9d76..695c08f8b6 100644 --- a/dict +++ b/dict @@ -63,6 +63,7 @@ Flying Fortran Foundation Fourier +Friedl GIL Google Greg @@ -81,9 +82,11 @@ Intel Inf Interesantemente Java +Jeffrey Jim Just Jython +K Katz Kivy L @@ -100,8 +103,11 @@ Mark Microsoft Mitch Monty +Mungear N NaN +Nd +None Neumann NumPy Numerical @@ -126,6 +132,7 @@ PySide Python Pythónico Qt +R Randal Refactorizados Refactorizar @@ -150,18 +157,23 @@ Tcl Tix Tk Tkinter +Tokenizador Tutorial Unicode Unix Usenet +UTF VM Von WWW Windows X Xt +Z Zip +ab aleatoriamente +aleatorizar append aproximarla argv @@ -199,6 +211,8 @@ bzip bytearray búfer búferes +capturable +capturador cargable cargables class @@ -279,6 +293,8 @@ finalizadores flag flags float +foo +foobar format formateador formateadores @@ -352,6 +368,7 @@ iterador iteradores j json +k Latin latin l @@ -371,6 +388,7 @@ map mapear mapeo mapeos +metacaracteres metaclase metaclases metadatos @@ -393,6 +411,7 @@ multicast multifase multihilo multilínea +mungear naif nonlocal object @@ -409,7 +428,9 @@ n naíf naífs ncurses +octal octale +octales normalización octal operando @@ -452,8 +473,10 @@ pseudo py pyc python -R +q quit +quote +raw read readline reasignación @@ -485,6 +508,7 @@ referenciado referenciados referencian referenciarse +regex reinicializador reinicializar remove @@ -496,6 +520,7 @@ reubicar root run s +scanf script scripting scripts @@ -505,6 +530,7 @@ secuencialmente seguirle self semánticamente +separándolos serializa serialización serializados @@ -528,6 +554,7 @@ spam stderr stdin stdout +str strings sub subcadena @@ -563,6 +590,7 @@ timestamp tipado tipear token +tokenizador tokens truncarlo tty @@ -578,7 +606,6 @@ unicode uninstall urllib utf -UTF vía versionados Win @@ -594,12 +621,14 @@ wxwidgets x xz ydel +z zip zipimporter zlib ésimo +ı +ſ option -octales permutación Gaussianas log @@ -635,5 +664,4 @@ reproducible retrocompatible remuestreo kernel -str pasándole diff --git a/library/re.po b/library/re.po index 42b27110fb..725bb088ac 100644 --- a/library/re.po +++ b/library/re.po @@ -6,33 +6,37 @@ # Check https://github.com/PyCampES/python-docs-es/blob/3.8/TRANSLATORS to # get the list of volunteers # -#, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2020-06-23 11:00+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" -"Content-Type: text/plain; charset=utf-8\n" +"Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.8.0\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Last-Translator: Miguel Hernandez \n" +"Language: es\n" +"X-Generator: Poedit 2.3.1\n" #: ../Doc/library/re.rst:2 msgid ":mod:`re` --- Regular expression operations" -msgstr "" +msgstr ":mod:`re` --- Operaciones con expresiones regulares" #: ../Doc/library/re.rst:10 msgid "**Source code:** :source:`Lib/re.py`" -msgstr "" +msgstr "**Código fuente:** :source:`Lib/re.py`" #: ../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 "" @@ -43,6 +47,12 @@ msgid "" "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 "" @@ -58,6 +68,18 @@ msgid "" "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:`DeprecationWarning` 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 "" @@ -68,6 +90,13 @@ msgid "" "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 "" @@ -76,6 +105,11 @@ msgid "" "expressions `. 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 ` (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 "" @@ -83,10 +117,13 @@ msgid "" "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 `_ , 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 "" +msgstr "Sintaxis de expresiones regulares" #: ../Doc/library/re.rst:61 msgid "" @@ -95,6 +132,11 @@ msgid "" "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 "" @@ -109,6 +151,17 @@ msgid "" "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 "" @@ -116,6 +169,9 @@ msgid "" "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 "" @@ -126,6 +182,13 @@ msgid "" "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 "" @@ -133,6 +196,9 @@ msgid "" "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 "" @@ -142,14 +208,20 @@ msgid "" "repetition to an inner repetition, parentheses may be used. For example, the " "expression ``(?:a{6})*`` matches any multiple of six ``'a'`` characters." msgstr "" +"Los delimitadores de repetición (``*``, ``+``, ``?``, ``{m,n}``, etc.) no " +"pueden ser anidados directamente. Esto evita la ambigüedad con el sufijo " +"modificador no *greedy* (codiciosos) ``?``, 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 "" +msgstr "Los caracteres especiales son:" #: ../Doc/library/re.rst:104 ../Doc/library/re.rst:1409 msgid "``.``" -msgstr "" +msgstr "``.``" #: ../Doc/library/re.rst:102 msgid "" @@ -157,20 +229,25 @@ msgid "" "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 "" +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 "" +msgstr "``$``" #: ../Doc/library/re.rst:115 msgid "" @@ -183,10 +260,18 @@ msgid "" "(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 "" +msgstr "``*``" #: ../Doc/library/re.rst:126 msgid "" @@ -194,10 +279,13 @@ msgid "" "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 "" +msgstr "``+``" #: ../Doc/library/re.rst:133 msgid "" @@ -205,20 +293,25 @@ msgid "" "``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 "" +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 "" +msgstr "``*?``, ``+?``, ``??``" #: ../Doc/library/re.rst:149 msgid "" @@ -230,10 +323,18 @@ msgid "" "characters as possible will be matched. Using the RE ``<.*?>`` will match " "only ``''``." msgstr "" +"Los delimitadores \"*\", \"+\" y \"*\" son todos :dfn:`greedy` (codiciosos); " +"coinciden con la mayor cantidad de texto posible. A veces este " +"comportamiento no es deseado; si el RE ``<.*>`` se utiliza para coincidir " +"con ``' b '``, coincidirá con toda la cadena, y no sólo con " +"``''``. 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 ``''``." #: ../Doc/library/re.rst:163 msgid "``{m}``" -msgstr "" +msgstr "``{m}``" #: ../Doc/library/re.rst:161 msgid "" @@ -241,10 +342,13 @@ msgid "" "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:172 msgid "``{m,n}``" -msgstr "" +msgstr "``{m,n}``" #: ../Doc/library/re.rst:166 msgid "" @@ -257,10 +361,18 @@ msgid "" "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:179 msgid "``{m,n}?``" -msgstr "" +msgstr "``{m,n}?``" #: ../Doc/library/re.rst:175 msgid "" @@ -270,10 +382,16 @@ msgid "" "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 ``'aaaaaaa'``, ``a{3,5}`` " +"coincidirá con 5 caracteres ``'a'``, mientras que ``a{3,5}?`` solo " +"coincidirá con 3 caracteres." #: ../Doc/library/re.rst:194 msgid "``\\``" -msgstr "" +msgstr "``\\``" #: ../Doc/library/re.rst:184 msgid "" @@ -281,6 +399,10 @@ msgid "" "``'*'``, ``'?'``, 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:188 msgid "" @@ -292,20 +414,30 @@ msgid "" "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:254 msgid "``[]``" -msgstr "" +msgstr "``[]``" #: ../Doc/library/re.rst:200 msgid "Used to indicate a set of characters. In a set:" -msgstr "" +msgstr "Se utiliza para indicar un conjunto de caracteres. En un conjunto:" #: ../Doc/library/re.rst:202 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:207 msgid "" @@ -316,6 +448,13 @@ msgid "" "``-`` 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:214 msgid "" @@ -323,6 +462,9 @@ msgid "" "``[(+*)]`` 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:220 msgid "" @@ -330,6 +472,10 @@ msgid "" "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:226 msgid "" @@ -340,6 +486,12 @@ msgid "" "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:233 msgid "" @@ -347,6 +499,10 @@ msgid "" "place it at the beginning of the set. For example, both ``[()[\\]{}]`` and " "``[]()[{}]`` will both match a parenthesis." 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:242 msgid "" @@ -357,16 +513,25 @@ msgid "" "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:252 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:267 msgid "``|``" -msgstr "" +msgstr "``|``" #: ../Doc/library/re.rst:259 msgid "" @@ -380,10 +545,20 @@ msgid "" "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:277 msgid "``(...)``" -msgstr "" +msgstr "``(...)``" #: ../Doc/library/re.rst:273 msgid "" @@ -394,10 +569,17 @@ msgid "" "``'('`` 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:286 msgid "``(?...)``" -msgstr "" +msgstr "``(?...)``" #: ../Doc/library/re.rst:282 msgid "" @@ -407,10 +589,15 @@ msgid "" "do not create a new group; ``(?P...)`` 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…)`` es la única excepción a esta regla. A " +"continuación se muestran las extensiones actualmente soportadas." #: ../Doc/library/re.rst:300 msgid "``(?aiLmsux)``" -msgstr "" +msgstr "``(?aiLmsux)``" #: ../Doc/library/re.rst:289 msgid "" @@ -425,10 +612,21 @@ msgid "" "*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:308 msgid "``(?:...)``" -msgstr "" +msgstr "``(?:...)``" #: ../Doc/library/re.rst:305 msgid "" @@ -437,10 +635,14 @@ msgid "" "*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:334 msgid "``(?aiLmsux-imsx:...)``" -msgstr "" +msgstr "``(?aiLmsux-imsx:...)``" #: ../Doc/library/re.rst:311 msgid "" @@ -453,6 +655,15 @@ msgid "" "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:321 msgid "" @@ -466,14 +677,26 @@ msgid "" "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:333 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:361 msgid "``(?P...)``" -msgstr "" +msgstr "``(?P...)``" #: ../Doc/library/re.rst:339 msgid "" @@ -483,6 +706,12 @@ msgid "" "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 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:345 msgid "" @@ -490,72 +719,77 @@ msgid "" "P['\"]).*?(?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['\"]).*?(?P=quote)`` (es decir, hacer coincidir una " +"cadena citada con comillas simples o dobles):" #: ../Doc/library/re.rst:350 msgid "Context of reference to group \"quote\"" -msgstr "" +msgstr "Contexto de la referencia al grupo *quote* (cita)" #: ../Doc/library/re.rst:350 msgid "Ways to reference it" -msgstr "" +msgstr "Formas de hacer referencia" #: ../Doc/library/re.rst:352 msgid "in the same pattern itself" -msgstr "" +msgstr "en el mismo patrón en sí mismo" #: ../Doc/library/re.rst:352 msgid "``(?P=quote)`` (as shown)" -msgstr "" +msgstr "``(?P=quote)`` (como se muestra)" #: ../Doc/library/re.rst:353 ../Doc/library/re.rst:360 msgid "``\\1``" -msgstr "" +msgstr "``\\1``" #: ../Doc/library/re.rst:355 msgid "when processing match object *m*" -msgstr "" +msgstr "cuando se procesa el objeto de la coincidencia *m*" #: ../Doc/library/re.rst:355 msgid "``m.group('quote')``" -msgstr "" +msgstr "``m.group('quote')``" #: ../Doc/library/re.rst:356 msgid "``m.end('quote')`` (etc.)" -msgstr "" +msgstr "``m.end('quote')`` (etc.)" #: ../Doc/library/re.rst:358 msgid "in a string passed to the *repl* argument of ``re.sub()``" -msgstr "" +msgstr "en una cadena pasada al argumento *repl* de ``re.sub()``" #: ../Doc/library/re.rst:358 msgid "``\\g``" -msgstr "" +msgstr "``\\g``" #: ../Doc/library/re.rst:359 msgid "``\\g<1>``" -msgstr "" +msgstr "``\\g<1>``" #: ../Doc/library/re.rst:367 msgid "``(?P=name)``" -msgstr "" +msgstr "``(?P=name)``" #: ../Doc/library/re.rst:366 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:372 msgid "``(?#...)``" -msgstr "" +msgstr "``(?#...)``" #: ../Doc/library/re.rst:372 msgid "A comment; the contents of the parentheses are simply ignored." -msgstr "" +msgstr "Un comentario; el contenido de los paréntesis es simplemente ignorado." #: ../Doc/library/re.rst:379 msgid "``(?=...)``" -msgstr "" +msgstr "``(?=...)``" #: ../Doc/library/re.rst:377 msgid "" @@ -563,10 +797,14 @@ msgid "" "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:386 msgid "``(?!...)``" -msgstr "" +msgstr "``(?!...)``" #: ../Doc/library/re.rst:384 msgid "" @@ -574,10 +812,14 @@ msgid "" "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:413 msgid "``(?<=...)``" -msgstr "" +msgstr "``(?<=...)``" #: ../Doc/library/re.rst:391 msgid "" @@ -592,18 +834,30 @@ msgid "" "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:406 msgid "This example looks for a word following a hyphen:" -msgstr "" +msgstr "Este ejemplo busca una palabra seguida de un guión:" #: ../Doc/library/re.rst:412 msgid "Added support for group references of fixed length." -msgstr "" +msgstr "Se añadió soporte a las referencias de grupo de longitud fija." #: ../Doc/library/re.rst:422 msgid "``(?'`` as well as ``'user@host.com'``, but not with " "``''``." 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 ``''`` así como " +"con ``'user@host.com'``, pero no con ``''``." #: ../Doc/library/re.rst:433 msgid "" @@ -635,10 +903,14 @@ msgid "" "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:448 msgid "``\\number``" -msgstr "" +msgstr "``\\number``" #: ../Doc/library/re.rst:441 msgid "" @@ -651,18 +923,27 @@ msgid "" "*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:453 msgid "``\\A``" -msgstr "" +msgstr "``\\A``" #: ../Doc/library/re.rst:453 msgid "Matches only at the start of the string." -msgstr "" +msgstr "Coincide sólo al principio de la cadena." #: ../Doc/library/re.rst:469 msgid "``\\b``" -msgstr "" +msgstr "``\\b``" #: ../Doc/library/re.rst:458 msgid "" @@ -673,6 +954,13 @@ msgid "" "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:465 msgid "" @@ -682,10 +970,16 @@ msgid "" "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:480 msgid "``\\B``" -msgstr "" +msgstr "``\\B``" #: ../Doc/library/re.rst:474 msgid "" @@ -697,15 +991,23 @@ msgid "" "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:492 msgid "``\\d``" -msgstr "" +msgstr "``\\d``" #: ../Doc/library/re.rst:489 ../Doc/library/re.rst:509 #: ../Doc/library/re.rst:529 msgid "For Unicode (str) patterns:" -msgstr "" +msgstr "Para los patrones de Unicode (str):" #: ../Doc/library/re.rst:486 msgid "" @@ -714,19 +1016,23 @@ msgid "" "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:492 ../Doc/library/re.rst:513 #: ../Doc/library/re.rst:535 msgid "For 8-bit (bytes) patterns:" -msgstr "" +msgstr "Para patrones de 8 bits (bytes):" #: ../Doc/library/re.rst:492 msgid "Matches any decimal digit; this is equivalent to ``[0-9]``." -msgstr "" +msgstr "Coincide con cualquier dígito decimal; esto equivale a ``[0-9]``." #: ../Doc/library/re.rst:499 msgid "``\\D``" -msgstr "" +msgstr "``\\D``" #: ../Doc/library/re.rst:497 msgid "" @@ -734,10 +1040,13 @@ msgid "" "``\\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:513 msgid "``\\s``" -msgstr "" +msgstr "``\\s``" #: ../Doc/library/re.rst:505 msgid "" @@ -746,16 +1055,23 @@ msgid "" "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:512 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:520 msgid "``\\S``" -msgstr "" +msgstr "``\\S``" #: ../Doc/library/re.rst:518 msgid "" @@ -763,10 +1079,13 @@ msgid "" "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:535 msgid "``\\w``" -msgstr "" +msgstr "``\\w``" #: ../Doc/library/re.rst:526 msgid "" @@ -774,6 +1093,10 @@ msgid "" "part of a word in any language, as well as numbers and the underscore. If " "the :const:`ASCII` flag is used, only ``[a-zA-Z0-9_]`` is matched." msgstr "" +"Coincide con los caracteres de palabras de Unicode; esto incluye la mayoría " +"de los caracteres que pueden formar parte de una palabra en cualquier " +"idioma, así como los números y el guión bajo. Si se usa el indicador :const:" +"`ASCII`, sólo coincide con ``[a-zA-Z0-9_]``." #: ../Doc/library/re.rst:532 msgid "" @@ -782,10 +1105,14 @@ msgid "" "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:544 msgid "``\\W``" -msgstr "" +msgstr "``\\W``" #: ../Doc/library/re.rst:540 msgid "" @@ -794,26 +1121,36 @@ msgid "" "``[^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:549 msgid "``\\Z``" -msgstr "" +msgstr "``\\Z``" #: ../Doc/library/re.rst:549 msgid "Matches only at the end of the string." -msgstr "" +msgstr "Coincide sólo el final de la cadena." #: ../Doc/library/re.rst:565 msgid "" "Most of the standard escapes supported by Python string literals are also " "accepted by the regular expression parser::" msgstr "" +"La mayoría de los escapes estándar soportados por los literales de la cadena " +"de Python también son aceptados por el analizador de expresiones regulares::" #: ../Doc/library/re.rst:572 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:575 msgid "" @@ -821,6 +1158,10 @@ msgid "" "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:579 msgid "" @@ -829,25 +1170,33 @@ msgid "" "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:584 msgid "The ``'\\u'`` and ``'\\U'`` escape sequences have been added." -msgstr "" +msgstr "Se han añadido las secuencias de escape ``'\\u'`` y ``'\\U'``." #: ../Doc/library/re.rst:587 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:590 msgid "" "The ``'\\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 ``'\\N{name}'``. Como en los literales de " +"cadena, se expande al carácter Unicode nombrado (por ej. ``'\\N{EM DASH}'``)." #: ../Doc/library/re.rst:598 msgid "Module Contents" -msgstr "" +msgstr "Contenidos del módulo" #: ../Doc/library/re.rst:600 msgid "" @@ -856,12 +1205,18 @@ msgid "" "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:605 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:611 msgid "" @@ -869,6 +1224,10 @@ msgid "" "`, 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 `, 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:616 msgid "" @@ -876,14 +1235,17 @@ msgid "" "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:620 msgid "The sequence ::" -msgstr "" +msgstr "La secuencia ::" #: ../Doc/library/re.rst:625 msgid "is equivalent to ::" -msgstr "" +msgstr "es equivalente a ::" #: ../Doc/library/re.rst:629 msgid "" @@ -891,6 +1253,9 @@ msgid "" "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:635 msgid "" @@ -899,6 +1264,10 @@ msgid "" "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:644 msgid "" @@ -907,6 +1276,10 @@ msgid "" "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:649 msgid "" @@ -915,12 +1288,19 @@ msgid "" "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:658 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:665 msgid "" @@ -931,6 +1311,13 @@ msgid "" "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:672 msgid "" @@ -938,10 +1325,17 @@ msgid "" "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 :" +"+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 indicador :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:683 msgid "" @@ -953,12 +1347,23 @@ msgid "" "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:692 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:696 msgid "" @@ -966,6 +1371,9 @@ msgid "" "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:705 msgid "" @@ -977,6 +1385,13 @@ msgid "" "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:717 msgid "" @@ -984,6 +1399,10 @@ msgid "" "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:727 msgid "" @@ -996,16 +1415,27 @@ msgid "" "backslash, all characters from the leftmost such ``#`` through the end of " "the line are ignored." msgstr "" +"Este indicador permite escribir expresiones regulares que se ven mejor y son " +"más legibles al facilitar la separación visual de las secciones lógicas del " +"patrón y añadir 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 no escapada, o dentro de fichas como ``*?" +"``, ``(?:`` o ``(?P<...>``. Cuando una línea contiene un ``#`` que no está " +"en una clase de caracteres y no está precedida por una barra inversa no " +"escapada, se ignoran todos los caracteres desde el más a la izquierda (como " +"``#``) hasta el final de la línea." #: ../Doc/library/re.rst:736 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:744 msgid "Corresponds to the inline flag ``(?x)``." -msgstr "" +msgstr "Corresponde al indicador en línea ``(?x)``." #: ../Doc/library/re.rst:749 msgid "" @@ -1015,6 +1445,12 @@ msgid "" "string matches the pattern; note that this is different from finding a zero-" "length match at some point in the string." msgstr "" +"Examina a través de la *string* (\"cadena\") buscando el primer lugar donde " +"el *pattern* (\"patrón\") de la expresión regular produce una coincidencia, " +"y devuelve un :ref:`objeto match ` correspondiente. Devuelve " +"``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:758 msgid "" @@ -1023,18 +1459,28 @@ msgid "" "objects>`. 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 *string* (\"cadena\") coinciden " +"con el *pattern* (\"patrón\") de la expresión regular, devuelve un :ref:" +"`objeto match ` correspondiente. Devuelve ``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:763 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:766 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:772 msgid "" @@ -1043,6 +1489,10 @@ msgid "" "string does not match the pattern; note that this is different from a zero-" "length match." msgstr "" +"Si toda la *string* (\"cadena\") coincide con el *pattern* (\"patrón\") de " +"la expresión regular, devuelve un correspondiente :ref:`objeto match `. Devuelve ``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:782 msgid "" @@ -1052,6 +1502,12 @@ msgid "" "*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 devuelven 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 devuelve como elemento final de la lista. ::" #: ../Doc/library/re.rst:797 msgid "" @@ -1059,28 +1515,37 @@ msgid "" "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:804 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:807 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:817 ../Doc/library/re.rst:897 #: ../Doc/library/re.rst:921 msgid "Added the optional flags argument." -msgstr "" +msgstr "Se añadió el argumento de los indicadores opcionales." #: ../Doc/library/re.rst:820 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:826 msgid "" @@ -1090,10 +1555,19 @@ msgid "" "list of groups; this will be a list of tuples if the pattern has more than " "one group. Empty matches are included in the result." msgstr "" +"Devuelve todas las coincidencias no superpuestas del *pattern* (\"patrón\") " +"en la *string* (\"cadena\"), como una lista de cadenas. La cadena es " +"examinada de izquierda a derecha, y las coincidencias son devueltas en el " +"orden en que fueron encontradas. Si uno o más grupos están presentes en el " +"patrón, devuelve una lista de grupos; esta será una lista de tuplas si el " +"patrón tiene más de un grupo. Las coincidencias vacías se incluyen en el " +"resultado." #: ../Doc/library/re.rst:832 ../Doc/library/re.rst:843 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:838 msgid "" @@ -1102,6 +1576,12 @@ msgid "" "*string* is scanned left-to-right, and matches are returned in the order " "found. Empty matches are included in the result." msgstr "" +"Devuelve un :term:`iterator` que produce :ref:`objetos de coincidencia " +"` sobre todas las coincidencias no superpuestas para " +"*pattern* (\"patrón\") de RE en la *string* (\"cadena\"). La *string* es " +"examinada de izquierda a derecha, y las coincidencias son devueltas en el " +"orden en que se encuentran. Las coincidencias vacías se incluyen en el " +"resultado." #: ../Doc/library/re.rst:849 msgid "" @@ -1116,6 +1596,17 @@ msgid "" "\\6``, are replaced with the substring matched by group 6 in the pattern. " "For example::" msgstr "" +"Devuelve 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 devuelve *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:865 msgid "" @@ -1123,10 +1614,13 @@ msgid "" "of *pattern*. The function takes a single :ref:`match object ` 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 :ref:`objeto match `, y devuelve la cadena de sustitución. Por ejemplo::" #: ../Doc/library/re.rst:877 msgid "The pattern may be a string or a :ref:`pattern object `." -msgstr "" +msgstr "El patrón puede ser una cadena o un :ref:`objeto patrón `." #: ../Doc/library/re.rst:879 msgid "" @@ -1136,6 +1630,12 @@ msgid "" "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')`` devuelve ``'-a-b--d-'``." #: ../Doc/library/re.rst:887 msgid "" @@ -1149,35 +1649,52 @@ msgid "" "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`` usará la " +"subcadena coincidente con el grupo llamado ``name``, como se define en la " +"sintaxis ``(?P...)``. ``\\g`` 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:900 ../Doc/library/re.rst:924 #: ../Doc/library/re.rst:1155 msgid "Unmatched groups are replaced with an empty string." -msgstr "" +msgstr "Los grupos no coincidentes son reemplazados por una cadena vacía." #: ../Doc/library/re.rst:903 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:907 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:911 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:918 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 devuelve una tupla " +"``(new_string, number_of_subs_made)``." #: ../Doc/library/re.rst:930 msgid "" @@ -1185,16 +1702,21 @@ msgid "" "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:945 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:953 msgid "The ``'_'`` character is no longer escaped." -msgstr "" +msgstr "El carácter de ``'_'`` ya no se escapa." #: ../Doc/library/re.rst:956 msgid "" @@ -1203,10 +1725,14 @@ msgid "" "``'/'``, ``':'``, ``';'``, ``'<'``, ``'='``, ``'>'``, ``'@'``, 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:965 msgid "Clear the regular expression cache." -msgstr "" +msgstr "Despeja la caché de expresión regular." #: ../Doc/library/re.rst:970 msgid "" @@ -1216,40 +1742,50 @@ msgid "" "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:978 msgid "The unformatted error message." -msgstr "" +msgstr "El mensaje de error sin formato." #: ../Doc/library/re.rst:982 msgid "The regular expression pattern." -msgstr "" +msgstr "El patrón de expresión regular." #: ../Doc/library/re.rst:986 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:990 msgid "The line corresponding to *pos* (may be ``None``)." -msgstr "" +msgstr "La línea correspondiente a *pos* (puede ser ``None``)." #: ../Doc/library/re.rst:994 msgid "The column corresponding to *pos* (may be ``None``)." -msgstr "" +msgstr "La columna correspondiente a *pos* (puede ser ``None``)." #: ../Doc/library/re.rst:996 msgid "Added additional attributes." -msgstr "" +msgstr "Se añadieron atributos adicionales." #: ../Doc/library/re.rst:1002 msgid "Regular Expression Objects" -msgstr "" +msgstr "Objetos expresión regular" #: ../Doc/library/re.rst:1004 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:" #: ../Doc/library/re.rst:1009 msgid "" @@ -1259,6 +1795,12 @@ msgid "" "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 *string* (\"cadena\") buscando la primera ubicación " +"donde esta expresión regular produce una coincidencia, y devuelve un :ref:" +"`objeto match ` correspondiente. Devuelve ``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:1015 msgid "" @@ -1268,6 +1810,11 @@ msgid "" "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:1021 msgid "" @@ -1278,6 +1825,12 @@ msgid "" "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:1036 msgid "" @@ -1286,18 +1839,28 @@ msgid "" "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 *beginning* (\"comienzo\") de la *string* " +"(\"cadena\") coinciden con esta expresión regular, devuelve un :ref:`objeto " +"match ` correspondiente. Devuelve ``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:1041 ../Doc/library/re.rst:1059 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:1049 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:1055 msgid "" @@ -1306,10 +1869,14 @@ msgid "" "string does not match the pattern; note that this is different from a zero-" "length match." msgstr "" +"Si toda la *string* (\"cadena\") coincide con esta expresión regular, " +"devuelve un :ref:`objeto match ` correspondiente. Devuelve " +"``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:1073 msgid "Identical to the :func:`split` function, using the compiled pattern." -msgstr "" +msgstr "Idéntico a la función :func:`split`, usando el patrón compilado." #: ../Doc/library/re.rst:1078 msgid "" @@ -1317,6 +1884,9 @@ msgid "" "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:1085 msgid "" @@ -1324,14 +1894,17 @@ msgid "" "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:1092 msgid "Identical to the :func:`sub` function, using the compiled pattern." -msgstr "" +msgstr "Idéntico a la función :func:`sub`, usando el patrón compilado." #: ../Doc/library/re.rst:1097 msgid "Identical to the :func:`subn` function, using the compiled pattern." -msgstr "" +msgstr "Idéntico a la función :func:`subn`, usando el patrón compilado." #: ../Doc/library/re.rst:1102 msgid "" @@ -1339,10 +1912,14 @@ msgid "" "`.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:1109 msgid "The number of capturing groups in the pattern." -msgstr "" +msgstr "El número de grupos de captura en el patrón." #: ../Doc/library/re.rst:1114 msgid "" @@ -1350,20 +1927,26 @@ msgid "" "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)`` para agrupar números. El diccionario está vacío si no se " +"utilizaron grupos simbólicos en el patrón." #: ../Doc/library/re.rst:1121 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:1124 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:1132 msgid "Match Objects" -msgstr "" +msgstr "Objetos de coincidencia" #: ../Doc/library/re.rst:1134 msgid "" @@ -1371,10 +1954,15 @@ msgid "" "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` " +"devuelven ``None`` cuando no hay coincidencia. Se puede probar si hubo una " +"coincidencia con una simple declaración ``if``::" #: ../Doc/library/re.rst:1143 msgid "Match objects support the following methods and attributes:" msgstr "" +"Los objetos de coincidencia admiten los siguientes métodos y atributos:" #: ../Doc/library/re.rst:1148 msgid "" @@ -1384,6 +1972,12 @@ msgid "" "backreferences (``\\1``, ``\\2``) and named backreferences (``\\g<1>``, ``" "\\g``) are replaced by the contents of the corresponding group." msgstr "" +"Devuelve 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``) son reemplazadas " +"por el contenido del grupo correspondiente." #: ../Doc/library/re.rst:1160 msgid "" @@ -1399,6 +1993,18 @@ msgid "" "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 "" +"Devuelve 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 devuelve 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 devuelve la última coincidencia. ::" #: ../Doc/library/re.rst:1182 msgid "" @@ -1407,24 +2013,32 @@ msgid "" "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...)``, 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:1187 msgid "A moderately complicated example::" -msgstr "" +msgstr "Un ejemplo moderadamente complicado::" #: ../Doc/library/re.rst:1195 msgid "Named groups can also be referred to by their index::" -msgstr "" +msgstr "Los grupos nombrados también pueden ser referidos por su índice::" #: ../Doc/library/re.rst:1202 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:1211 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:1227 msgid "" @@ -1432,10 +2046,14 @@ msgid "" "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 "" +"Devuelve 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:1231 ../Doc/library/re.rst:1453 msgid "For example::" -msgstr "" +msgstr "Por ejemplo::" #: ../Doc/library/re.rst:1237 msgid "" @@ -1443,6 +2061,9 @@ msgid "" "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:1250 msgid "" @@ -1450,6 +2071,10 @@ msgid "" "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 "" +"Devuelve 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:1262 msgid "" @@ -1459,6 +2084,12 @@ msgid "" "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 "" +"Devuelve 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). Devuelve ``-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:1270 msgid "" @@ -1467,10 +2098,17 @@ msgid "" "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:1275 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:1285 msgid "" @@ -1478,6 +2116,9 @@ msgid "" "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*, devuelve 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:1292 msgid "" @@ -1485,6 +2126,9 @@ msgid "" "`~Pattern.match` method of a :ref:`regex object `. 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 `. Este es el índice " +"de la cadena en la que el motor RE comenzó a buscar una coincidencia." #: ../Doc/library/re.rst:1299 msgid "" @@ -1492,6 +2136,9 @@ msgid "" "meth:`~Pattern.match` method of a :ref:`regex object `. 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 `. Este es el índice " +"de la cadena más allá de la cual el motor RE no irá." #: ../Doc/library/re.rst:1306 msgid "" @@ -1501,42 +2148,56 @@ msgid "" "``'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:1315 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:1321 msgid "" "The :ref:`regular expression object ` whose :meth:`~Pattern." "match` or :meth:`~Pattern.search` method produced this match instance." msgstr "" +"El :ref:`objeto de expresión regular ` cuyo método :meth:" +"`~Pattern.match` o :meth:`~Pattern.search` produce esta instancia de " +"coincidencia." #: ../Doc/library/re.rst:1327 msgid "The string passed to :meth:`~Pattern.match` or :meth:`~Pattern.search`." -msgstr "" +msgstr "La cadena pasada a :meth:`~Pattern.match` o :meth:`~Pattern.search`." #: ../Doc/library/re.rst:1330 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:1338 msgid "Regular Expression Examples" -msgstr "" +msgstr "Ejemplos de expresiones regulares" #: ../Doc/library/re.rst:1342 msgid "Checking for a Pair" -msgstr "" +msgstr "Buscando un par" #: ../Doc/library/re.rst:1344 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:1352 msgid "" @@ -1545,10 +2206,17 @@ msgid "" "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:1357 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:1367 msgid "" @@ -1556,16 +2224,21 @@ msgid "" "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:1377 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:1396 msgid "Simulating scanf()" -msgstr "" +msgstr "Simular scanf()" #: ../Doc/library/re.rst:1400 msgid "" @@ -1575,107 +2248,112 @@ msgid "" "equivalent mappings between :c:func:`scanf` format tokens and regular " "expressions." msgstr "" +"Python no tiene actualmente un equivalente a :c:func:`scanf`. Las " +"expresiones regulares son generalmente más poderosas, aunque también más " +"verbosas, que las cadenas de formato :c:func:`scanf`. La tabla siguiente " +"ofrece algunos mapeos más o menos equivalentes entre tokens de formato :c:" +"func:`scanf` y expresiones regulares." #: ../Doc/library/re.rst:1407 msgid ":c:func:`scanf` Token" -msgstr "" +msgstr "Token :c:func:`scanf`" #: ../Doc/library/re.rst:1407 msgid "Regular Expression" -msgstr "" +msgstr "Expresión regular" #: ../Doc/library/re.rst:1409 #, python-format msgid "``%c``" -msgstr "" +msgstr "``%c``" #: ../Doc/library/re.rst:1411 #, python-format msgid "``%5c``" -msgstr "" +msgstr "``%5c``" #: ../Doc/library/re.rst:1411 msgid "``.{5}``" -msgstr "" +msgstr "``.{5}``" #: ../Doc/library/re.rst:1413 #, python-format msgid "``%d``" -msgstr "" +msgstr "``%d``" #: ../Doc/library/re.rst:1413 msgid "``[-+]?\\d+``" -msgstr "" +msgstr "``[-+]?\\d+``" #: ../Doc/library/re.rst:1415 #, python-format msgid "``%e``, ``%E``, ``%f``, ``%g``" -msgstr "" +msgstr "``%e``, ``%E``, ``%f``, ``%g``" #: ../Doc/library/re.rst:1415 msgid "``[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?``" -msgstr "" +msgstr "``[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?``" #: ../Doc/library/re.rst:1417 #, python-format msgid "``%i``" -msgstr "" +msgstr "``%i``" #: ../Doc/library/re.rst:1417 msgid "``[-+]?(0[xX][\\dA-Fa-f]+|0[0-7]*|\\d+)``" -msgstr "" +msgstr "``[-+]?(0[xX][\\dA-Fa-f]+|0[0-7]*|\\d+)``" #: ../Doc/library/re.rst:1419 #, python-format msgid "``%o``" -msgstr "" +msgstr "``%o``" #: ../Doc/library/re.rst:1419 msgid "``[-+]?[0-7]+``" -msgstr "" +msgstr "``[-+]?[0-7]+``" #: ../Doc/library/re.rst:1421 #, python-format msgid "``%s``" -msgstr "" +msgstr "``%s``" #: ../Doc/library/re.rst:1421 msgid "``\\S+``" -msgstr "" +msgstr "``\\S+``" #: ../Doc/library/re.rst:1423 #, python-format msgid "``%u``" -msgstr "" +msgstr "``%u``" #: ../Doc/library/re.rst:1423 msgid "``\\d+``" -msgstr "" +msgstr "``\\d+``" #: ../Doc/library/re.rst:1425 #, python-format msgid "``%x``, ``%X``" -msgstr "" +msgstr "``%x``, ``%X``" #: ../Doc/library/re.rst:1425 msgid "``[-+]?(0[xX])?[\\dA-Fa-f]+``" -msgstr "" +msgstr "``[-+]?(0[xX])?[\\dA-Fa-f]+``" #: ../Doc/library/re.rst:1428 msgid "To extract the filename and numbers from a string like ::" -msgstr "" +msgstr "Para extraer el nombre de archivo y los números de una cadena como ::" #: ../Doc/library/re.rst:1432 msgid "you would use a :c:func:`scanf` format like ::" -msgstr "" +msgstr "se usaría un formato :c:func:`scanf` como ::" #: ../Doc/library/re.rst:1436 msgid "The equivalent regular expression would be ::" -msgstr "" +msgstr "La expresión regular equivalente sería ::" #: ../Doc/library/re.rst:1444 msgid "search() vs. match()" -msgstr "" +msgstr "search() vs. match()" #: ../Doc/library/re.rst:1448 msgid "" @@ -1684,12 +2362,19 @@ msgid "" "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)." #: ../Doc/library/re.rst:1459 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:1467 msgid "" @@ -1698,10 +2383,14 @@ msgid "" "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:1477 msgid "Making a Phonebook" -msgstr "" +msgstr "Haciendo una guía telefónica" #: ../Doc/library/re.rst:1479 msgid "" @@ -1710,18 +2399,28 @@ msgid "" "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:1484 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:1497 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:1510 msgid "" @@ -1729,6 +2428,10 @@ msgid "" "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:1523 msgid "" @@ -1736,10 +2439,13 @@ msgid "" "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:1538 msgid "Text Munging" -msgstr "" +msgstr "Mungear texto" #: ../Doc/library/re.rst:1540 msgid "" @@ -1748,10 +2454,15 @@ msgid "" "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:1557 msgid "Finding all Adverbs" -msgstr "" +msgstr "Encontrar todos los adverbios" #: ../Doc/library/re.rst:1559 msgid "" @@ -1760,10 +2471,14 @@ msgid "" "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:1570 msgid "Finding all Adverbs and their Positions" -msgstr "" +msgstr "Encontrar todos los adverbios y sus posiciones" #: ../Doc/library/re.rst:1572 msgid "" @@ -1773,10 +2488,16 @@ msgid "" "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 uno quiere más información sobre todas las coincidencias de un patrón en " +"lugar del texto coincidente, :func:`finditer` es útil ya que proporciona :" +"ref:`objetos de coincidencia ` 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:1586 msgid "Raw String Notation" -msgstr "" +msgstr "Notación de cadena *raw*" #: ../Doc/library/re.rst:1588 msgid "" @@ -1785,6 +2506,10 @@ msgid "" "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:1598 msgid "" @@ -1793,10 +2518,14 @@ msgid "" "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:1610 msgid "Writing a Tokenizer" -msgstr "" +msgstr "Escribir un Tokenizador" #: ../Doc/library/re.rst:1612 msgid "" @@ -1804,6 +2533,10 @@ msgid "" "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 `_ 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:1616 msgid "" @@ -1811,10 +2544,13 @@ msgid "" "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:1672 msgid "The tokenizer produces the following output::" -msgstr "" +msgstr "El tokenizador produce el siguiente resultado::" #: ../Doc/library/re.rst:1695 msgid "" @@ -1823,3 +2559,7 @@ msgid "" "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."