From 4a01dce0a6ea981c2f837b7774a317b5b6e19bba Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Wed, 28 Oct 2020 20:04:04 +0100 Subject: [PATCH 1/9] traducido howto/regex --- dictionaries/howto_regex.txt | 0 howto/regex.po | 1030 ++++++++++++++++++++++++++++++---- 2 files changed, 914 insertions(+), 116 deletions(-) create mode 100644 dictionaries/howto_regex.txt diff --git a/dictionaries/howto_regex.txt b/dictionaries/howto_regex.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/howto/regex.po b/howto/regex.po index 77d17b2d48..ac29c98ce0 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -6,34 +6,37 @@ # Check https://github.com/python/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-10-28 00:04+0100\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: \n" +"Language: es\n" +"X-Generator: Poedit 2.3.1\n" +"X-Poedit-SourceCharset: UTF-8\n" #: ../Doc/howto/regex.rst:5 msgid "Regular Expression HOWTO" -msgstr "" +msgstr "Expresiones regulares COMOS (*HOW TO*)" #: ../Doc/howto/regex.rst msgid "Author" -msgstr "" +msgstr "Autor" #: ../Doc/howto/regex.rst:7 msgid "A.M. Kuchling " -msgstr "" +msgstr "*A.M. Kuchling *" msgid "Abstract" -msgstr "" +msgstr "Resumen" #: ../Doc/howto/regex.rst:18 msgid "" @@ -41,10 +44,14 @@ msgid "" "Python with the :mod:`re` module. It provides a gentler introduction than " "the corresponding section in the Library Reference." msgstr "" +"Este documento es un tutorial de introducción al uso de expresiones " +"regulares en Python con el módulo :mod:`re`. Proporciona una introducción " +"más apacible que la sección correspondiente en la Referencia de la " +"biblioteca." #: ../Doc/howto/regex.rst:24 msgid "Introduction" -msgstr "" +msgstr "Introducción" #: ../Doc/howto/regex.rst:26 msgid "" @@ -58,6 +65,17 @@ msgid "" "match for the pattern anywhere in this string?\". You can also use REs to " "modify a string or to split it apart in various ways." msgstr "" +"Las expresiones regulares (llamadas RE, o regexes, o patrones de regex) son " +"esencialmente en un lenguaje de programación diminuto y altamente " +"especializado incrustado dentro de Python y disponible a través del módulo :" +"mod:`re`. Usando este pequeño lenguaje, especificas las reglas para el " +"conjunto de cadenas de caracteres posibles que deseas hacer coincidir; este " +"conjunto puede contener frases en inglés, o direcciones de correo " +"electrónico, o comandos *TeX*, o cualquier cosa que desee. A continuación, " +"puede hacer preguntas como “¿Coincide esta cadena con el patrón?” O “¿Hay " +"alguna coincidencia con el patrón en alguna parte de esta cadena?”. También " +"puede utilizar RE para modificar una cadena de caracteres o dividirla de " +"varias formas." #: ../Doc/howto/regex.rst:35 msgid "" @@ -69,6 +87,13 @@ msgid "" "requires that you have a good understanding of the matching engine's " "internals." msgstr "" +"Los patrones de expresiones regulares se compilan en una serie de códigos de " +"bytes que luego son ejecutados por un motor de coincidencia escrito en C. " +"Para un uso avanzado, puede ser necesario prestar mucha atención a cómo el " +"motor ejecutará un RE dado y escribir el RE en un de cierta manera para " +"producir un código de bytes que se ejecute más rápido. La optimización no se " +"trata en este documento, porque requiere que tenga un buen conocimiento de " +"los componentes internos del motor de coincidencia." #: ../Doc/howto/regex.rst:42 msgid "" @@ -80,10 +105,18 @@ msgid "" "be slower than an elaborate regular expression, it will also probably be " "more understandable." msgstr "" +"El lenguaje de expresiones regulares es relativamente pequeño y restringido, " +"por lo que no todas las posibles tareas de procesamiento de cadenas de " +"caracteres se pueden realizar utilizando expresiones regulares. También hay " +"tareas que *se pueden* hacer con expresiones regulares, pero las expresiones " +"resultan ser muy complicadas. En estos casos, es mejor que escriba código " +"Python para realizar el procesamiento; Si bien el código Python será más " +"lento que una expresión regular elaborada, probablemente también será más " +"comprensible." #: ../Doc/howto/regex.rst:51 msgid "Simple Patterns" -msgstr "" +msgstr "Patrones simples" #: ../Doc/howto/regex.rst:53 msgid "" @@ -91,6 +124,10 @@ msgid "" "Since regular expressions are used to operate on strings, we'll begin with " "the most common task: matching characters." msgstr "" +"Comenzaremos aprendiendo sobre las expresiones regulares más simples " +"posibles. Dado que las expresiones regulares se utilizan para operar en " +"cadenas de caracteres, comenzaremos con la tarea más común: hacer coincidir " +"caracteres." #: ../Doc/howto/regex.rst:57 msgid "" @@ -98,10 +135,14 @@ msgid "" "expressions (deterministic and non-deterministic finite automata), you can " "refer to almost any textbook on writing compilers." msgstr "" +"Para obtener una explicación detallada de la informática que subyace a las " +"expresiones regulares (autómatas finitos deterministas y no deterministas), " +"puede consultar casi cualquier libro de texto sobre la escritura de " +"compiladores." #: ../Doc/howto/regex.rst:63 msgid "Matching Characters" -msgstr "" +msgstr "Coincidencia de Caracteres (*Matching Characters*)" #: ../Doc/howto/regex.rst:65 msgid "" @@ -110,6 +151,11 @@ msgid "" "can enable a case-insensitive mode that would let this RE match ``Test`` or " "``TEST`` as well; more about this later.)" msgstr "" +"La mayoría de letras y caracteres simplemente coincidirán. Por ejemplo, la " +"expresión regular ``test`` coincidirá exactamente con la cadena ``test``. " +"(Puede habilitar un modo que no distinga entre mayúsculas y minúsculas que " +"permitiría que este RE coincida con ``test`` o ``TEST`` también; más sobre " +"esto más adelante.)" #: ../Doc/howto/regex.rst:70 msgid "" @@ -120,12 +166,19 @@ msgid "" "this document is devoted to discussing various metacharacters and what they " "do." msgstr "" +"Hay excepciones a esta regla; algunos caracteres son especiales :dfn:" +"`metacharacters`, y no coinciden. En cambio, señalan que debe coincidir con " +"algo fuera de lo común, o afectan otras partes del RE repitiéndolos o " +"cambiando su significado. Gran parte de este documento está dedicado a " +"discutir varios metacaracteres y lo que hacen." #: ../Doc/howto/regex.rst:76 msgid "" "Here's a complete list of the metacharacters; their meanings will be " "discussed in the rest of this HOWTO." msgstr "" +"Aquí hay una lista completa de los metacaracteres; sus significados se " +"discutirán en el resto de este COMO (*HOWTO*)." #: ../Doc/howto/regex.rst:83 msgid "" @@ -138,6 +191,14 @@ msgid "" "characters. If you wanted to match only lowercase letters, your RE would be " "``[a-z]``." msgstr "" +"Los primeros metacaracteres que veremos son ``[`` and ``]``. Se utilizan " +"para especificar una clase de carácter, que es un conjunto de caracteres que " +"desea hacer coincidir. Los caracteres se pueden enumerar individualmente, o " +"se puede indicar un rango de caracteres dando dos caracteres y separándolos " +"con un ``’-‘``. Por ejemplo, ``[abc]`` coincidirá con cualquiera de los " +"caracteres ``a``, ``b`` o ``c``; esto es lo mismo que ``[a-c]``, que usa un " +"rango para expresar el mismo conjunto de caracteres. Si quisiera hacer " +"coincidir solo letras minúsculas, su RE sería ``[a-c]``." #: ../Doc/howto/regex.rst:92 msgid "" @@ -146,6 +207,10 @@ msgid "" "is usually a metacharacter, but inside a character class it's stripped of " "its special nature." msgstr "" +"Los metacaracteres no están activos dentro de las clases. Por ejemplo, ``[akm" +"$]`` coincidirá con cualquiera de los caracteres ``’a’``, ``’k’``, ``’m’``, " +"or ``’$’``; ``’$’`` suele ser un metacaracter, pero dentro de una clase de " +"caracter se le quita su naturaleza especial." #: ../Doc/howto/regex.rst:97 msgid "" @@ -156,6 +221,12 @@ msgid "" "does not have special meaning. For example: ``[5^]`` will match either a " "``'5'`` or a ``'^'``." msgstr "" +"Puede hacer coincidir los caracteres que no figuran en la clase mediante el " +"conjunto :dfn:`complementing`. Esto se indica mediante la inclusión de un " +"``’^’`` como primer carácter de la clase. Por ejemplo, ``[^5]`` coincidirá " +"con cualquier carácter excepto con ``’5’``.Si el símbolo de intercalación " +"aparece en otra parte de una clase de caracter, no tiene un significado " +"especial. Por ejemplo: ``[5^] `` coincidirá con un `` ‘5’`` o un ``’^’``." #: ../Doc/howto/regex.rst:103 msgid "" @@ -166,6 +237,13 @@ msgid "" "need to match a ``[`` or ``\\``, you can precede them with a backslash to " "remove their special meaning: ``\\[`` or ``\\\\``." msgstr "" +"Quizás el metacarácter más importante es la barra invertida, `` \\ ‘’. Al " +"igual que en los literales de cadena de Python, la barra invertida puede ir " +"seguida de varios caracteres para señalar varias secuencias especiales. " +"También se usa para escapar de todos los metacaracteres, de modo que aún " +"pueda emparejarlos en patrones; por ejemplo, si necesita hacer coincidir un " +"`` [`` o `` \\ ``, puede precederlos con una barra invertida para eliminar " +"su significado especial: `` \\ [`` o `` \\\\ ``." #: ../Doc/howto/regex.rst:110 msgid "" @@ -173,6 +251,10 @@ msgid "" "sets of characters that are often useful, such as the set of digits, the set " "of letters, or the set of anything that isn't whitespace." msgstr "" +"Algunas de las secuencias especiales que comienzan con ``’\\’`` representan " +"conjuntos predefinidos de caracteres que a menudo son útiles, como el " +"conjunto de dígitos, el conjunto de letras o el conjunto de cualquier cosa " +"que no sea un espacio en blanco." #: ../Doc/howto/regex.rst:115 msgid "" @@ -184,6 +266,14 @@ msgid "" "in a string pattern by supplying the :const:`re.ASCII` flag when compiling " "the regular expression." msgstr "" +"Tomemos un ejemplo: ``\\w`` coincide con cualquier carácter alfanumérico. Si " +"el patrón de expresiones regulares se expresa en bytes, esto es equivalente " +"a la clase ``[a-zA-Z0-9_]``. Si el patrón de expresiones regulares es una " +"cadena de caracteres, ``\\w`` coincidirá con todos los caracteres marcados " +"como letras en la base de datos Unicode proporcionada por el módulo :mod:" +"`unicodedata`. Puede usar la definición más restringida de ``\\w`` en un " +"patrón de cadena proporcionando el indicador :const:`re.ASCII` al compilar " +"la expresión regular." #: ../Doc/howto/regex.rst:123 msgid "" @@ -193,63 +283,81 @@ msgid "" "Standard Library reference. In general, the Unicode versions match any " "character that's in the appropriate category in the Unicode database." msgstr "" +"La siguiente lista de secuencias especiales no está completa. Para obtener " +"una lista completa de secuencias y definiciones de clases expandidas para " +"patrones de cadenas Unicode, consulte la última parte de :ref:`Regular " +"Expression Syntax ` en la referencia de la biblioteca estándar. " +"En general, las versiones Unicode coinciden con cualquier caracter que esté " +"en la categoría apropiada en la base de datos Unicode." #: ../Doc/howto/regex.rst:131 msgid "``\\d``" -msgstr "" +msgstr "``\\d``" #: ../Doc/howto/regex.rst:131 msgid "Matches any decimal digit; this is equivalent to the class ``[0-9]``." msgstr "" +"Coincide con cualquier dígito decimal; esto es equivalente a la clase " +"``[0-9]``." #: ../Doc/howto/regex.rst:134 msgid "``\\D``" -msgstr "" +msgstr "``\\D``" #: ../Doc/howto/regex.rst:134 msgid "" "Matches any non-digit character; this is equivalent to the class ``[^0-9]``." msgstr "" +"Coincide con cualquier caracter que no sea un dígito; esto es equivalente a " +"la clase ``[^0-9]``." #: ../Doc/howto/regex.rst:138 msgid "``\\s``" -msgstr "" +msgstr "``\\s``" #: ../Doc/howto/regex.rst:137 msgid "" "Matches any whitespace character; this is equivalent to the class ``[ \\t\\n" "\\r\\f\\v]``." msgstr "" +"Coincide con cualquier caracter de espacio en blanco; esto es equivalente a " +"la clase ``[ \\t\\n\\r\\f\\v]``." #: ../Doc/howto/regex.rst:142 msgid "``\\S``" -msgstr "" +msgstr "``\\S``" #: ../Doc/howto/regex.rst:141 msgid "" "Matches any non-whitespace character; this is equivalent to the class ``[^ " "\\t\\n\\r\\f\\v]``." msgstr "" +"Coincide con cualquier caracter que no sea un espacio en blanco; esto es " +"equivalente a la clase ``[^ \\t\\n\\r\\f\\v]``." #: ../Doc/howto/regex.rst:146 msgid "``\\w``" -msgstr "" +msgstr "``\\w``" #: ../Doc/howto/regex.rst:145 msgid "" "Matches any alphanumeric character; this is equivalent to the class ``[a-zA-" "Z0-9_]``." msgstr "" +"Coincide con cualquier caracter alfanumérico; esto es equivalente a la clase " +"``[a-zA-Z0-9_]``." #: ../Doc/howto/regex.rst:150 msgid "``\\W``" -msgstr "" +msgstr "``\\W``" #: ../Doc/howto/regex.rst:149 msgid "" "Matches any non-alphanumeric character; this is equivalent to the class " "``[^a-zA-Z0-9_]``." msgstr "" +"Coincide con cualquier caracter no alfanumérico; esto es equivalente a la " +"clase``[^a-zA-Z0-9_]``." #: ../Doc/howto/regex.rst:152 msgid "" @@ -257,6 +365,9 @@ msgid "" "``[\\s,.]`` is a character class that will match any whitespace character, " "or ``','`` or ``'.'``." msgstr "" +"Estas secuencias se pueden incluir dentro de una clase de personaje. Por " +"ejemplo, ``[\\s,.]`` es una clase de caracter que coincidirá con cualquier " +"carácter de espacio en blanco, o ``’,’`` o ``’.’``." #: ../Doc/howto/regex.rst:156 msgid "" @@ -265,10 +376,14 @@ msgid "" "DOTALL`) where it will match even a newline. ``.`` is often used where you " "want to match \"any character\"." msgstr "" +"El metacaracter final en esta sección es ``.``. Coincide con cualquier cosa " +"excepto un caracter de nueva línea, y hay un modo alternativo (:const:`re." +"DOTALL`) donde coincidirá incluso con una nueva línea. ``.`` se usa a menudo " +"cuando se desea hacer coincidir “cualquier carácter”." #: ../Doc/howto/regex.rst:163 msgid "Repeating Things" -msgstr "" +msgstr "Repitiendo cosas (*Repeating Things*)" #: ../Doc/howto/regex.rst:165 msgid "" @@ -278,6 +393,12 @@ msgid "" "they wouldn't be much of an advance. Another capability is that you can " "specify that portions of the RE must be repeated a certain number of times." msgstr "" +"Ser capaz de hacer coincidir diferentes conjuntos de caracteres es lo " +"primero que pueden hacer las expresiones regulares que ya no es posible con " +"los métodos disponibles en cadenas. Sin embargo, si esa fuera la única " +"capacidad adicional de las expresiones regulares, no serían un gran avance. " +"Otra capacidad es que puede especificar que partes del RE deben repetirse un " +"cierto número de veces." #: ../Doc/howto/regex.rst:171 msgid "" @@ -286,12 +407,18 @@ msgid "" "that the previous character can be matched zero or more times, instead of " "exactly once." msgstr "" +"El primer metacaracter para repetir cosas que veremos es ``*``. ``*`` no " +"coincide con el caracter literal ``’*’``; en cambio, especifica que el " +"carácter anterior puede coincidir cero o más veces, en lugar de exactamente " +"una vez." #: ../Doc/howto/regex.rst:175 msgid "" "For example, ``ca*t`` will match ``'ct'`` (0 ``'a'`` characters), ``'cat'`` " "(1 ``'a'``), ``'caaat'`` (3 ``'a'`` characters), and so forth." msgstr "" +"Por ejemplo, ``ca*t`` coincidirá con ``’ct’`` (0 ``’a’`` caracteres), " +"``’cat’`` (1 ``’a’``), ``’caaat’`` (3 ``’a’`` characters), etcétera." #: ../Doc/howto/regex.rst:178 msgid "" @@ -300,6 +427,10 @@ msgid "" "portions of the pattern don't match, the matching engine will then back up " "and try again with fewer repetitions." msgstr "" +"Las repeticiones como ``*`` son :dfn:`greedy`; al repetir un RE, el motor de " +"emparejamiento intentará repetirlo tantas veces como sea posible. Si las " +"partes posteriores del patrón no coinciden, el motor de coincidencia hará " +"una copia de seguridad y volverá a intentarlo con menos repeticiones." #: ../Doc/howto/regex.rst:183 msgid "" @@ -308,98 +439,114 @@ msgid "" "letters from the class ``[bcd]``, and finally ends with a ``'b'``. Now " "imagine matching this RE against the string ``'abcbd'``." msgstr "" +"Un ejemplo paso a paso hará que esto sea más obvio. Consideremos la " +"expresión ``a[bcd]*b``. Esto coincide con la letra ``’a’``, cero o más " +"letras de la clase ``[bcd]``, y finalmente termina con una ``’b’``. Ahora " +"imagina hacer coincidir este RE con la cadena de caracteres ``’abcbd’``." #: ../Doc/howto/regex.rst:189 msgid "Step" -msgstr "" +msgstr "Pasos" #: ../Doc/howto/regex.rst:189 msgid "Matched" -msgstr "" +msgstr "Coincidencias" #: ../Doc/howto/regex.rst:189 msgid "Explanation" -msgstr "" +msgstr "Explicación" #: ../Doc/howto/regex.rst:191 msgid "1" -msgstr "" +msgstr "1" #: ../Doc/howto/regex.rst:191 msgid "``a``" -msgstr "" +msgstr "``a``" #: ../Doc/howto/regex.rst:191 msgid "The ``a`` in the RE matches." -msgstr "" +msgstr "La ``a`` en los RE coincide." #: ../Doc/howto/regex.rst:193 msgid "2" -msgstr "" +msgstr "2" #: ../Doc/howto/regex.rst:193 msgid "``abcbd``" -msgstr "" +msgstr "``abcbd``" #: ../Doc/howto/regex.rst:193 msgid "" "The engine matches ``[bcd]*``, going as far as it can, which is to the end " "of the string." msgstr "" +"El motor coincide con ``[bcd]*``, yendo tan lejos como puede, que es hasta " +"el final de la cadena de caracteres." #: ../Doc/howto/regex.rst:197 msgid "3" -msgstr "" +msgstr "3" #: ../Doc/howto/regex.rst:197 ../Doc/howto/regex.rst:205 msgid "*Failure*" -msgstr "" +msgstr "*Failure*" #: ../Doc/howto/regex.rst:197 msgid "" "The engine tries to match ``b``, but the current position is at the end of " "the string, so it fails." msgstr "" +"El motor intenta hacer coincidir ``b``,pero la posición actual está al final " +"de la cadena de caracteres, por lo que falla." #: ../Doc/howto/regex.rst:202 msgid "4" -msgstr "" +msgstr "4" #: ../Doc/howto/regex.rst:202 ../Doc/howto/regex.rst:213 msgid "``abcb``" -msgstr "" +msgstr "``abcb``" #: ../Doc/howto/regex.rst:202 msgid "Back up, so that ``[bcd]*`` matches one less character." msgstr "" +"Hace una copia de seguridad para que ``[bcd]*`` coincida con un carácter " +"menos." #: ../Doc/howto/regex.rst:205 msgid "5" -msgstr "" +msgstr "5" #: ../Doc/howto/regex.rst:205 msgid "" "Try ``b`` again, but the current position is at the last character, which is " "a ``'d'``." msgstr "" +"Intente ``b`` de nuevo, pero la posición actual está en el último caracter, " +"que es un ``’d’``." #: ../Doc/howto/regex.rst:209 ../Doc/howto/regex.rst:213 msgid "6" -msgstr "" +msgstr "6" #: ../Doc/howto/regex.rst:209 msgid "``abc``" -msgstr "" +msgstr "``abc``" #: ../Doc/howto/regex.rst:209 msgid "Back up again, so that ``[bcd]*`` is only matching ``bc``." msgstr "" +"Hace una copia de seguridad de nuevo, de modo que ``[bcd]*`` solo coincida " +"con ``bc``." #: ../Doc/howto/regex.rst:213 msgid "" "Try ``b`` again. This time the character at the current position is " "``'b'``, so it succeeds." msgstr "" +"Intenta ``b`` de nuevo. Esta vez, el caracter en la posición actual es " +"``’b’``, por lo que tiene éxito." #: ../Doc/howto/regex.rst:219 msgid "" @@ -410,6 +557,13 @@ msgid "" "``[bcd]*``, and if that subsequently fails, the engine will conclude that " "the string doesn't match the RE at all." msgstr "" +"Se ha alcanzado el final del RE y ha coincidido con ``’abcb’``. Esto " +"demuestra cómo el motor de coincidencias llega tan lejos como puede al " +"principio, y si no se encuentra ninguna coincidencia, retrocederá " +"progresivamente y volverá a intentar el resto del RE una y otra vez. Hará " +"una copia de seguridad hasta que haya probado cero coincidencias para " +"``[bcd]*``, y si eso falla posteriormente, el motor concluirá que la cadena " +"no coincide con el RE en absoluto." #: ../Doc/howto/regex.rst:226 msgid "" @@ -420,6 +574,12 @@ msgid "" "similar example, ``ca+t`` will match ``'cat'`` (1 ``'a'``), ``'caaat'`` (3 " "``'a'``\\ s), but won't match ``'ct'``." msgstr "" +"Otro metacaracter que se repite es `` + ‘’, que coincide una o más veces. " +"Preste especial atención a la diferencia entre ``*`` and ``+``; coincide con " +"* cero * o más veces, por lo que cualquier cosa que se repita puede no estar " +"presente en absoluto, mientras que ``+`` requiere al menos * una * " +"aparición. Para usar un ejemplo similar, ``’cat’`` (1 ``’a’``), ``’caaat’`` " +"(3 ``’a’``\\ s), pero no coincidirá con ``’ct’``." #: ../Doc/howto/regex.rst:233 msgid "" @@ -428,6 +588,10 @@ msgid "" "something as being optional. For example, ``home-?brew`` matches either " "``'homebrew'`` or ``'home-brew'``." msgstr "" +"Hay dos calificadores más que se repiten. El carácter de signo de " +"interrogación, ``?``, Coincide una vez o cero veces; puede pensar en ello " +"como si marcara algo como opcional. Por ejemplo, ``home-?brew`` coincide con " +"``’homebrew’`` o ``’home-brew’``." #: ../Doc/howto/regex.rst:238 msgid "" @@ -437,6 +601,11 @@ msgid "" "b'``, ``'a//b'``, and ``'a///b'``. It won't match ``'ab'``, which has no " "slashes, or ``'a////b'``, which has four." msgstr "" +"El calificador repetido más complicado es ``{m,n}``, donde *m* y *n* son " +"enteros decimales. Este calificador significa que debe haber al menos *m* " +"repeticiones y como máximo *n*. Por ejemplo, ``a/{1,3}b`` coincidirá con``’a/" +"b’``, ``’a//b’``, and ``’a///b’``. No coincidirá con `` ‘ab’ ‘, que no tiene " +"barras, ni con ``’a////b’``, que tiene cuatro." #: ../Doc/howto/regex.rst:244 msgid "" @@ -444,6 +613,9 @@ msgid "" "for the missing value. Omitting *m* is interpreted as a lower limit of 0, " "while omitting *n* results in an upper bound of infinity." msgstr "" +"Puede omitir *m* o *n*; en ese caso, se asume un valor razonable para el " +"valor faltante. Omitir *m* se interpreta como un límite inferior de 0, " +"mientras que omitir *n* da como resultado un límite superior de infinito." #: ../Doc/howto/regex.rst:248 msgid "" @@ -453,10 +625,15 @@ msgid "" "better to use ``*``, ``+``, or ``?`` when you can, simply because they're " "shorter and easier to read." msgstr "" +"Los lectores de una inclinación reduccionista pueden notar que los otros " +"tres calificativos pueden expresarse usando esta notación. ``{0,}`` es lo " +"mismo que ``*``, ``{1,}`` es equivalente a ``+``, y ``{0,1}`` es lo mismo " +"que ``?``. Es mejor usar ``*``, ``+``, o ``?`` cuando pueda, simplemente " +"porque son más cortos y fáciles de leer." #: ../Doc/howto/regex.rst:256 msgid "Using Regular Expressions" -msgstr "" +msgstr "Usando Expresiones regulares" #: ../Doc/howto/regex.rst:258 msgid "" @@ -465,17 +642,25 @@ msgid "" "regular expression engine, allowing you to compile REs into objects and then " "perform matches with them." msgstr "" +"Ahora que hemos visto algunas expresiones regulares simples, ¿cómo las " +"usamos realmente en Python? El módulo :mod:`re` proporciona una interfaz " +"para el motor de expresiones regulares, lo que le permite compilar RE en " +"objetos y luego realizar coincidencias con ellos." #: ../Doc/howto/regex.rst:265 msgid "Compiling Regular Expressions" -msgstr "" +msgstr "Compilando Expresiones regulares" #: ../Doc/howto/regex.rst:267 +#, fuzzy msgid "" "Regular expressions are compiled into pattern objects, which have methods " "for various operations such as searching for pattern matches or performing " "string substitutions. ::" msgstr "" +"Las expresiones regulares se compilan en objetos de patrón, que tienen " +"métodos para diversas operaciones, como buscar coincidencias de patrones o " +"realizar sustituciones de cadenas de caracteres. ::" #: ../Doc/howto/regex.rst:276 msgid "" @@ -483,6 +668,10 @@ msgid "" "various special features and syntax variations. We'll go over the available " "settings later, but for now a single example will do::" msgstr "" +":func:`re.compile` también acepta un argumento opcional *flags*, usado para " +"habilitar varias características especiales y variaciones de sintaxis. " +"Repasaremos las configuraciones disponibles más adelante, pero por ahora un " +"solo ejemplo servirá:" #: ../Doc/howto/regex.rst:282 msgid "" @@ -494,16 +683,26 @@ msgid "" "simply a C extension module included with Python, just like the :mod:" "`socket` or :mod:`zlib` modules." msgstr "" +"El RE se pasa a :func:`re.compile` como una cadena. Los RE se manejan como " +"cadenas porque las expresiones regulares no son parte del lenguaje central " +"de Python y no se creó una sintaxis especial para expresarlas. (Hay " +"aplicaciones que no necesitan RE en absoluto, por lo que no hay necesidad de " +"aumentar la especificación del lenguaje incluyéndolas). En cambio, el " +"módulo :mod:`re` es simplemente un módulo de extensión C incluido con " +"Python, al igual que los módulos :mod:`socket` o :mod:zlib`." #: ../Doc/howto/regex.rst:289 msgid "" "Putting REs in strings keeps the Python language simpler, but has one " "disadvantage which is the topic of the next section." msgstr "" +"Poner RE en cadenas mantiene el lenguaje Python más simple, pero tiene una " +"desventaja que es el tema de la siguiente sección." #: ../Doc/howto/regex.rst:296 +#, fuzzy msgid "The Backslash Plague" -msgstr "" +msgstr "La maldita barra invertida (*The Backslash Plague*)" #: ../Doc/howto/regex.rst:298 msgid "" @@ -512,6 +711,11 @@ msgid "" "used without invoking their special meaning. This conflicts with Python's " "usage of the same character for the same purpose in string literals." msgstr "" +"Como se indicó anteriormente, las expresiones regulares usan el carácter de " +"barra invertida (``’\\’``) para indicar formas especiales o para permitir " +"que se usen caracteres especiales sin invocar su significado especial. Esto " +"entra en conflicto con el uso de Python del mismo carácter para el mismo " +"propósito en cadenas literales." #: ../Doc/howto/regex.rst:303 msgid "" @@ -524,38 +728,48 @@ msgid "" "to express this as a Python string literal, both backslashes must be escaped " "*again*." msgstr "" +"Supongamos que desea escribir un RE que coincida con la cadena ``" +"\\section``, que podría encontrarse en un archivo *LaTeX*. Para averiguar " +"qué escribir en el código del programa, comience con la cadena deseada para " +"que coincida. A continuación, debe escapar de las barras invertidas y otros " +"metacaracteres precediéndolos con una barra invertida, lo que da como " +"resultado la cadena `` \\\\ sección ‘’. La cadena resultante que debe " +"pasarse a :func:`re.compile` debe ser ``\\\\section``. Sin embargo, para " +"expresar esto como una cadena literal de Python, ambas barras invertidas " +"deben escaparse *nuevamente*." #: ../Doc/howto/regex.rst:312 msgid "Characters" -msgstr "" +msgstr "Caracteres" #: ../Doc/howto/regex.rst:312 msgid "Stage" -msgstr "" +msgstr "Explicación" #: ../Doc/howto/regex.rst:314 msgid "``\\section``" -msgstr "" +msgstr "``\\section``" #: ../Doc/howto/regex.rst:314 msgid "Text string to be matched" -msgstr "" +msgstr "Cadena de texto que debe coincidir" #: ../Doc/howto/regex.rst:316 msgid "``\\\\section``" -msgstr "" +msgstr "``\\\\section``" #: ../Doc/howto/regex.rst:316 msgid "Escaped backslash for :func:`re.compile`" -msgstr "" +msgstr "Barra invertida de escape para :func:`re.compile`" #: ../Doc/howto/regex.rst:318 ../Doc/howto/regex.rst:345 msgid "``\"\\\\\\\\section\"``" -msgstr "" +msgstr "``”\\\\\\\\section”``" #: ../Doc/howto/regex.rst:318 msgid "Escaped backslashes for a string literal" msgstr "" +"Barra diagonal inversa de escape para un literal de cadena de caracteres" #: ../Doc/howto/regex.rst:321 msgid "" @@ -565,6 +779,12 @@ msgid "" "literal. In REs that feature backslashes repeatedly, this leads to lots of " "repeated backslashes and makes the resulting strings difficult to understand." msgstr "" +"En resumen, para hacer coincidir una barra invertida literal, uno tiene que " +"escribir ``’\\\\\\\\’`` como la cadena RE, porque la expresión regular debe " +"ser ``\\\\``, y cada barra invertida debe expresarse como ``\\\\`` dentro de " +"un literal de cadena Python normal. En los RE que presentan barras " +"invertidas repetidamente, esto genera muchas barras invertidas repetidas y " +"dificulta la comprensión de las cadenas resultantes." #: ../Doc/howto/regex.rst:327 msgid "" @@ -575,6 +795,13 @@ msgid "" "newline. Regular expressions will often be written in Python code using this " "raw string notation." msgstr "" +"La solución es utilizar la notación de cadena sin formato de Python para " +"expresiones regulares; las barras invertidas no se manejan de ninguna manera " +"especial en una cadena literal con el prefijo ``’r’``, por lo 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. Las " +"expresiones regulares a menudo se escribirán en código Python utilizando " +"esta notación de cadena sin formato." #: ../Doc/howto/regex.rst:333 msgid "" @@ -584,38 +811,45 @@ msgid "" "means the sequences will be invalid if raw string notation or escaping the " "backslashes isn't used." msgstr "" +"Además, las secuencias de escape especiales que son válidas en expresiones " +"regulares, pero no válidas como literales de cadena de Python, ahora dan " +"como resultado :exc:`DeprecationWarning` y eventualmente se convertirán en :" +"exc:`SyntaxError`, lo que significa que las secuencias no serán válidas. si " +"no se utiliza la notación de cadena sin formato o el escape de las barras " +"invertidas." #: ../Doc/howto/regex.rst:341 msgid "Regular String" -msgstr "" +msgstr "Cadena de caracteres regular" #: ../Doc/howto/regex.rst:341 msgid "Raw string" -msgstr "" +msgstr "Cadena de caracteres cruda (*Raw string*)" #: ../Doc/howto/regex.rst:343 msgid "``\"ab*\"``" -msgstr "" +msgstr "``”ab*”``" #: ../Doc/howto/regex.rst:343 msgid "``r\"ab*\"``" -msgstr "" +msgstr "``r”ab*”``" #: ../Doc/howto/regex.rst:345 msgid "``r\"\\\\section\"``" -msgstr "" +msgstr "``r”\\\\section”``" #: ../Doc/howto/regex.rst:347 msgid "``\"\\\\w+\\\\s+\\\\1\"``" -msgstr "" +msgstr "``”\\\\w+\\\\s+\\\\1”``" #: ../Doc/howto/regex.rst:347 msgid "``r\"\\w+\\s+\\1\"``" -msgstr "" +msgstr "``r”\\w+\\s+\\1”``" #: ../Doc/howto/regex.rst:352 +#, fuzzy msgid "Performing Matches" -msgstr "" +msgstr "Realizando coincidencias" #: ../Doc/howto/regex.rst:354 msgid "" @@ -624,50 +858,59 @@ msgid "" "the most significant ones will be covered here; consult the :mod:`re` docs " "for a complete listing." msgstr "" +"Una vez que tiene un objeto que representa una expresión regular compilada, " +"¿qué hace con él? Los objetos de patrón tienen varios métodos y atributos. " +"Aquí solo se cubrirán los más importantes; consulte los documentos :mod:`re` " +"para obtener una lista completa." #: ../Doc/howto/regex.rst:360 ../Doc/howto/regex.rst:418 #: ../Doc/howto/regex.rst:1064 msgid "Method/Attribute" -msgstr "" +msgstr "Método/atributo" #: ../Doc/howto/regex.rst:360 ../Doc/howto/regex.rst:418 #: ../Doc/howto/regex.rst:1064 msgid "Purpose" -msgstr "" +msgstr "Objetivo" #: ../Doc/howto/regex.rst:362 msgid "``match()``" -msgstr "" +msgstr "``match()``" #: ../Doc/howto/regex.rst:362 msgid "Determine if the RE matches at the beginning of the string." -msgstr "" +msgstr "Determina si el RE coincide con el comienzo de la cadena." #: ../Doc/howto/regex.rst:365 msgid "``search()``" -msgstr "" +msgstr "``search()``" #: ../Doc/howto/regex.rst:365 msgid "Scan through a string, looking for any location where this RE matches." msgstr "" +"Escanea una cadena, buscando cualquier ubicación donde coincida este RE." #: ../Doc/howto/regex.rst:368 msgid "``findall()``" -msgstr "" +msgstr "``findall()``" #: ../Doc/howto/regex.rst:368 msgid "Find all substrings where the RE matches, and returns them as a list." msgstr "" +"Encuentra todas las subcadenas de caracteres donde coincide el RE y las " +"devuelve como una lista." #: ../Doc/howto/regex.rst:371 msgid "``finditer()``" -msgstr "" +msgstr "``finditer()``" #: ../Doc/howto/regex.rst:371 msgid "" "Find all substrings where the RE matches, and returns them as an :term:" "`iterator`." msgstr "" +"Encuentra todas las subcadenas donde el RE coincide y las devuelve como un " +"término iterado :term:`iterator`." #: ../Doc/howto/regex.rst:375 msgid "" @@ -676,6 +919,11 @@ msgid "" "objects>` instance is returned, containing information about the match: " "where it starts and ends, the substring it matched, and more." msgstr "" +":meth:`~re.Pattern.match` y :meth:`~re.Pattern.search` retornan ``None`` si " +"la coincidencia no puede ser encontrada. Si tienen éxito, se retorna una " +"instancia :ref:`match object `, que contiene información " +"sobre la coincidencia: dónde comienza y termina, la subcadena de caracteres " +"con la que coincidió, y más." #: ../Doc/howto/regex.rst:380 msgid "" @@ -686,12 +934,21 @@ msgid "" "whether the RE matches or fails. :file:`redemo.py` can be quite useful when " "trying to debug a complicated RE." msgstr "" +"Puede aprender sobre esto experimentando interactivamente con el módulo :mod:" +"`re`. Si tiene :mod:`tkinter` disponible, también puede consultar :source:" +"`Tools/demo/redemo.py`, un programa de demostración incluido con la " +"distribución de Python. Le permite ingresar RE y cadenas, y muestra si el RE " +"coincide o falla. :file:`redemo.py` puede ser bastante útil cuando se " +"intenta depurar un RE complicado." #: ../Doc/howto/regex.rst:387 msgid "" "This HOWTO uses the standard Python interpreter for its examples. First, run " "the Python interpreter, import the :mod:`re` module, and compile a RE::" msgstr "" +"Este CÓMO (*HOWTO*) utiliza el intérprete estándar de Python para sus " +"ejemplos. Primero, ejecute el intérprete de Python, importe el módulo :mod:" +"`re` y compile en RE::" #: ../Doc/howto/regex.rst:395 msgid "" @@ -701,6 +958,12 @@ msgid "" "which will cause the interpreter to print no output. You can explicitly " "print the result of :meth:`!match` to make this clear. ::" msgstr "" +"Ahora, puede intentar hacer coincidir varias cadenas con el RE ``[a-z]+``. " +"Una cadena de caracteres vacía no debería coincidir en absoluto, ya que ``" +"+`` significa ‘una o más repeticiones’. :meth:`~ re.Pattern.match` debería " +"devolver``None`` en este caso, lo que hará que el intérprete no imprima " +"ningún resultado. Puede imprimir explícitamente el resultado de :meth:`!" +"match` para aclarar esto. ::" #: ../Doc/howto/regex.rst:405 msgid "" @@ -708,6 +971,10 @@ msgid "" "this case, :meth:`~re.Pattern.match` will return a :ref:`match object `, so you should store the result in a variable for later use. ::" msgstr "" +"Ahora, intentémoslo en una cadena de caracteres que debería coincidir, como " +"``tempo``.En este caso ,:meth:`~re.Pattern.match` retornará un :ref:`match " +"object `, por lo que debe almacenar el resultado en una " +"variable para su uso posterior. ::" #: ../Doc/howto/regex.rst:413 msgid "" @@ -715,42 +982,47 @@ msgid "" "about the matching string. Match object instances also have several methods " "and attributes; the most important ones are:" msgstr "" +"Ahora puede consultar: ref: `match object ` para obtener " +"información sobre la cadena coincidente. Las instancias de objetos " +"coincidentes también tienen varios métodos y atributos; los más importantes " +"son:" #: ../Doc/howto/regex.rst:420 msgid "``group()``" -msgstr "" +msgstr "``group()``" #: ../Doc/howto/regex.rst:420 msgid "Return the string matched by the RE" -msgstr "" +msgstr "Retorna la cadena de caracteres que coincide con el RE" #: ../Doc/howto/regex.rst:422 msgid "``start()``" -msgstr "" +msgstr "``start()``" #: ../Doc/howto/regex.rst:422 msgid "Return the starting position of the match" -msgstr "" +msgstr "Retorna la posición de inicio de la coincidencia" #: ../Doc/howto/regex.rst:424 msgid "``end()``" -msgstr "" +msgstr "``end()``" #: ../Doc/howto/regex.rst:424 msgid "Return the ending position of the match" -msgstr "" +msgstr "Retorna la posición final de la coincidencia" #: ../Doc/howto/regex.rst:426 msgid "``span()``" -msgstr "" +msgstr "``span()``" #: ../Doc/howto/regex.rst:426 msgid "Return a tuple containing the (start, end) positions of the match" msgstr "" +"Retorna una dupla que contiene (inicio, final) las posiciones de coincidencia" #: ../Doc/howto/regex.rst:430 msgid "Trying these methods will soon clarify their meaning::" -msgstr "" +msgstr "Probando estos métodos pronto aclarará sus significados::" #: ../Doc/howto/regex.rst:439 msgid "" @@ -763,6 +1035,14 @@ msgid "" "scans through the string, so the match may not start at zero in that " "case. ::" msgstr "" +":meth:`~re.Match.group` retorna la subcadena de caracteres que coincide con " +"el RE. :meth:`~re.Match.start` y :meth:`~ re.Match.end` retornan el índice " +"inicial y final de la coincidencia. :meth:`~re.Match.span` retorna los " +"índices inicial y final en una única tupla. Dado que el método :meth:`~re." +"Pattern.match` solo verifica si el RE coincide al comienzo de una cadena , :" +"meth:`!start` siempre será cero. Sin embargo, el método de patrones :meth:" +"`~re.Pattern.search` escanea a través de la cadena de caracteres, por lo que " +"es posible que la coincidencia no comience en cero en ese caso. ::" #: ../Doc/howto/regex.rst:456 msgid "" @@ -770,12 +1050,17 @@ msgid "" "` in a variable, and then check if it was ``None``. This " "usually looks like::" msgstr "" +"En programas reales, el estilo más común es almacenar :ref:`match object " +"` en una variable, y luego verificar si era ``None``. Esto " +"generalmente se ve así::" #: ../Doc/howto/regex.rst:467 msgid "" "Two pattern methods return all of the matches for a pattern. :meth:`~re." "Pattern.findall` returns a list of matching strings::" msgstr "" +"Dos métodos de patrón retornan todas las coincidencias de un patrón. :meth:" +"`~re.Pattern.findall` retorna una lista de cadenas coincidentes::" #: ../Doc/howto/regex.rst:474 msgid "" @@ -785,6 +1070,12 @@ msgid "" "in a :exc:`DeprecationWarning` and will eventually become a :exc:" "`SyntaxError`. See :ref:`the-backslash-plague`." msgstr "" +"El prefijo ``r``, que convierte al literal en un literal de cadena sin " +"formato, es necesario en este ejemplo porque las secuencias de escape en un " +"literal de cadena “cocinado” normal que no son reconocidas por Python, a " +"diferencia de las expresiones regulares, ahora dan como resultado :exc:" +"`DeprecationWarning` y eventualmente se convertirá en :exc:`SyntaxError`. " +"Ver :ref:`the-backslash-plague`." #: ../Doc/howto/regex.rst:480 msgid "" @@ -793,10 +1084,14 @@ msgid "" "sequence of :ref:`match object ` instances as an :term:" "`iterator`::" msgstr "" +":meth:`~re.Pattern.findall` tiene que crear la lista completa antes de que " +"pueda devolverse como resultado. El método :meth:`~re.Pattern.finditer` " +"retorna una secuencia de :ref:`match object ` instancias como " +"iterados :term:`iterator`::" #: ../Doc/howto/regex.rst:496 msgid "Module-Level Functions" -msgstr "" +msgstr "Funciones a nivel de módulo" #: ../Doc/howto/regex.rst:498 msgid "" @@ -807,14 +1102,26 @@ msgid "" "with the RE string added as the first argument, and still return either " "``None`` or a :ref:`match object ` instance. ::" msgstr "" +"No es necesario crear un objeto patrón y llamar a sus métodos; el módulo :" +"mod:`re` también proporciona funciones de nivel superior llamadas :func:`~ " +"re.match` , :func:`~re.search` , :func:`~re.findall` , :func:`~re.sub`, y " +"así sucesivamente. Estas funciones toman los mismos argumentos que el método " +"de patrón correspondiente con la cadena RE agregada como primer argumento, y " +"aún así devuelven una instancia de ``None`` o :ref:`match object `. ::" #: ../Doc/howto/regex.rst:510 +#, fuzzy msgid "" "Under the hood, these functions simply create a pattern object for you and " "call the appropriate method on it. They also store the compiled object in a " "cache, so future calls using the same RE won't need to parse the pattern " "again and again." msgstr "" +"Bajo el capó, estas funciones simplemente crean un objeto patrón para usted " +"y llaman al método apropiado en él. También almacenan el objeto compilado en " +"una caché, por lo que las futuras llamadas que usen el mismo RE no " +"necesitarán analizar el patrón una y otra vez." #: ../Doc/howto/regex.rst:515 msgid "" @@ -823,10 +1130,15 @@ msgid "" "pre-compiling it will save a few function calls. Outside of loops, there's " "not much difference thanks to the internal cache." msgstr "" +"¿Debería utilizar estas funciones a nivel de módulo o debería obtener el " +"patrón y llamar a sus métodos usted mismo? Si está accediendo a una " +"expresión regular dentro de un bucle, la compilación previa guardará algunas " +"llamadas a funciones. Fuera de los bucles, no hay mucha diferencia gracias " +"al caché interno." #: ../Doc/howto/regex.rst:523 msgid "Compilation Flags" -msgstr "" +msgstr "Los Flags de compilación" #: ../Doc/howto/regex.rst:525 msgid "" @@ -839,71 +1151,87 @@ msgid "" "them; ``re.I | re.M`` sets both the :const:`I` and :const:`M` flags, for " "example." msgstr "" +"Lo flags de compilación le permiten modificar algunos aspectos de cómo " +"funcionan las expresiones regulares. Las banderas están disponibles en el " +"módulo :mod:`re` con dos nombres, un nombre largo como :const:`IGNORECASE` y " +"una forma corta de una letra como :const:`I`. (Si está familiarizado con los " +"modificadores de patrones de Perl, las formas de una letra usan las mismas " +"letras; la forma corta de :const:`re.VERBOSE` es :const:`re.X`, por " +"ejemplo). \n" +"Se pueden especificar varios indicadores colocándolos en *OR-ing* bit a bit; " +"``re.I | re.M`` establece los flags :const:`I` and :const:`M`, por ejemplo." #: ../Doc/howto/regex.rst:533 msgid "" "Here's a table of the available flags, followed by a more detailed " "explanation of each one." msgstr "" +"Aquí hay una tabla de las banderas disponibles, seguida de una explicación " +"más detallada de cada una." #: ../Doc/howto/regex.rst:537 msgid "Flag" -msgstr "" +msgstr "Flag" #: ../Doc/howto/regex.rst:537 msgid "Meaning" -msgstr "" +msgstr "Significado" #: ../Doc/howto/regex.rst:539 msgid ":const:`ASCII`, :const:`A`" -msgstr "" +msgstr ":const:`ASCII`, :const:`A`" #: ../Doc/howto/regex.rst:539 msgid "" "Makes several escapes like ``\\w``, ``\\b``, ``\\s`` and ``\\d`` match only " "on ASCII characters with the respective property." msgstr "" +"Hace que varios escapes como ``\\w``, ``\\b``, ``\\s`` y ``\\d`` coincidan " +"solo en caracteres ASCII con la propiedad respectiva." #: ../Doc/howto/regex.rst:543 msgid ":const:`DOTALL`, :const:`S`" -msgstr "" +msgstr ":const:`DOTALL`, :const:`S`" #: ../Doc/howto/regex.rst:543 msgid "Make ``.`` match any character, including newlines." msgstr "" +"Hace que ``.`` Coincida con cualquier caracter, incluidas las nuevas líneas." #: ../Doc/howto/regex.rst:546 msgid ":const:`IGNORECASE`, :const:`I`" -msgstr "" +msgstr ":const:`IGNORECASE`, :const:`I`" #: ../Doc/howto/regex.rst:546 msgid "Do case-insensitive matches." -msgstr "" +msgstr "Hace coincidencias que no distingan entre mayúsculas y minúsculas." #: ../Doc/howto/regex.rst:548 msgid ":const:`LOCALE`, :const:`L`" -msgstr "" +msgstr ":const:`LOCALE`, :const:`L`" #: ../Doc/howto/regex.rst:548 msgid "Do a locale-aware match." -msgstr "" +msgstr "Hace una coincidencia con reconocimiento de configuración regional." #: ../Doc/howto/regex.rst:550 msgid ":const:`MULTILINE`, :const:`M`" -msgstr "" +msgstr ":const:`MULTILINE`, :const:`M`" #: ../Doc/howto/regex.rst:550 msgid "Multi-line matching, affecting ``^`` and ``$``." -msgstr "" +msgstr "Coincidencia de varias líneas, que afecta a ``^`` y ``$``." #: ../Doc/howto/regex.rst:553 msgid ":const:`VERBOSE`, :const:`X` (for 'extended')" -msgstr "" +msgstr ":const:`VERBOSE`, :const:`X` (for ‘extended’)m" #: ../Doc/howto/regex.rst:553 msgid "" "Enable verbose REs, which can be organized more cleanly and understandably." msgstr "" +"Habilite RE detallados, que se pueden organizar de manera más limpia y " +"comprensible." #: ../Doc/howto/regex.rst:562 msgid "" @@ -914,18 +1242,35 @@ msgid "" "z]`` or ``[A-Z]`` are used in combination with the :const:`IGNORECASE` flag, " "they will match the 52 ASCII letters and 4 additional non-ASCII letters: " "'İ' (U+0130, Latin capital letter I with dot above), 'ı' (U+0131, Latin " -"small letter dotless i), 'ſ' (U+017F, Latin small letter long s) and 'K' (U" +"small letter dotless i), 'ſ' (U+017F, Latin small letter long s) and 'K' (U" "+212A, Kelvin sign). ``Spam`` will match ``'Spam'``, ``'spam'``, " "``'spAM'``, or ``'ſpam'`` (the latter is matched only in Unicode mode). This " "lowercasing doesn't take the current locale into account; it will if you " "also set the :const:`LOCALE` flag." msgstr "" +"Realiza una coincidencia que no distinga entre mayúsculas y minúsculas; la " +"clase de caracteres y las cadenas de caracteres literales coincidirán con " +"las letras ignorando el caso. Por ejemplo, ``[A-Z]`` también coincidirá con " +"letras minúsculas. La coincidencia completa de Unicode también funciona a " +"menos que se utilice la flag :const:`ASCII` para deshabilitar las " +"coincidencias que no sean ASCII. Cuando los patrones Unicode ``[a-z]`` o " +"``[A-Z]`` se utilizan 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 un punto arriba), ‘ı’ (U+0131, letra " +"minúscula latina sin punto i),’ſ’ (U+017F, letra minúscula latina larga s) y " +"‘K’ (U+212A, signo de *Kelvin*). ``Spam`` coincidirá ``’Spam’``, ``’spam’``, " +"``’spAM’``, o ``’ſpam’`` (este último solo coincide en modo Unicode). Esta " +"minúscula no tiene en cuenta la configuración regional actual; lo hará si " +"también establece la flag :const:`LOCALE`." #: ../Doc/howto/regex.rst:580 msgid "" "Make ``\\w``, ``\\W``, ``\\b``, ``\\B`` and case-insensitive matching " "dependent on the current locale instead of the Unicode database." msgstr "" +"Hace que ``\\w``, ``\\W``, ``\\b``, ``\\B`` y la coincidencia que no " +"distinga entre mayúsculas y minúsculas dependan de la configuración regional " +"actual en lugar de la base de datos Unicode." #: ../Doc/howto/regex.rst:583 msgid "" @@ -945,12 +1290,32 @@ msgid "" "matching is already enabled by default in Python 3 for Unicode (str) " "patterns, and it is able to handle different locales/languages." msgstr "" +"Las configuraciones regionales son una característica de la biblioteca C " +"destinada a ayudar a escribir programas que tengan en cuenta las diferencias " +"de idioma. Por ejemplo, si está procesando texto en francés codificado, " +"querrá poder escribir ``\\w+`` para que coincida con las palabras, pero ``" +"\\w`` solo coincide con la clase de caracteres ``[A-Za-z]`` en patrones de " +"bytes; no coincidirá con los bytes correspondientes a ``é`` or ``ç``. Si su " +"sistema está configurado correctamente y se selecciona una configuración " +"regional francesa, ciertas funciones de C le dirán al programa que el byte " +"correspondiente a ``é`` también debe considerarse una letra. Establecer el " +"indicador :const:`LOCALE` al compilar una expresión regular hará que el " +"objeto compilado resultante use estas funciones C para ``\\w``; esto es más " +"lento, pero también permite que ``\\w+`` coincida con las palabras en " +"francés como era de esperar. Se desaconseja el uso de esta bandera en Python " +"3 ya que el mecanismo de configuración regional es muy poco confiable, solo " +"maneja una “cultura” a la vez y solo funciona con configuraciones regionales " +"de 8 bits. La coincidencia Unicode ya está habilitada de forma " +"predeterminada en Python 3 para patrones Unicode (str), y puede manejar " +"diferentes configuraciones regionales/idiomas." #: ../Doc/howto/regex.rst:605 msgid "" "(``^`` and ``$`` haven't been explained yet; they'll be introduced in " "section :ref:`more-metacharacters`.)" msgstr "" +"(``^`` y ``$`` aún no se han explicado; se presentarán en la sección :ref:" +"`more-metacharacters`.)" #: ../Doc/howto/regex.rst:608 msgid "" @@ -962,12 +1327,23 @@ msgid "" "matches either at the end of the string and at the end of each line " "(immediately preceding each newline)." msgstr "" +"Por lo general, ``^`` coincide solo al principio de la cadena, y ``$`` solo " +"coincide con el final de la cadena de caracteres e inmediatamente antes del " +"salto de línea (si existe) al final de la cadena de caracteres. Cuando se " +"especifica esta bandera, ``^`` coincide al principio de la cadena y al " +"comienzo de cada línea dentro de la cadena, inmediatamente después de cada " +"nueva línea. De manera similar, el metacaracter ``$`` coincide al final de " +"la cadena de caracteres y al final de cada línea (inmediatamente antes de " +"cada nueva línea)." #: ../Doc/howto/regex.rst:621 msgid "" "Makes the ``'.'`` special character match any character at all, including a " "newline; without this flag, ``'.'`` will match anything *except* a newline." msgstr "" +"Hace que el caracter especial ``'.'`` coincida con cualquier carácter, " +"incluida una nueva línea; sin esta bandera, ``'.'`` coincidirá con cualquier " +"cosa *excepto* una nueva línea." #: ../Doc/howto/regex.rst:629 msgid "" @@ -975,6 +1351,10 @@ msgid "" "only matching instead of full Unicode matching. This is only meaningful for " "Unicode patterns, and is ignored for byte patterns." msgstr "" +"Haga que ``\\w``, ``\\W``, ``\\b``, ``\\B``, ``\\s`` y ``\\S`` realicen una " +"coincidencia solo en ASCII en lugar de una coincidencia Unicode completa. " +"Esto solo es significativo para los patrones Unicode y se ignora para los " +"patrones de bytes." #: ../Doc/howto/regex.rst:638 msgid "" @@ -987,16 +1367,28 @@ msgid "" "comments are marked by a ``'#'`` that's neither in a character class or " "preceded by an unescaped backslash." msgstr "" +"Esta flag le permite escribir expresiones regulares que son más legibles al " +"otorgarle más flexibilidad en cómo puede formatearlas. Cuando se ha " +"especificado esta flag, los espacios en blanco dentro de la cadena de " +"caracteres de la RE se ignoran, excepto cuando el espacio en blanco está en " +"una clase de caracteres o está precedido por una barra invertida sin escape; " +"esto le permite organizar e indentar la RE más claramente. Esta flag también " +"le permite poner comentarios dentro de una RE que serán ignorados por el " +"motor (*engine*); los comentarios están marcados con un ``’#’`` que no está " +"en una clase de carácter ni está precedido por una barra invertida sin " +"escape." #: ../Doc/howto/regex.rst:647 msgid "" "For example, here's a RE that uses :const:`re.VERBOSE`; see how much easier " "it is to read? ::" msgstr "" +"Por ejemplo, aquí hay una RE que usa :const:`re.VERBOSE`; ¿Ves lo fácil que " +"es leer? ::" #: ../Doc/howto/regex.rst:660 msgid "Without the verbose setting, the RE would look like this::" -msgstr "" +msgstr "Sin la configuración detallada, el RE se vería así::" #: ../Doc/howto/regex.rst:666 msgid "" @@ -1004,10 +1396,13 @@ msgid "" "has been used to break up the RE into smaller pieces, but it's still more " "difficult to understand than the version using :const:`re.VERBOSE`." msgstr "" +"En el ejemplo anterior, la concatenación automática de cadenas literales de " +"Python se ha utilizado para dividir el RE en partes más pequeñas, pero aún " +"es más difícil de entender que la versión que usa :const:`re.VERBOSE`." #: ../Doc/howto/regex.rst:672 msgid "More Pattern Power" -msgstr "" +msgstr "Más poder de coincidencia" #: ../Doc/howto/regex.rst:674 msgid "" @@ -1015,16 +1410,21 @@ msgid "" "this section, we'll cover some new metacharacters, and how to use groups to " "retrieve portions of the text that was matched." msgstr "" +"Hasta ahora solo hemos cubierto una parte de las características de las " +"expresiones regulares. En esta sección, cubriremos algunos metacaracteres " +"nuevos y cómo usar grupos para recuperar partes del texto que coincidió." #: ../Doc/howto/regex.rst:682 msgid "More Metacharacters" -msgstr "" +msgstr "Más metacaracteres" #: ../Doc/howto/regex.rst:684 msgid "" "There are some metacharacters that we haven't covered yet. Most of them " "will be covered in this section." msgstr "" +"Hay algunos metacaracteres que aún no hemos cubierto. La mayoría de ellos se " +"tratarán en esta sección." #: ../Doc/howto/regex.rst:687 msgid "" @@ -1037,10 +1437,18 @@ msgid "" "once at a given location, they can obviously be matched an infinite number " "of times." msgstr "" +"Algunos de los metacaracteres restantes que se discutirán son :dfn:`zero-" +"width assertions`. No hacen que el motor avance a través de la cuerda; en " +"cambio, no consumen caracteres en absoluto y simplemente tienen éxito o " +"fracasan. Por ejemplo, ``\\b`` es una afirmación de que la posición actual " +"se encuentra en el límite de una palabra; la posición no cambia por la ``" +"\\b`` en absoluto. Esto significa que las aserciones de ancho cero nunca " +"deben repetirse, porque si coinciden una vez en una ubicación determinada, " +"obviamente pueden coincidir un número infinito de veces." #: ../Doc/howto/regex.rst:703 msgid "``|``" -msgstr "" +msgstr "``|``" #: ../Doc/howto/regex.rst:696 msgid "" @@ -1051,16 +1459,24 @@ msgid "" "``'Crow'`` or ``'Servo'``, not ``'Cro'``, a ``'w'`` or an ``'S'``, and " "``'ervo'``." msgstr "" +"Alternancia, o el operador “or”. Si *A* y *B* son expresiones regulares, ``A|" +"B`` coincidirá con cualquier cadena de caracteres que coincida con *A* o " +"*B*. ``|`` tiene una precedencia muy baja para que funcione razonablemente " +"cuando está alternando cadenas de varios caracteres. ``Crow|Servo`` " +"coincidirá con `’Crow’`` o ``’Servo’``, no ``’Cro’``, un ``’w’`` o un " +"``’S’``, y ``’ervo’``." #: ../Doc/howto/regex.rst:702 msgid "" "To match a literal ``'|'``, use ``\\|``, or enclose it inside a character " "class, as in ``[|]``." msgstr "" +"Para hacer coincidir un literal `` '|' ``, use `` \\|``, o enciérrelo dentro " +"de una clase de carácter, como en ``[|]``." #: ../Doc/howto/regex.rst:718 msgid "``^``" -msgstr "" +msgstr "``^``" #: ../Doc/howto/regex.rst:706 msgid "" @@ -1069,36 +1485,46 @@ msgid "" "`MULTILINE` mode, this also matches immediately after each newline within " "the string." msgstr "" +"Coincide con el comienzo de las líneas. A menos que se haya establecido la " +"flag :const:`MULTILINE`, esto solo coincidirá al principio de la cadena de " +"caracteres. En modo :const:`MULTILINE`, esto también coincide inmediatamente " +"después de cada nueva línea dentro de la cadena." #: ../Doc/howto/regex.rst:710 msgid "" "For example, if you wish to match the word ``From`` only at the beginning of " "a line, the RE to use is ``^From``. ::" msgstr "" +"Por ejemplo, si desea hacer coincidir la palabra ``From`` solo al principio " +"de una línea, la RE que debe usar es ``^From``. ::" #: ../Doc/howto/regex.rst:718 msgid "To match a literal ``'^'``, use ``\\^``." -msgstr "" +msgstr "Para una coincidencia literal ``’^’``, usar ``\\^``." #: ../Doc/howto/regex.rst:732 msgid "``$``" -msgstr "" +msgstr "``$``" #: ../Doc/howto/regex.rst:721 msgid "" "Matches at the end of a line, which is defined as either the end of the " "string, or any location followed by a newline character. ::" msgstr "" +"Coincide con el final de una línea, que se define como el final de la cadena " +"o cualquier ubicación seguida de un carácter de nueva línea. ::" #: ../Doc/howto/regex.rst:731 msgid "" "To match a literal ``'$'``, use ``\\$`` or enclose it inside a character " "class, as in ``[$]``." msgstr "" +"Para hacer coincidir un literal ``’$’``, usar ``\\$`` o enciérrelo dentro de " +"una clase de carácter, como en ``[$]``." #: ../Doc/howto/regex.rst:738 msgid "``\\A``" -msgstr "" +msgstr "``\\A``" #: ../Doc/howto/regex.rst:735 msgid "" @@ -1108,18 +1534,23 @@ msgid "" "string, but ``^`` may match at any location inside the string that follows a " "newline character." msgstr "" +"Coincide solo al comienzo de la cadena de caracteres. Cuando no está en el " +"modo :const:`MULTILINE`,``\\A`` y ``^``son efectivamente lo mismo. En el " +"modo :const:`MULTILINE`, son diferentes: ``\\ A`` todavía coincide solo al " +"principio de la cadena, pero``^``puede coincidir en cualquier ubicación " +"dentro de la cadena de caracteres que sigue a un carácter de nueva línea." #: ../Doc/howto/regex.rst:741 msgid "``\\Z``" -msgstr "" +msgstr "``\\Z``" #: ../Doc/howto/regex.rst:741 msgid "Matches only at the end of the string." -msgstr "" +msgstr "Coincidencias solo al final de la cadena de caracteres." #: ../Doc/howto/regex.rst:776 msgid "``\\b``" -msgstr "" +msgstr "``\\b``" #: ../Doc/howto/regex.rst:744 msgid "" @@ -1128,14 +1559,21 @@ msgid "" "characters, so the end of a word is indicated by whitespace or a non-" "alphanumeric character." msgstr "" +"Límite de palabra. Esta es una aserción de ancho cero que coincide solo al " +"principio o al final de una palabra. Una palabra se define como una " +"secuencia de caracteres alfanuméricos, por lo que el final de una palabra se " +"indica mediante un espacio en blanco o un carácter no alfanumérico." #: ../Doc/howto/regex.rst:749 msgid "" "The following example matches ``class`` only when it's a complete word; it " "won't match when it's contained inside another word. ::" msgstr "" +"El siguiente ejemplo coincide con ``class`` solo cuando es una palabra " +"completa; no coincidirá cuando esté contenido dentro de otra palabra. ::" #: ../Doc/howto/regex.rst:760 +#, fuzzy msgid "" "There are two subtleties you should remember when using this special " "sequence. First, this is the worst collision between Python's string " @@ -1145,6 +1583,15 @@ msgid "" "won't match as you expect it to. The following example looks the same as our " "previous RE, but omits the ``'r'`` in front of the RE string. ::" msgstr "" +"Hay dos sutilezas que debe recordar al usar esta secuencia especial. " +"Primero, esta es la peor colisión entre las cadenas literales de caracteres " +"de Python y las secuencias de expresiones regulares. En las cadenas de " +"caracteres literales de Python, ``\\b`` es el carácter de retroceso " +"(*backspace*), valor ASCII 8. Si no está utilizando cadenas de caracteres " +"sin procesar, Python convertirá la ``\\b`` en un retroceso, y su RE no lo " +"hará coincidir como lo espera. El siguiente ejemplo tiene el mismo aspecto " +"que nuestra RE anterior, pero omite la ``’r’`` delante de la cadena de " +"caracteres de RE. ::" #: ../Doc/howto/regex.rst:774 msgid "" @@ -1152,20 +1599,25 @@ msgid "" "\\b`` represents the backspace character, for compatibility with Python's " "string literals." msgstr "" +"En segundo lugar, dentro de una clase de caracteres, donde no hay uso para " +"esta aserción, ``\\b`` representa el carácter de retroceso, por " +"compatibilidad con las cadenas de caracteres literales de Python." #: ../Doc/howto/regex.rst:781 msgid "``\\B``" -msgstr "" +msgstr "``\\B``" #: ../Doc/howto/regex.rst:779 msgid "" "Another zero-width assertion, this is the opposite of ``\\b``, only matching " "when the current position is not at a word boundary." msgstr "" +"Otra afirmación de ancho cero, esto es lo opuesto a ``\\b``, solo coincide " +"cuando la posición actual no está en el límite de una palabra." #: ../Doc/howto/regex.rst:784 msgid "Grouping" -msgstr "" +msgstr "Agrupando" #: ../Doc/howto/regex.rst:786 msgid "" @@ -1175,6 +1627,12 @@ msgid "" "of interest. For example, an RFC-822 header line is divided into a header " "name and a value, separated by a ``':'``, like this:" msgstr "" +"Con frecuencia, necesita obtener más información que solo si la RE coincide " +"o no. Las expresiones regulares se utilizan a menudo para diseccionar " +"cadenas de caracteres escribiendo una RE dividido en varios subgrupos que " +"coinciden con diferentes componentes de interés. Por ejemplo, una línea de " +"encabezado RFC-822 se divide en un nombre de encabezado y un valor, " +"separados por un ``’:’``, así:" #: ../Doc/howto/regex.rst:799 msgid "" @@ -1182,6 +1640,9 @@ msgid "" "header line, and has one group which matches the header name, and another " "group which matches the header's value." msgstr "" +"Esto se puede manejar escribiendo una expresión regular que coincida con una " +"línea de encabezado completa y que tenga un grupo que coincida con el nombre " +"del encabezado y otro grupo que coincida con el valor del encabezado." #: ../Doc/howto/regex.rst:803 msgid "" @@ -1192,6 +1653,12 @@ msgid "" "+``, ``?``, or ``{m,n}``. For example, ``(ab)*`` will match zero or more " "repetitions of ``ab``. ::" msgstr "" +"Los grupos están marcados por los ``’(‘``, ``’)’`` metacaracteres. ``’(‘`` y " +"``’)’`` tienen el mismo significado que en las expresiones matemáticas; " +"agrupan las expresiones contenidas en ellos, y puedes repetir el contenido " +"de un grupo con un calificador repetitivo, como ``*``, ``+``, ``?``, o ``{m," +"n}``. Por ejemplo, ``(ab)*`` coincidirá con cero o más repeticiones de " +"``ab``. ::" #: ../Doc/howto/regex.rst:814 msgid "" @@ -1204,6 +1671,14 @@ msgid "" "we'll see how to express groups that don't capture the span of text that " "they match. ::" msgstr "" +"Los grupos indicados con ``'('``, ``')'`` también capturan el índice inicial " +"y final del texto que coinciden; esto se puede recuperar pasando un " +"argumento a :meth:`~re.Match.group`, :meth:`~re.Match.start`, :meth:`~re." +"Match.end`, y :meth:`~re.Match.span`. Los grupos se numeran empezando por 0. " +"El grupo 0 siempre está presente; es todo las RE, entonces todos los " +"métodos :ref:`match object ` tienen el grupo 0 como argumento " +"predeterminado. Más adelante veremos cómo expresar grupos que no capturan el " +"espacio de texto que coinciden. ::" #: ../Doc/howto/regex.rst:830 msgid "" @@ -1211,6 +1686,9 @@ msgid "" "nested; to determine the number, just count the opening parenthesis " "characters, going from left to right. ::" msgstr "" +"Los subgrupos están numerados de izquierda a derecha, de 1 en adelante. Los " +"grupos se pueden anidar; para determinar el número, simplemente cuente los " +"caracteres del paréntesis de apertura, de izquierda a derecha. ::" #: ../Doc/howto/regex.rst:843 msgid "" @@ -1218,12 +1696,17 @@ msgid "" "which case it will return a tuple containing the corresponding values for " "those groups. ::" msgstr "" +":meth:`~re.Match.group` se pueden pasar varios números de grupo a la vez, en " +"cuyo caso devolverá una tupla que contiene los valores correspondientes para " +"esos grupos. ::" #: ../Doc/howto/regex.rst:849 msgid "" "The :meth:`~re.Match.groups` method returns a tuple containing the strings " "for all the subgroups, from 1 up to however many there are. ::" msgstr "" +"El método :meth:`~ re.Match.groups` retorna una tupla que contiene las " +"cadenas de todos los subgrupos, desde 1 hasta la cantidad que haya. ::" #: ../Doc/howto/regex.rst:855 msgid "" @@ -1235,10 +1718,20 @@ msgid "" "including arbitrary characters in a string, so be sure to use a raw string " "when incorporating backreferences in a RE." msgstr "" +"Las referencias inversas en un patrón le permiten especificar que el " +"contenido de un grupo de captura anterior también debe encontrarse en la " +"ubicación actual en la cadena. Por ejemplo,``\\1`` tendrá éxito si el " +"contenido exacto del grupo 1 se puede encontrar en la posición actual y " +"falla en caso contrario. Recuerde que las cadenas de caracteres literales de " +"Python también usan una barra invertida seguida de números para permitir la " +"inclusión de caracteres arbitrarios en una cadena de caracteres, así que " +"asegúrese de usar una cadena de caracteres sin procesar al incorporar " +"referencias inversas en una RE." #: ../Doc/howto/regex.rst:863 msgid "For example, the following RE detects doubled words in a string. ::" msgstr "" +"Por ejemplo, la siguiente RE detecta palabras duplicadas en una cadena. ::" #: ../Doc/howto/regex.rst:869 msgid "" @@ -1247,10 +1740,14 @@ msgid "" "you'll soon find out that they're *very* useful when performing string " "substitutions." msgstr "" +"Las referencias inversas como esta no suelen ser útiles para buscar a través " +"de una cadena --- hay pocos formatos de texto que repiten datos de esta " +"manera --- pero pronto descubrirá que son *muy* útiles al realizar " +"sustituciones de cadenas ." #: ../Doc/howto/regex.rst:875 msgid "Non-capturing and Named Groups" -msgstr "" +msgstr "Grupos con nombre y sin captura" #: ../Doc/howto/regex.rst:877 msgid "" @@ -1260,6 +1757,12 @@ msgid "" "help with this problem. Both of them use a common syntax for regular " "expression extensions, so we'll look at that first." msgstr "" +"Las RE elaboradas pueden utilizar muchos grupos, tanto para capturar " +"subcadenas de caracteres de interés como para agrupar y estructurar la " +"propia RE. En las RE complejas, resulta difícil realizar un seguimiento de " +"los números de los grupos. Hay dos funciones que ayudan con este problema. " +"Ambos usan una sintaxis común para las extensiones de expresiones regulares, " +"así que veremos eso primero." #: ../Doc/howto/regex.rst:883 msgid "" @@ -1271,6 +1774,14 @@ msgid "" "expressions would be assuming that ``&`` was a regular character and " "wouldn't have escaped it by writing ``\\&`` or ``[&]``." msgstr "" +"Perl 5 es bien conocido por sus poderosas adiciones a las expresiones " +"regulares estándar. Para estas nuevas características, los desarrolladores " +"de Perl no podían elegir nuevos metacaracteres de una sola pulsación de " +"tecla o nuevas secuencias especiales que comienzan con ``\\`` sin hacer que " +"las expresiones regulares de Perl sean confusamente diferentes de las RE " +"estándar. Si eligieran ``&`` como un nuevo metacarácter, por ejemplo, las " +"expresiones antiguas supondrían que ``&`` era un carácter regular y no se " +"habría escapado escribiendo ``\\&`` o ``[&]``." #: ../Doc/howto/regex.rst:890 msgid "" @@ -1282,6 +1793,14 @@ msgid "" "positive lookahead assertion) and ``(?:foo)`` is something else (a non-" "capturing group containing the subexpression ``foo``)." msgstr "" +"La solución elegida por los desarrolladores de Perl fue utilizar ``(?...)`` " +"como sintaxis de extensión. ``?`` inmediatamente después de un paréntesis " +"había un error de sintaxis porque el ``?`` no tendría nada que repetir, por " +"lo que esto no introdujo ningún problema de compatibilidad. Los caracteres " +"inmediatamente después de ``?`` Indican qué extensión se está utilizando, " +"por lo que ``(?=foo)`` es una cosa (una afirmación de anticipación positiva) " +"y ``(?:foo)`` es otra cosa (un grupo de no captura que contiene la " +"subexpresión ``foo``)." #: ../Doc/howto/regex.rst:898 msgid "" @@ -1289,12 +1808,18 @@ msgid "" "Perl's extension syntax. If the first character after the question mark is " "a ``P``, you know that it's an extension that's specific to Python." msgstr "" +"Python admite varias de las extensiones de Perl y agrega una sintaxis de " +"extensión a la sintaxis de extensión de Perl. Si el primer carácter después " +"del signo de interrogación es una ``P``, sabrá que es una extensión " +"específica de Python." #: ../Doc/howto/regex.rst:903 msgid "" "Now that we've looked at the general extension syntax, we can return to the " "features that simplify working with groups in complex REs." msgstr "" +"Ahora que hemos visto la sintaxis de la extensión general, podemos volver a " +"las características que simplifican el trabajo con grupos en RE complejos." #: ../Doc/howto/regex.rst:906 msgid "" @@ -1303,6 +1828,11 @@ msgid "" "can make this fact explicit by using a non-capturing group: ``(?:...)``, " "where you can replace the ``...`` with any other regular expression. ::" msgstr "" +"A veces querrá usar un grupo para denotar una parte de una expresión " +"regular, pero no está interesado en recuperar el contenido del grupo. Puede " +"hacer que este hecho sea explícito utilizando un grupo de no captura: " +"``(?:...)``, donde puede reemplazar el ``...`` con cualquier otra expresión " +"regular. ::" #: ../Doc/howto/regex.rst:918 msgid "" @@ -1316,12 +1846,24 @@ msgid "" "performance difference in searching between capturing and non-capturing " "groups; neither form is any faster than the other." msgstr "" +"Excepto por el hecho de que no puede recuperar el contenido de lo que " +"coincide con el grupo, un grupo que no captura se comporta exactamente igual " +"que un grupo que captura; puede poner cualquier cosa dentro de él, repetirlo " +"con un metacarácter de repetición como ``*`` y anidarlo dentro de otros " +"grupos (capturando o no capturando). ``(?:...)`` es particularmente útil " +"cuando se modifica un patrón existente, ya que puede agregar nuevos grupos " +"sin cambiar cómo se numeran todos los demás grupos. Cabe mencionar que no " +"hay diferencia de rendimiento en la búsqueda entre grupos de captura y no " +"captura; ninguna forma es más rápida que la otra." #: ../Doc/howto/regex.rst:927 msgid "" "A more significant feature is named groups: instead of referring to them by " "numbers, groups can be referenced by a name." msgstr "" +"Una característica más significativa son los grupos nombrados: en lugar de " +"referirse a ellos por números, los grupos pueden ser referenciados por un " +"nombre." #: ../Doc/howto/regex.rst:930 msgid "" @@ -1334,12 +1876,22 @@ msgid "" "still given numbers, so you can retrieve information about a group in two " "ways::" msgstr "" +"La sintaxis de un grupo con nombre es una de las extensiones específicas de " +"Python: ``(?P...)``. *name* es, obviamente, el nombre del grupo. Los " +"grupos con nombre se comportan exactamente como los grupos de captura y, " +"además, asocian un nombre con un grupo. Los métodos :ref:`match object " +"` que tratan con la captura de grupos aceptan enteros que se " +"refieren al grupo por número o cadenas de caracteres que contienen el nombre " +"del grupo deseado. Los grupos con nombre todavía reciben números, por lo que " +"puede recuperar información sobre un grupo de dos maneras:" #: ../Doc/howto/regex.rst:945 msgid "" "Additionally, you can retrieve named groups as a dictionary with :meth:`~re." "Match.groupdict`::" msgstr "" +"Además, puede recuperar grupos nombrados como un diccionario con :meth:`~re." +"Match.groupdict`::" #: ../Doc/howto/regex.rst:952 msgid "" @@ -1347,12 +1899,17 @@ msgid "" "instead of having to remember numbers. Here's an example RE from the :mod:" "`imaplib` module::" msgstr "" +"Los grupos con nombre son útiles porque le permiten usar nombres fáciles de " +"recordar, en lugar de tener que recordar números. Aquí hay un ejemplo de RE " +"del módulo :mod:`imaplib`::" #: ../Doc/howto/regex.rst:963 msgid "" "It's obviously much easier to retrieve ``m.group('zonem')``, instead of " "having to remember to retrieve group 9." msgstr "" +"Obviamente, es mucho más fácil recuperar ``m.group(‘zonem’)``, en lugar de " +"tener que recordar recuperar el grupo 9." #: ../Doc/howto/regex.rst:966 msgid "" @@ -1364,10 +1921,17 @@ msgid "" "words, ``\\b(\\w+)\\s+\\1\\b`` can also be written as ``\\b(?P\\w+)\\s" "+(?P=word)\\b``::" msgstr "" +"La sintaxis de las referencias inversas en una expresión como ``(...)\\1`` " +"se refiere al número del grupo. Naturalmente, existe una variante que usa el " +"nombre del grupo en lugar del número. Esta es otra extensión de Python: ``(?" +"P=name)`` indica que el contenido del grupo llamado *name* debe coincidir " +"nuevamente en el punto actual. La expresión regular para encontrar palabras " +"duplicadas, ``\\b(\\w+)\\s+\\1\\b`` también se puede escribir como ``\\b(?" +"P\\w+)\\s+(?P=word)\\b``::" #: ../Doc/howto/regex.rst:979 msgid "Lookahead Assertions" -msgstr "" +msgstr "Aserciones Anticipadas" #: ../Doc/howto/regex.rst:981 msgid "" @@ -1375,10 +1939,13 @@ msgid "" "assertions are available in both positive and negative form, and look like " "this:" msgstr "" +"Otra aserción de ancho cero es la aserción de anticipación. Las afirmaciones " +"anticipadas están disponibles tanto en forma positiva como negativa, y " +"tienen este aspecto:" #: ../Doc/howto/regex.rst:989 msgid "``(?=...)``" -msgstr "" +msgstr "``(?=…)``" #: ../Doc/howto/regex.rst:985 msgid "" @@ -1388,10 +1955,15 @@ msgid "" "tried, the matching engine doesn't advance at all; the rest of the pattern " "is tried right where the assertion started." msgstr "" +"Aserción de anticipación positiva. Esto tiene éxito si la expresión regular " +"contenida, representada aquí por ``…``, coincide con éxito en la ubicación " +"actual y falla en caso contrario. Pero, una vez que se ha probado la " +"expresión contenida, el motor de comparación no avanza en absoluto; el resto " +"del patrón se intenta justo donde comenzó la aserción." #: ../Doc/howto/regex.rst:994 msgid "``(?!...)``" -msgstr "" +msgstr "``(?!…)``" #: ../Doc/howto/regex.rst:992 msgid "" @@ -1399,6 +1971,9 @@ msgid "" "assertion; it succeeds if the contained expression *doesn't* match at the " "current position in the string." msgstr "" +"Aserción de anticipación negativa. Esto es lo opuesto a la afirmación " +"positiva; tiene éxito si la expresión contenida *no* coincide con la " +"posición actual en la cadena." #: ../Doc/howto/regex.rst:996 msgid "" @@ -1407,14 +1982,19 @@ msgid "" "name and an extension, separated by a ``.``. For example, in ``news.rc``, " "``news`` is the base name, and ``rc`` is the filename's extension." msgstr "" +"Para que esto sea concreto, veamos un caso en el que una búsqueda anticipada " +"es útil. Considere un patrón simple para hacer coincidir un nombre de " +"archivo y dividirlo en un nombre base y una extensión, separados por un ``." +"``. Por ejemplo, en ``news.rc``, ``news`` es el nombre base y ``rc`` es la " +"extensión del nombre del archivo." #: ../Doc/howto/regex.rst:1001 msgid "The pattern to match this is quite simple:" -msgstr "" +msgstr "El patrón para que coincida con esto es bastante simple:" #: ../Doc/howto/regex.rst:1003 msgid "``.*[.].*$``" -msgstr "" +msgstr "``.*[.].*$``" #: ../Doc/howto/regex.rst:1005 msgid "" @@ -1425,12 +2005,21 @@ msgid "" "expression matches ``foo.bar`` and ``autoexec.bat`` and ``sendmail.cf`` and " "``printers.conf``." msgstr "" +"Tenga en cuenta que el ``.`` Debe tratarse especialmente porque es un " +"metacaracter, por lo que está dentro de una clase de carácter para coincidir " +"solo con ese carácter específico. También observe el final ``$``; esto se " +"agrega para garantizar que todo el resto de la cadena deba incluirse en la " +"extensión. Esta expresión regular coincide con ``foo.bar`` y ``autoexec." +"bat`` y ``sendmail.cf`` y ``printers.conf``." #: ../Doc/howto/regex.rst:1012 msgid "" "Now, consider complicating the problem a bit; what if you want to match " "filenames where the extension is not ``bat``? Some incorrect attempts:" msgstr "" +"Ahora, considere complicar un poco el problema; ¿Qué sucede si desea hacer " +"coincidir los nombres de archivo donde la extensión no es ``bat``? Algunos " +"intentos incorrectos:" #: ../Doc/howto/regex.rst:1015 msgid "" @@ -1438,10 +2027,13 @@ msgid "" "requiring that the first character of the extension is not a ``b``. This is " "wrong, because the pattern also doesn't match ``foo.bar``." msgstr "" +"``.*[.][^b].*$`` El primer intento anterior intenta excluir ``bat`` " +"requiriendo que el primer carácter de la extensión no sea una ``b``. Esto " +"está mal, porque el patrón tampoco coincide ``foo.bar``." #: ../Doc/howto/regex.rst:1019 msgid "``.*[.]([^b]..|.[^a].|..[^t])$``" -msgstr "" +msgstr "``.*[.]([^b]..|.[^a].|..[^t])$``" #: ../Doc/howto/regex.rst:1021 msgid "" @@ -1453,10 +2045,17 @@ msgid "" "with a two-letter extension such as ``sendmail.cf``. We'll complicate the " "pattern again in an effort to fix it." msgstr "" +"La expresión se vuelve más desordenada cuando intenta parchear la primera " +"solución requiriendo que coincida uno de los siguientes casos: el primer " +"carácter de la extensión no es ``b``; el segundo carácter no es ``a``; o el " +"tercer carácter no es ``t``. Esto acepta ``foo.bar`` y rechaza ``autoexec." +"bat``, pero requiere una extensión de tres letras y no acepta un nombre de " +"archivo con una extensión de dos letras como ``sendmail.cf``. Complicaremos " +"el patrón nuevamente en un esfuerzo por arreglarlo." #: ../Doc/howto/regex.rst:1029 msgid "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``" -msgstr "" +msgstr "``.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$``" #: ../Doc/howto/regex.rst:1031 msgid "" @@ -1464,6 +2063,9 @@ msgid "" "order to allow matching extensions shorter than three characters, such as " "``sendmail.cf``." msgstr "" +"En el tercer intento, la segunda y tercera letras se hacen opcionales para " +"permitir extensiones coincidentes de menos de tres caracteres, como " +"``sendmail.cf``." #: ../Doc/howto/regex.rst:1035 msgid "" @@ -1472,10 +2074,14 @@ msgid "" "``bat`` and ``exe`` as extensions, the pattern would get even more " "complicated and confusing." msgstr "" +"El patrón se está volviendo realmente complicado ahora, lo que dificulta su " +"lectura y comprensión. Peor aún, si el problema cambia y desea excluir tanto " +"``bat`` y ``exe`` como extensiones, el patrón se volvería aún más complicado " +"y confuso." #: ../Doc/howto/regex.rst:1040 msgid "A negative lookahead cuts through all this confusion:" -msgstr "" +msgstr "Una mirada anticipada negativa atraviesa toda esta confusión:" #: ../Doc/howto/regex.rst:1042 msgid "" @@ -1486,6 +2092,12 @@ msgid "" "starts with ``bat``, will be allowed. The ``[^.]*`` makes sure that the " "pattern works when there are multiple dots in the filename." msgstr "" +"``.*[.](?!bat$)[^.]*$`` La búsqueda anticipada negativa significa: si la " +"expresión ``bat`` no coincide en este punto, pruebe el resto del patrón; si " +"``bat$`` coincide, todo el patrón fallará. El ``$`` final es necesario para " +"garantizar que se permita algo como ``sample.batch``, donde la extensión " +"solo comienza con ``bat``. El ``[^.]*`` asegura que el patrón funcione " +"cuando hay varios puntos en el nombre del archivo." #: ../Doc/howto/regex.rst:1049 msgid "" @@ -1493,14 +2105,17 @@ msgid "" "alternative inside the assertion. The following pattern excludes filenames " "that end in either ``bat`` or ``exe``:" msgstr "" +"Ahora es fácil excluir otra extensión de nombre de archivo; simplemente " +"agréguelo como una alternativa dentro de la aserción. El siguiente patrón " +"excluye los nombres de archivo que terminan en ``bat`` o ``exe``:" #: ../Doc/howto/regex.rst:1053 msgid "``.*[.](?!bat$|exe$)[^.]*$``" -msgstr "" +msgstr "``.*[.](?!bat$|exe$)[^.]*$``" #: ../Doc/howto/regex.rst:1057 msgid "Modifying Strings" -msgstr "" +msgstr "Modificando cadenas de caracteres" #: ../Doc/howto/regex.rst:1059 msgid "" @@ -1508,38 +2123,48 @@ msgid "" "Regular expressions are also commonly used to modify strings in various " "ways, using the following pattern methods:" msgstr "" +"Hasta este punto, simplemente hemos realizado búsquedas en una cadena de " +"caracteres estática. Las expresiones regulares también se utilizan " +"comúnmente para modificar cadenas de varias formas, utilizando los " +"siguientes métodos de patrón:" #: ../Doc/howto/regex.rst:1066 msgid "``split()``" -msgstr "" +msgstr "``split()`" #: ../Doc/howto/regex.rst:1066 msgid "Split the string into a list, splitting it wherever the RE matches" msgstr "" +"Divida la cadena de caracteres en una lista, dividiéndola donde coincida la " +"RE" #: ../Doc/howto/regex.rst:1069 msgid "``sub()``" -msgstr "" +msgstr "``sub()``" #: ../Doc/howto/regex.rst:1069 msgid "" "Find all substrings where the RE matches, and replace them with a different " "string" msgstr "" +"Encuentre todas las subcadenas de caracteres donde coincida la RE y " +"reemplácelas con una cadena de caracteres diferente" #: ../Doc/howto/regex.rst:1072 msgid "``subn()``" -msgstr "" +msgstr "``subn()``" #: ../Doc/howto/regex.rst:1072 msgid "" "Does the same thing as :meth:`!sub`, but returns the new string and the " "number of replacements" msgstr "" +"Hace lo mismo que :meth:`!sub`, pero retorna la nueva cadena de caracteres y " +"el número de reemplazos" #: ../Doc/howto/regex.rst:1079 msgid "Splitting Strings" -msgstr "" +msgstr "Separando cadenas de caracteres" #: ../Doc/howto/regex.rst:1081 msgid "" @@ -1550,6 +2175,13 @@ msgid "" "splitting by whitespace or by a fixed string. As you'd expect, there's a " "module-level :func:`re.split` function, too." msgstr "" +"El método :meth:`~re.Pattern.split` de un patrón divide una cadena donde la " +"RE coincide, devolviendo una lista de las piezas. Es similar al método de " +"cadenas de caracteres :meth:`~str.split` pero proporciona mucha más " +"generalidad en los delimitadores por los que puede dividir; cadena de " +"caracteres :meth:`!split` solo admite la división por espacios en blanco o " +"por una cadena fija. Como era de esperar, también hay una función a nivel de " +"módulo :func:`re.split`." #: ../Doc/howto/regex.rst:1092 msgid "" @@ -1558,6 +2190,10 @@ msgid "" "part of the resulting list. If *maxsplit* is nonzero, at most *maxsplit* " "splits are performed." msgstr "" +"Dividir *string* por las coincidencias de la expresión regular. Si se " +"utilizan paréntesis de captura en la RE, su contenido también se devolverá " +"como parte de la lista resultante. Si *maxsplit* es distinto de cero, se " +"realizan como máximo *maxsplit* splits." #: ../Doc/howto/regex.rst:1097 msgid "" @@ -1567,6 +2203,11 @@ msgid "" "the following example, the delimiter is any sequence of non-alphanumeric " "characters. ::" msgstr "" +"Puede limitar el número de divisiones realizadas, pasando un valor para " +"*maxsplit*. Cuando *maxsplit* es distinto de cero, se realizarán como máximo " +"*maxsplit* divisiones, y el resto de la cadena de caracteres se retorna como " +"el elemento final de la lista. En el siguiente ejemplo, el delimitador es " +"cualquier secuencia de caracteres no alfanuméricos. ::" #: ../Doc/howto/regex.rst:1109 msgid "" @@ -1575,16 +2216,22 @@ msgid "" "used in the RE, then their values are also returned as part of the list. " "Compare the following calls::" msgstr "" +"A veces, no solo le interesa cuál es el texto entre delimitadores, sino que " +"también necesita saber cuál era el delimitador. Si se utilizan paréntesis de " +"captura en la RE, sus valores también se retornan como parte de la lista. " +"Compare las siguientes llamadas:" #: ../Doc/howto/regex.rst:1121 msgid "" "The module-level function :func:`re.split` adds the RE to be used as the " "first argument, but is otherwise the same. ::" msgstr "" +"La función de nivel de módulo :func:`re.split` agrega la RE que se usará " +"como primer argumento, pero por lo demás es el mismo. ::" #: ../Doc/howto/regex.rst:1133 msgid "Search and Replace" -msgstr "" +msgstr "Búsqueda y Remplazo" #: ../Doc/howto/regex.rst:1135 msgid "" @@ -1593,6 +2240,10 @@ msgid "" "replacement value, which can be either a string or a function, and the " "string to be processed." msgstr "" +"Otra tarea común es encontrar todas las coincidencias para un patrón y " +"reemplazarlas con una cadena de caracteres diferente. El método :meth:`~re." +"Pattern.sub` toma un valor de reemplazo, que puede ser una cadena de " +"caracteres o una función, y la cadena de caracteres a procesar." #: ../Doc/howto/regex.rst:1142 msgid "" @@ -1600,6 +2251,10 @@ msgid "" "occurrences of the RE in *string* by the replacement *replacement*. If the " "pattern isn't found, *string* is returned unchanged." msgstr "" +"Retorna la cadena de caracteres obtenida al reemplazar las apariciones no " +"superpuestas del extremo izquierdo de la RE en *string* por el reemplazo " +"*replacement*. Si no se encuentra el patrón, el *string* se retorna sin " +"cambios." #: ../Doc/howto/regex.rst:1146 msgid "" @@ -1607,12 +2262,17 @@ msgid "" "to be replaced; *count* must be a non-negative integer. The default value " "of 0 means to replace all occurrences." msgstr "" +"El argumento opcional *count* es el número máximo de ocurrencias de patrones " +"que se reemplazarán; *count* debe ser un número entero no negativo. El valor " +"predeterminado de 0 significa reemplazar todas las ocurrencias." #: ../Doc/howto/regex.rst:1150 msgid "" "Here's a simple example of using the :meth:`~re.Pattern.sub` method. It " "replaces colour names with the word ``colour``::" msgstr "" +"Aquí hay un ejemplo simple del uso del método :meth:`~re.Pattern.sub`. " +"Reemplaza los nombres de los colores con la palabra ``colour``::" #: ../Doc/howto/regex.rst:1159 msgid "" @@ -1620,12 +2280,17 @@ msgid "" "tuple containing the new string value and the number of replacements that " "were performed::" msgstr "" +"El método :meth:`~re.Pattern.subn` hace el mismo trabajo, pero devuelve una " +"tupla de 2 que contiene el nuevo valor de cadena de caracteres y el número " +"de reemplazos que se realizaron::" #: ../Doc/howto/regex.rst:1168 msgid "" "Empty matches are replaced only when they're not adjacent to a previous " "empty match. ::" msgstr "" +"Las coincidencias vacías se reemplazan solo cuando no son adyacentes a una " +"coincidencia vacía anterior. ::" #: ../Doc/howto/regex.rst:1175 msgid "" @@ -1637,12 +2302,21 @@ msgid "" "incorporate portions of the original text in the resulting replacement " "string." msgstr "" +"Si *replacement* es una cadena, se procesan los escapes de barra invertida " +"que contenga. Es decir, ``\\n`` se convierte en un solo carácter de nueva " +"línea, ``\\r`` se convierte en un retorno de carro, y así sucesivamente. Los " +"escapes desconocidos como ``\\&`` se dejan en paz. Las referencias inversas, " +"como ``\\6``, se reemplazan con la subcadena de caracteres que coincide con " +"el grupo correspondiente a la RE. Esto le permite incorporar partes del " +"texto original en la cadena de reemplazo resultante." #: ../Doc/howto/regex.rst:1182 msgid "" "This example matches the word ``section`` followed by a string enclosed in " "``{``, ``}``, and changes ``section`` to ``subsection``::" msgstr "" +"Este ejemplo hace coincidir la palabra ``section`` seguida de una cadena " +"encerrada entre ``{``, ``}``, y cambia ``section`` a ``subsection``::" #: ../Doc/howto/regex.rst:1189 msgid "" @@ -1655,6 +2329,15 @@ msgid "" "literal character ``'0'``.) The following substitutions are all equivalent, " "but use all three variations of the replacement string. ::" msgstr "" +"También hay una sintaxis para hacer referencia a grupos con nombre según lo " +"definido por la sintaxis ``(?P…)``syntax. ``\\g`` usará la " +"subcadena de caracteres que coincide con el grupo llamado ``name``, y ``" +"\\g`` usa el número de grupo correspondiente. ``\\g<2>`` es " +"equivalente a ``\\2``, pero no es ambiguo en una cadena de reemplazo como ``" +"\\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’``.) Las " +"siguientes sustituciones son todas equivalentes, pero use las tres " +"variaciones de la cadena de reemplazo. ::" #: ../Doc/howto/regex.rst:1206 msgid "" @@ -1664,12 +2347,20 @@ msgid "" "a :ref:`match object ` argument for the match and can use " "this information to compute the desired replacement string and return it." msgstr "" +"*replacement* también puede ser una función, lo que le brinda aún más " +"control. Si *replacement* es una función, la función se llama para cada " +"ocurrencia no superpuesta de *pattern*. En cada llamada, a la función se le " +"pasa un argumento :ref:`match object ` para la coincidencia y " +"puede usar esta información para calcular la cadena de reemplazo deseada y " +"devolverla." #: ../Doc/howto/regex.rst:1212 msgid "" "In the following example, the replacement function translates decimals into " "hexadecimal::" msgstr "" +"En el siguiente ejemplo, la función de reemplazo traduce decimales a " +"hexadecimales::" #: ../Doc/howto/regex.rst:1224 msgid "" @@ -1680,10 +2371,16 @@ msgid "" "pattern string, e.g. ``sub(\"(?i)b+\", \"x\", \"bbbb BBBB\")`` returns ``'x " "x'``." msgstr "" +"Cuando se usa la función module-level :func:`re.sub`, el patrón se pasa como " +"primer argumento. El patrón puede proporcionarse como un objeto o como una " +"cuerda; Si necesita especificar marcas de expresión regular, debe usar un " +"objeto de patrón como primer parámetro o usar modificadores incrustados en " +"la cadena de patrón, por ejemplo ``sub(“(?i)b+”, “x”, “bbbb BBBB”)`` returns " +"``’x x’``." #: ../Doc/howto/regex.rst:1232 msgid "Common Problems" -msgstr "" +msgstr "Problemas comunes" #: ../Doc/howto/regex.rst:1234 msgid "" @@ -1692,10 +2389,14 @@ msgid "" "you may expect them to. This section will point out some of the most common " "pitfalls." msgstr "" +"Las expresiones regulares son una herramienta poderosa para algunas " +"aplicaciones, pero de alguna manera su comportamiento no es intuitivo y, a " +"veces, no se comportan de la forma esperada. Esta sección señalará algunos " +"de los errores más comunes." #: ../Doc/howto/regex.rst:1240 msgid "Use String Methods" -msgstr "" +msgstr "Uso de métodos de cadenas de caracteres" #: ../Doc/howto/regex.rst:1242 msgid "" @@ -1708,6 +2409,15 @@ msgid "" "for the purpose, instead of the large, more generalized regular expression " "engine." msgstr "" +"A veces, usar el módulo :mod:`re` es un error. Si está haciendo coincidir " +"una cadena de caracteres fija, o una clase de un solo caracter, y no está " +"usando ninguna característica :mod:`re` como la marca :const:`~re." +"IGNORECASE`, entonces todo el poder de las expresiones regulares puede que " +"no sea necesario. Las cadenas tienen varios métodos para realizar " +"operaciones con cadenas fijas y, por lo general, son mucho más rápidas, " +"porque la implementación es un único bucle C pequeño que se ha optimizado " +"para este propósito, en lugar del motor de expresión regular más grande y " +"generalizado." #: ../Doc/howto/regex.rst:1250 msgid "" @@ -1721,6 +2431,15 @@ msgid "" "``word`` have a word boundary on either side. This takes the job beyond :" "meth:`!replace`'s abilities.)" msgstr "" +"Un ejemplo podría ser reemplazar una sola cadena fija por otra; por ejemplo, " +"puede reemplazar `` palabra ‘’ por `` escritura ‘’. : func: `re.sub` parece " +"la función a utilizar para esto, pero considere el método :meth:`~str." +"replace`. Tenga en cuenta que :meth:`!replace` también reemplazará` `word ‘’ " +"dentro de las palabras, convirtiendo ``swordfish`` en ``sdeedfish``, pero la " +"ingenua RE ``word`` también lo habría hecho. (Para evitar realizar la " +"sustitución en partes de palabras, el patrón tendría que ser ``\\bword\\b``, " +"para requerir que `` palabra ‘’ tenga un límite de palabra en cada lado. " +"Esto lleva el trabajo más allá de las habilidades de :meth:`!replace`.)" #: ../Doc/howto/regex.rst:1259 msgid "" @@ -1730,16 +2449,23 @@ msgid "" "capable of doing both tasks and will be faster than any regular expression " "operation can be." msgstr "" +"Otra tarea común es eliminar cada aparición de un solo carácter de una " +"cadena o reemplazarlo con otro solo carácter. Puede hacer esto con algo como " +"``re.sub(‘\\n’, ‘ ‘, S)``, pero :meth:`~str.translate` es capaz de realizar " +"ambas tareas y será más rápido que cualquier expresión regular la operación " +"puede ser." #: ../Doc/howto/regex.rst:1265 msgid "" "In short, before turning to the :mod:`re` module, consider whether your " "problem can be solved with a faster and simpler string method." msgstr "" +"En resumen, antes de pasar al módulo :mod:`re`, considere si su problema " +"puede resolverse con un método de cadena de caracteres más rápido y simple." #: ../Doc/howto/regex.rst:1270 msgid "match() versus search()" -msgstr "" +msgstr "*match() versus search()*" #: ../Doc/howto/regex.rst:1272 msgid "" @@ -1750,12 +2476,20 @@ msgid "" "start at 0; if the match wouldn't start at zero, :func:`!match` will *not* " "report it. ::" msgstr "" +"La función :func:`~re.match` solo verifica si el RE coincide con el comienzo " +"de la cadena de caracteres, mientras que :func:`~re.search` buscará una " +"coincidencia en la cadena de caracteres. Es importante tener en cuenta esta " +"distinción. Recuerde :func:`!match` solo informará una coincidencia exitosa " +"que comenzará en 0; si la coincidencia no comienza en cero, :func:`!match` " +"*no* lo informará. ::" #: ../Doc/howto/regex.rst:1283 msgid "" "On the other hand, :func:`~re.search` will scan forward through the string, " "reporting the first match it finds. ::" msgstr "" +"Por otro lado, :func:`~re.search` escaneará hacia adelante a través de la " +"cadena de caracteres, informando la primera coincidencia que encuentre. ::" #: ../Doc/howto/regex.rst:1291 msgid "" @@ -1768,6 +2502,15 @@ msgid "" "analysis lets the engine quickly scan through the string looking for the " "starting character, only trying the full match if a ``'C'`` is found." msgstr "" +"A veces, tendrá la tentación de seguir usando :func:`re.match`, y " +"simplemente agregar ``.*`` al frente de su RE. Resista esta tentación y use :" +"func:`re.search` en su lugar. El compilador de expresiones regulares realiza " +"un análisis de los RE para acelerar el proceso de búsqueda de coincidencias. " +"Uno de esos análisis determina cuál debe ser el primer carácter de una " +"coincidencia; por ejemplo, un patrón que comienza con ``Crow`` debe " +"coincidir con una ``’C’``.El análisis permite que el motor escanee " +"rápidamente a través de la cadena en busca del carácter inicial, solo " +"probando la coincidencia completa si se encuentra una ``’C’``." #: ../Doc/howto/regex.rst:1300 msgid "" @@ -1775,10 +2518,13 @@ msgid "" "the string and then backtracking to find a match for the rest of the RE. " "Use :func:`re.search` instead." msgstr "" +"Agregar ``.*`` anula esta optimización, lo que requiere escanear hasta el " +"final de la cadena y luego retroceder para encontrar una coincidencia para " +"el resto del RE. Utilice :func:`re.search` en su lugar." #: ../Doc/howto/regex.rst:1306 msgid "Greedy versus Non-Greedy" -msgstr "" +msgstr "Codiciosa versus no codiciosa (*Greedy versus Non-Greedy*)" #: ../Doc/howto/regex.rst:1308 msgid "" @@ -1788,6 +2534,12 @@ msgid "" "brackets surrounding an HTML tag. The naive pattern for matching a single " "HTML tag doesn't work because of the greedy nature of ``.*``. ::" msgstr "" +"Al repetir una expresión regular, como en ``a*``, la acción resultante es " +"consumir la mayor cantidad posible del patrón. Este hecho suele molestarle " +"cuando intenta hacer coincidir un par de delimitadores equilibrados, como " +"los corchetes angulares que rodean una etiqueta HTML. El patrón ingenuo para " +"hacer coincidir una sola etiqueta HTML no funciona debido a la naturaleza " +"codiciosa de ``.*``. ::" #: ../Doc/howto/regex.rst:1322 msgid "" @@ -1798,6 +2550,13 @@ msgid "" "The final match extends from the ``'<'`` in ``''`` to the ``'>'`` in " "``''``, which isn't what you want." msgstr "" +"La RE coincide con el ``’<‘`` en ``’’``, y el ``.*`` consume el resto " +"de la cadena de caracteres. Sin embargo, aún queda más en la RE y el ``>`` " +"no puede coincidir al final de la cadena de caracteres, por lo que el motor " +"de expresión regular tiene que retroceder caracter por caracter hasta que " +"encuentre una coincidencia para el “. La coincidencia final se extiende " +"desde el `’<‘`` en ``’’`` al ``’>’`` en ``’’``, que no es lo " +"que queremos." #: ../Doc/howto/regex.rst:1329 msgid "" @@ -1807,6 +2566,12 @@ msgid "" "matches, and when it fails, the engine advances a character at a time, " "retrying the ``'>'`` at every step. This produces just the right result::" msgstr "" +"En este caso, la solución es utilizar los calificadores no codiciosos ``*?" +"``, ``+?``, ``??``, o ``{m,n}?``, Que coinciden como *poco* texto como sea " +"posible. En el ejemplo anterior, el ``’>’`` se prueba inmediatamente después " +"de las primeras coincidencias ``’<‘``, y cuando falla, el motor avanza un " +"carácter a la vez, volviendo a intentar el ``’>’`` en cada paso. Esto " +"produce el resultado correcto:" #: ../Doc/howto/regex.rst:1338 msgid "" @@ -1817,10 +2582,16 @@ msgid "" "patterns will be *very* complicated. Use an HTML or XML parser module for " "such tasks.)" msgstr "" +"(Tenga en cuenta que analizar HTML o XML con expresiones regulares es " +"doloroso. Los patrones rápidos y sucios manejarán casos comunes, pero HTML y " +"XML tienen casos especiales que romperán la expresión regular obvia; para " +"cuando haya escrito una expresión regular que maneja todos los casos " +"posibles, los patrones serán *muy* complicados. Utilice un módulo analizador " +"HTML o XML para tales tareas.)" #: ../Doc/howto/regex.rst:1346 msgid "Using re.VERBOSE" -msgstr "" +msgstr "Usando re.VERBOSE" #: ../Doc/howto/regex.rst:1348 msgid "" @@ -1829,6 +2600,10 @@ msgid "" "become lengthy collections of backslashes, parentheses, and metacharacters, " "making them difficult to read and understand." msgstr "" +"Probablemente ya hayas notado que las expresiones regulares son una notación " +"muy compacta, pero no son muy legibles. Los RE de complejidad moderada " +"pueden convertirse en largas colecciones de barras invertidas, paréntesis y " +"metacaracteres, lo que dificulta su lectura y comprensión." #: ../Doc/howto/regex.rst:1353 msgid "" @@ -1836,6 +2611,9 @@ msgid "" "regular expression can be helpful, because it allows you to format the " "regular expression more clearly." msgstr "" +"Para tales RE, especificar el flag :const:`re.VERBOSE` al compilar la " +"expresión regular puede ser útil, porque le permite formatear la expresión " +"regular con mayor claridad." #: ../Doc/howto/regex.rst:1357 msgid "" @@ -1847,14 +2625,24 @@ msgid "" "extend from a ``#`` character to the next newline. When used with triple-" "quoted strings, this enables REs to be formatted more neatly::" msgstr "" +"La `` re.VERBOSE ‘’ tiene varios efectos. Los espacios en blanco en la " +"expresión regular que * no están * dentro de una clase de caracteres se " +"ignoran. Esto significa que una expresión como `` perro | gato ‘’ es " +"equivalente al menos legible `` perro | gato ‘’, pero `` [a b] ‘’ seguirá " +"coincidiendo con los caracteres `` ‘a’``, ``’ b’`` o un espacio. Además, " +"también puede poner comentarios dentro de un RE; los comentarios se " +"extienden desde un carácter `` # ‘’ hasta la siguiente línea nueva. Cuando " +"se usa con cadenas entre comillas triples, esto permite que los REs sean " +"formateados de manera más ordenada:" #: ../Doc/howto/regex.rst:1374 msgid "This is far more readable than::" -msgstr "" +msgstr "Esto es mas legible que::" #: ../Doc/howto/regex.rst:1380 +#, fuzzy msgid "Feedback" -msgstr "" +msgstr "Sus comentarios" #: ../Doc/howto/regex.rst:1382 msgid "" @@ -1863,6 +2651,9 @@ msgid "" "encountered that weren't covered here? If so, please send suggestions for " "improvements to the author." msgstr "" +"Las expresiones regulares son un tema complicado. ¿Le ayudó este documento a " +"comprenderlos? ¿Hubo partes que no estaban claras o problemas que encontró " +"que no se trataron aquí? Si es así, envíe sugerencias de mejora al autor." #: ../Doc/howto/regex.rst:1387 msgid "" @@ -1874,3 +2665,10 @@ msgid "" "edition covered Python's now-removed :mod:`!regex` module, which won't help " "you much.) Consider checking it out from your library." msgstr "" +"El libro más completo sobre expresiones regulares es casi con certeza " +"*Mastering Regular Expressions de Jeffrey Friedl*, publicado por *O’Reilly*. " +"Desafortunadamente, se concentra exclusivamente en los tipos de expresiones " +"regulares de Perl y Java, y no contiene ningún material de Python, por lo " +"que no será útil como referencia para la programación en Python. (La primera " +"edición cubría el módulo :mod:`!regex` de Python, ahora eliminado, que no le " +"ayudará mucho.) Considere sacarlo de su biblioteca." From 87d153ee92efb1811e2523fdc1295fa3e59b7038 Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Thu, 29 Oct 2020 19:58:38 +0100 Subject: [PATCH 2/9] pospell --- dictionaries/howto_regex.txt | 16 ++ howto/regex.po | 541 ++++++++++++++++++----------------- 2 files changed, 289 insertions(+), 268 deletions(-) diff --git a/dictionaries/howto_regex.txt b/dictionaries/howto_regex.txt index e69de29bb2..4d93fac625 100644 --- a/dictionaries/howto_regex.txt +++ b/dictionaries/howto_regex.txt @@ -0,0 +1,16 @@ +metacarácteres +metacarácter +colocándolos +intentémoslo +reduccionista +enciérrelo +subexpresión +subgrupos +anidarlo +hexadecimales +colocándolos +colocándolas +reemplácelas +comprenderlas +precediéndolos +precederlos \ No newline at end of file diff --git a/howto/regex.po b/howto/regex.po index ac29c98ce0..615a4ddef6 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -11,7 +11,7 @@ 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: 2020-10-28 00:04+0100\n" +"PO-Revision-Date: 2020-10-28 22:57+0100\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -25,7 +25,7 @@ msgstr "" #: ../Doc/howto/regex.rst:5 msgid "Regular Expression HOWTO" -msgstr "Expresiones regulares COMOS (*HOW TO*)" +msgstr "Expresiones regulares COMOS (*HOWTO*)" #: ../Doc/howto/regex.rst msgid "Author" @@ -47,7 +47,7 @@ msgstr "" "Este documento es un tutorial de introducción al uso de expresiones " "regulares en Python con el módulo :mod:`re`. Proporciona una introducción " "más apacible que la sección correspondiente en la Referencia de la " -"biblioteca." +"Biblioteca." #: ../Doc/howto/regex.rst:24 msgid "Introduction" @@ -65,7 +65,7 @@ msgid "" "match for the pattern anywhere in this string?\". You can also use REs to " "modify a string or to split it apart in various ways." msgstr "" -"Las expresiones regulares (llamadas RE, o regexes, o patrones de regex) son " +"Las expresiones regulares (llamadas RE, o regex, o patrones de regex) son " "esencialmente en un lenguaje de programación diminuto y altamente " "especializado incrustado dentro de Python y disponible a través del módulo :" "mod:`re`. Usando este pequeño lenguaje, especificas las reglas para el " @@ -90,7 +90,7 @@ msgstr "" "Los patrones de expresiones regulares se compilan en una serie de códigos de " "bytes que luego son ejecutados por un motor de coincidencia escrito en C. " "Para un uso avanzado, puede ser necesario prestar mucha atención a cómo el " -"motor ejecutará un RE dado y escribir el RE en un de cierta manera para " +"motor ejecutará una RE dado y escribir la RE en un de cierta manera para " "producir un código de bytes que se ejecute más rápido. La optimización no se " "trata en este documento, porque requiere que tenga un buen conocimiento de " "los componentes internos del motor de coincidencia." @@ -168,16 +168,16 @@ msgid "" msgstr "" "Hay excepciones a esta regla; algunos caracteres son especiales :dfn:" "`metacharacters`, y no coinciden. En cambio, señalan que debe coincidir con " -"algo fuera de lo común, o afectan otras partes del RE repitiéndolos o " +"algo fuera de lo común, o afectan otras partes de la RE repitiéndolos o " "cambiando su significado. Gran parte de este documento está dedicado a " -"discutir varios metacaracteres y lo que hacen." +"discutir varios metacarácteres y lo que hacen." #: ../Doc/howto/regex.rst:76 msgid "" "Here's a complete list of the metacharacters; their meanings will be " "discussed in the rest of this HOWTO." msgstr "" -"Aquí hay una lista completa de los metacaracteres; sus significados se " +"Aquí hay una lista completa de los metacarácteres; sus significados se " "discutirán en el resto de este COMO (*HOWTO*)." #: ../Doc/howto/regex.rst:83 @@ -191,11 +191,11 @@ msgid "" "characters. If you wanted to match only lowercase letters, your RE would be " "``[a-z]``." msgstr "" -"Los primeros metacaracteres que veremos son ``[`` and ``]``. Se utilizan " +"Los primeros metacarácteres que veremos son ``[`` and ``]``. Se utilizan " "para especificar una clase de carácter, que es un conjunto de caracteres que " "desea hacer coincidir. Los caracteres se pueden enumerar individualmente, o " "se puede indicar un rango de caracteres dando dos caracteres y separándolos " -"con un ``’-‘``. Por ejemplo, ``[abc]`` coincidirá con cualquiera de los " +"con un ``'-'``. Por ejemplo, ``[abc]`` coincidirá con cualquiera de los " "caracteres ``a``, ``b`` o ``c``; esto es lo mismo que ``[a-c]``, que usa un " "rango para expresar el mismo conjunto de caracteres. Si quisiera hacer " "coincidir solo letras minúsculas, su RE sería ``[a-c]``." @@ -207,10 +207,10 @@ msgid "" "is usually a metacharacter, but inside a character class it's stripped of " "its special nature." msgstr "" -"Los metacaracteres no están activos dentro de las clases. Por ejemplo, ``[akm" -"$]`` coincidirá con cualquiera de los caracteres ``’a’``, ``’k’``, ``’m’``, " -"or ``’$’``; ``’$’`` suele ser un metacaracter, pero dentro de una clase de " -"caracter se le quita su naturaleza especial." +"Los metacarácteres no están activos dentro de las clases. Por ejemplo, ``[akm" +"$]`` coincidirá con cualquiera de los caracteres ``'a'``, ``'k'``, ``'m'``, " +"or ``'$'``; ``'$'`` suele ser un metacarácter, pero dentro de una clase de " +"carácter se le quita su naturaleza especial." #: ../Doc/howto/regex.rst:97 msgid "" @@ -223,10 +223,10 @@ msgid "" msgstr "" "Puede hacer coincidir los caracteres que no figuran en la clase mediante el " "conjunto :dfn:`complementing`. Esto se indica mediante la inclusión de un " -"``’^’`` como primer carácter de la clase. Por ejemplo, ``[^5]`` coincidirá " -"con cualquier carácter excepto con ``’5’``.Si el símbolo de intercalación " +"``'^'`` como primer carácter de la clase. Por ejemplo, ``[^5]`` coincidirá " +"con cualquier carácter excepto con ``'5'``.Si el símbolo de intercalación " "aparece en otra parte de una clase de caracter, no tiene un significado " -"especial. Por ejemplo: ``[5^] `` coincidirá con un `` ‘5’`` o un ``’^’``." +"especial. Por ejemplo: ``[5^] `` coincidirá con un ``'5'`` o un ``'^'``." #: ../Doc/howto/regex.rst:103 msgid "" @@ -237,13 +237,13 @@ msgid "" "need to match a ``[`` or ``\\``, you can precede them with a backslash to " "remove their special meaning: ``\\[`` or ``\\\\``." msgstr "" -"Quizás el metacarácter más importante es la barra invertida, `` \\ ‘’. Al " +"Quizás el metacarácter más importante es la barra invertida, ``\\``. Al " "igual que en los literales de cadena de Python, la barra invertida puede ir " "seguida de varios caracteres para señalar varias secuencias especiales. " -"También se usa para escapar de todos los metacaracteres, de modo que aún " +"También se usa para escapar de todos los metacarácteres, de modo que aún " "pueda emparejarlos en patrones; por ejemplo, si necesita hacer coincidir un " -"`` [`` o `` \\ ``, puede precederlos con una barra invertida para eliminar " -"su significado especial: `` \\ [`` o `` \\\\ ``." +"``[`` o ``\\``, puede precederlos con una barra invertida para eliminar su " +"significado especial: ``\\[`` o ``\\\\``." #: ../Doc/howto/regex.rst:110 msgid "" @@ -251,7 +251,7 @@ msgid "" "sets of characters that are often useful, such as the set of digits, the set " "of letters, or the set of anything that isn't whitespace." msgstr "" -"Algunas de las secuencias especiales que comienzan con ``’\\’`` representan " +"Algunas de las secuencias especiales que comienzan con ``'\\'`` representan " "conjuntos predefinidos de caracteres que a menudo son útiles, como el " "conjunto de dígitos, el conjunto de letras o el conjunto de cualquier cosa " "que no sea un espacio en blanco." @@ -287,7 +287,7 @@ msgstr "" "una lista completa de secuencias y definiciones de clases expandidas para " "patrones de cadenas Unicode, consulte la última parte de :ref:`Regular " "Expression Syntax ` en la referencia de la biblioteca estándar. " -"En general, las versiones Unicode coinciden con cualquier caracter que esté " +"En general, las versiones Unicode coinciden con cualquier carácter que esté " "en la categoría apropiada en la base de datos Unicode." #: ../Doc/howto/regex.rst:131 @@ -308,7 +308,7 @@ msgstr "``\\D``" msgid "" "Matches any non-digit character; this is equivalent to the class ``[^0-9]``." msgstr "" -"Coincide con cualquier caracter que no sea un dígito; esto es equivalente a " +"Coincide con cualquier carácter que no sea un dígito; esto es equivalente a " "la clase ``[^0-9]``." #: ../Doc/howto/regex.rst:138 @@ -320,7 +320,7 @@ msgid "" "Matches any whitespace character; this is equivalent to the class ``[ \\t\\n" "\\r\\f\\v]``." msgstr "" -"Coincide con cualquier caracter de espacio en blanco; esto es equivalente a " +"Coincide con cualquier carácter de espacio en blanco; esto es equivalente a " "la clase ``[ \\t\\n\\r\\f\\v]``." #: ../Doc/howto/regex.rst:142 @@ -332,7 +332,7 @@ msgid "" "Matches any non-whitespace character; this is equivalent to the class ``[^ " "\\t\\n\\r\\f\\v]``." msgstr "" -"Coincide con cualquier caracter que no sea un espacio en blanco; esto es " +"Coincide con cualquier carácter que no sea un espacio en blanco; esto es " "equivalente a la clase ``[^ \\t\\n\\r\\f\\v]``." #: ../Doc/howto/regex.rst:146 @@ -344,7 +344,7 @@ msgid "" "Matches any alphanumeric character; this is equivalent to the class ``[a-zA-" "Z0-9_]``." msgstr "" -"Coincide con cualquier caracter alfanumérico; esto es equivalente a la clase " +"Coincide con cualquier carácter alfanumérico; esto es equivalente a la clase " "``[a-zA-Z0-9_]``." #: ../Doc/howto/regex.rst:150 @@ -356,7 +356,7 @@ msgid "" "Matches any non-alphanumeric character; this is equivalent to the class " "``[^a-zA-Z0-9_]``." msgstr "" -"Coincide con cualquier caracter no alfanumérico; esto es equivalente a la " +"Coincide con cualquier carácter no alfanumérico; esto es equivalente a la " "clase``[^a-zA-Z0-9_]``." #: ../Doc/howto/regex.rst:152 @@ -365,9 +365,9 @@ msgid "" "``[\\s,.]`` is a character class that will match any whitespace character, " "or ``','`` or ``'.'``." msgstr "" -"Estas secuencias se pueden incluir dentro de una clase de personaje. Por " -"ejemplo, ``[\\s,.]`` es una clase de caracter que coincidirá con cualquier " -"carácter de espacio en blanco, o ``’,’`` o ``’.’``." +"Estas secuencias se pueden incluir dentro de una clase de carácter. Por " +"ejemplo, ``[\\s,.]`` es una clase de carácter que coincidirá con cualquier " +"carácter de espacio en blanco, o ``','`` o ``'.'``." #: ../Doc/howto/regex.rst:156 msgid "" @@ -376,8 +376,8 @@ msgid "" "DOTALL`) where it will match even a newline. ``.`` is often used where you " "want to match \"any character\"." msgstr "" -"El metacaracter final en esta sección es ``.``. Coincide con cualquier cosa " -"excepto un caracter de nueva línea, y hay un modo alternativo (:const:`re." +"El metacarácter final en esta sección es ``.``. Coincide con cualquier cosa " +"excepto un carácter de nueva línea, y hay un modo alternativo (:const:`re." "DOTALL`) donde coincidirá incluso con una nueva línea. ``.`` se usa a menudo " "cuando se desea hacer coincidir “cualquier carácter”." @@ -395,10 +395,10 @@ msgid "" msgstr "" "Ser capaz de hacer coincidir diferentes conjuntos de caracteres es lo " "primero que pueden hacer las expresiones regulares que ya no es posible con " -"los métodos disponibles en cadenas. Sin embargo, si esa fuera la única " -"capacidad adicional de las expresiones regulares, no serían un gran avance. " -"Otra capacidad es que puede especificar que partes del RE deben repetirse un " -"cierto número de veces." +"los métodos disponibles en cadenas de caracteres. Sin embargo, si esa fuera " +"la única capacidad adicional de las expresiones regulares, no serían un gran " +"avance. Otra capacidad es que puede especificar que partes de la RE deben " +"repetirse un cierto número de veces." #: ../Doc/howto/regex.rst:171 msgid "" @@ -407,8 +407,8 @@ msgid "" "that the previous character can be matched zero or more times, instead of " "exactly once." msgstr "" -"El primer metacaracter para repetir cosas que veremos es ``*``. ``*`` no " -"coincide con el caracter literal ``’*’``; en cambio, especifica que el " +"El primer metacarácter para repetir cosas que veremos es ``*``. ``*`` no " +"coincide con el carácter literal ``'*'``; en cambio, especifica que el " "carácter anterior puede coincidir cero o más veces, en lugar de exactamente " "una vez." @@ -417,8 +417,8 @@ msgid "" "For example, ``ca*t`` will match ``'ct'`` (0 ``'a'`` characters), ``'cat'`` " "(1 ``'a'``), ``'caaat'`` (3 ``'a'`` characters), and so forth." msgstr "" -"Por ejemplo, ``ca*t`` coincidirá con ``’ct’`` (0 ``’a’`` caracteres), " -"``’cat’`` (1 ``’a’``), ``’caaat’`` (3 ``’a’`` characters), etcétera." +"Por ejemplo, ``ca*t`` coincidirá con ``'ct'`` (0 ``'a'`` caracteres), " +"``'cat'`` (1 ``'a'``), ``'caaat'`` (3 ``'a'`` caracteres), etcétera." #: ../Doc/howto/regex.rst:178 msgid "" @@ -427,8 +427,8 @@ msgid "" "portions of the pattern don't match, the matching engine will then back up " "and try again with fewer repetitions." msgstr "" -"Las repeticiones como ``*`` son :dfn:`greedy`; al repetir un RE, el motor de " -"emparejamiento intentará repetirlo tantas veces como sea posible. Si las " +"Las repeticiones como ``*`` son :dfn:`greedy`; al repetir una RE, el motor " +"de emparejamiento intentará repetirlo tantas veces como sea posible. Si las " "partes posteriores del patrón no coinciden, el motor de coincidencia hará " "una copia de seguridad y volverá a intentarlo con menos repeticiones." @@ -440,9 +440,9 @@ msgid "" "imagine matching this RE against the string ``'abcbd'``." msgstr "" "Un ejemplo paso a paso hará que esto sea más obvio. Consideremos la " -"expresión ``a[bcd]*b``. Esto coincide con la letra ``’a’``, cero o más " -"letras de la clase ``[bcd]``, y finalmente termina con una ``’b’``. Ahora " -"imagina hacer coincidir este RE con la cadena de caracteres ``’abcbd’``." +"expresión ``a[bcd]*b``. Esto coincide con la letra ``'a'``, cero o más " +"letras de la clase ``[bcd]``, y finalmente termina con una ``'b'``. Ahora " +"imagina hacer coincidir este RE con la cadena de caracteres ``'abcbd'``." #: ../Doc/howto/regex.rst:189 msgid "Step" @@ -466,7 +466,7 @@ msgstr "``a``" #: ../Doc/howto/regex.rst:191 msgid "The ``a`` in the RE matches." -msgstr "La ``a`` en los RE coincide." +msgstr "La ``a`` en las RE coincide." #: ../Doc/howto/regex.rst:193 msgid "2" @@ -524,7 +524,7 @@ msgid "" "a ``'d'``." msgstr "" "Intente ``b`` de nuevo, pero la posición actual está en el último caracter, " -"que es un ``’d’``." +"que es un ``'d'``." #: ../Doc/howto/regex.rst:209 ../Doc/howto/regex.rst:213 msgid "6" @@ -537,7 +537,7 @@ msgstr "``abc``" #: ../Doc/howto/regex.rst:209 msgid "Back up again, so that ``[bcd]*`` is only matching ``bc``." msgstr "" -"Hace una copia de seguridad de nuevo, de modo que ``[bcd]*`` solo coincida " +"Haga una copia de seguridad de nuevo, de modo que ``[bcd]*`` solo coincida " "con ``bc``." #: ../Doc/howto/regex.rst:213 @@ -545,8 +545,8 @@ msgid "" "Try ``b`` again. This time the character at the current position is " "``'b'``, so it succeeds." msgstr "" -"Intenta ``b`` de nuevo. Esta vez, el caracter en la posición actual es " -"``’b’``, por lo que tiene éxito." +"Intente ``b`` de nuevo. Esta vez, el carácter en la posición actual es " +"``'b'``, por lo que tiene éxito." #: ../Doc/howto/regex.rst:219 msgid "" @@ -557,13 +557,13 @@ msgid "" "``[bcd]*``, and if that subsequently fails, the engine will conclude that " "the string doesn't match the RE at all." msgstr "" -"Se ha alcanzado el final del RE y ha coincidido con ``’abcb’``. Esto " +"Se ha alcanzado el final de la RE y ha coincidido con ``'abcb'``. Esto " "demuestra cómo el motor de coincidencias llega tan lejos como puede al " "principio, y si no se encuentra ninguna coincidencia, retrocederá " -"progresivamente y volverá a intentar el resto del RE una y otra vez. Hará " -"una copia de seguridad hasta que haya probado cero coincidencias para " -"``[bcd]*``, y si eso falla posteriormente, el motor concluirá que la cadena " -"no coincide con el RE en absoluto." +"progresivamente y volverá a intentar de la RE una y otra vez. Hará una copia " +"de seguridad hasta que haya probado cero coincidencias para ``[bcd]*``, y si " +"eso falla posteriormente, el motor concluirá que la cadena no coincide con " +"la RE en absoluto." #: ../Doc/howto/regex.rst:226 msgid "" @@ -574,12 +574,12 @@ msgid "" "similar example, ``ca+t`` will match ``'cat'`` (1 ``'a'``), ``'caaat'`` (3 " "``'a'``\\ s), but won't match ``'ct'``." msgstr "" -"Otro metacaracter que se repite es `` + ‘’, que coincide una o más veces. " +"Otro metacarácter que se repite es ``+``, que coincide una o más veces. " "Preste especial atención a la diferencia entre ``*`` and ``+``; coincide con " -"* cero * o más veces, por lo que cualquier cosa que se repita puede no estar " -"presente en absoluto, mientras que ``+`` requiere al menos * una * " -"aparición. Para usar un ejemplo similar, ``’cat’`` (1 ``’a’``), ``’caaat’`` " -"(3 ``’a’``\\ s), pero no coincidirá con ``’ct’``." +"*zero* o más veces, por lo que cualquier cosa que se repita puede no estar " +"presente en absoluto, mientras que ``+`` requiere al menos *one* aparición. " +"Para usar un ejemplo similar, ``'cat'`` (1 ``'a'``), ``'caaat'`` (3 ``'a'``" +"\\ s), pero no coincidirá con ``'ct'``." #: ../Doc/howto/regex.rst:233 msgid "" @@ -591,7 +591,7 @@ msgstr "" "Hay dos calificadores más que se repiten. El carácter de signo de " "interrogación, ``?``, Coincide una vez o cero veces; puede pensar en ello " "como si marcara algo como opcional. Por ejemplo, ``home-?brew`` coincide con " -"``’homebrew’`` o ``’home-brew’``." +"``'homebrew'`` o ``'home-brew'``." #: ../Doc/howto/regex.rst:238 msgid "" @@ -603,9 +603,9 @@ msgid "" msgstr "" "El calificador repetido más complicado es ``{m,n}``, donde *m* y *n* son " "enteros decimales. Este calificador significa que debe haber al menos *m* " -"repeticiones y como máximo *n*. Por ejemplo, ``a/{1,3}b`` coincidirá con``’a/" -"b’``, ``’a//b’``, and ``’a///b’``. No coincidirá con `` ‘ab’ ‘, que no tiene " -"barras, ni con ``’a////b’``, que tiene cuatro." +"repeticiones y como máximo *n*. Por ejemplo, ``a/{1,3}b`` coincidirá con``'a/" +"b'``, ``'a//b'``, and ``'a///b'``. No coincidirá con `` 'ab' ', que no tiene " +"barras, ni con ``'a////b'``, que tiene cuatro." #: ../Doc/howto/regex.rst:244 msgid "" @@ -683,21 +683,21 @@ msgid "" "simply a C extension module included with Python, just like the :mod:" "`socket` or :mod:`zlib` modules." msgstr "" -"El RE se pasa a :func:`re.compile` como una cadena. Los RE se manejan como " -"cadenas porque las expresiones regulares no son parte del lenguaje central " -"de Python y no se creó una sintaxis especial para expresarlas. (Hay " -"aplicaciones que no necesitan RE en absoluto, por lo que no hay necesidad de " -"aumentar la especificación del lenguaje incluyéndolas). En cambio, el " -"módulo :mod:`re` es simplemente un módulo de extensión C incluido con " -"Python, al igual que los módulos :mod:`socket` o :mod:zlib`." +"La RE se pasa a :func:`re.compile` como una cadena de caracteres. Las RE se " +"manejan como cadenas de caracteres porque las expresiones regulares no son " +"parte del lenguaje central de Python y no se creó una sintaxis especial para " +"expresarlas. (Hay aplicaciones que no necesitan RE en absoluto, por lo que " +"no hay necesidad de aumentar la especificación del lenguaje incluyéndolas). " +"En cambio, el módulo :mod:`re` es simplemente un módulo de extensión C " +"incluido en Python, al igual que los módulos :mod:`socket` o :mod:zlib`." #: ../Doc/howto/regex.rst:289 msgid "" "Putting REs in strings keeps the Python language simpler, but has one " "disadvantage which is the topic of the next section." msgstr "" -"Poner RE en cadenas mantiene el lenguaje Python más simple, pero tiene una " -"desventaja que es el tema de la siguiente sección." +"Poner RE en cadenas de caracteres mantiene el lenguaje Python más simple, " +"pero tiene una desventaja que es el tema de la siguiente sección." #: ../Doc/howto/regex.rst:296 #, fuzzy @@ -712,7 +712,7 @@ msgid "" "usage of the same character for the same purpose in string literals." msgstr "" "Como se indicó anteriormente, las expresiones regulares usan el carácter de " -"barra invertida (``’\\’``) para indicar formas especiales o para permitir " +"barra invertida (``'\\'``) para indicar formas especiales o para permitir " "que se usen caracteres especiales sin invocar su significado especial. Esto " "entra en conflicto con el uso de Python del mismo carácter para el mismo " "propósito en cadenas literales." @@ -728,15 +728,15 @@ msgid "" "to express this as a Python string literal, both backslashes must be escaped " "*again*." msgstr "" -"Supongamos que desea escribir un RE que coincida con la cadena ``" -"\\section``, que podría encontrarse en un archivo *LaTeX*. Para averiguar " -"qué escribir en el código del programa, comience con la cadena deseada para " -"que coincida. A continuación, debe escapar de las barras invertidas y otros " -"metacaracteres precediéndolos con una barra invertida, lo que da como " -"resultado la cadena `` \\\\ sección ‘’. La cadena resultante que debe " -"pasarse a :func:`re.compile` debe ser ``\\\\section``. Sin embargo, para " -"expresar esto como una cadena literal de Python, ambas barras invertidas " -"deben escaparse *nuevamente*." +"Supongamos que desea escribir una RE que coincida con la cadena de " +"caracteres ``\\section``, que podría encontrarse en un archivo *LaTeX*. Para " +"averiguar qué escribir en el código del programa, comience con la cadena " +"deseada para que coincida. A continuación, debe escapar de las barras " +"invertidas y otros metacarácteres precediéndolos con una barra invertida, lo " +"que da como resultado la cadena `` \\\\ sección ''. La cadena resultante que " +"debe pasarse a :func:`re.compile` debe ser ``\\\\section``. Sin embargo, " +"para expresar esto como una cadena literal de Python, ambas barras " +"invertidas deben escaparse *nuevamente*." #: ../Doc/howto/regex.rst:312 msgid "Characters" @@ -780,9 +780,9 @@ msgid "" "repeated backslashes and makes the resulting strings difficult to understand." msgstr "" "En resumen, para hacer coincidir una barra invertida literal, uno tiene que " -"escribir ``’\\\\\\\\’`` como la cadena RE, porque la expresión regular debe " +"escribir ``'\\\\\\\\'`` como la cadena RE, porque la expresión regular debe " "ser ``\\\\``, y cada barra invertida debe expresarse como ``\\\\`` dentro de " -"un literal de cadena Python normal. En los RE que presentan barras " +"un literal de cadena Python normal. En las RE que presentan barras " "invertidas repetidamente, esto genera muchas barras invertidas repetidas y " "dificulta la comprensión de las cadenas resultantes." @@ -795,13 +795,13 @@ msgid "" "newline. Regular expressions will often be written in Python code using this " "raw string notation." msgstr "" -"La solución es utilizar la notación de cadena sin formato de Python para " -"expresiones regulares; las barras invertidas no se manejan de ninguna manera " -"especial en una cadena literal con el prefijo ``’r’``, por lo 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. Las " -"expresiones regulares a menudo se escribirán en código Python utilizando " -"esta notación de cadena sin formato." +"La solución es utilizar la notación de cadena de caracteres sin formato de " +"Python para expresiones regulares; las barras invertidas no se manejan de " +"ninguna manera especial en una cadena literal con el prefijo ``'r'``, por lo " +"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. Las expresiones regulares a menudo se escribirán en código " +"Python utilizando esta notación de cadena sin formato." #: ../Doc/howto/regex.rst:333 msgid "" @@ -879,7 +879,8 @@ msgstr "``match()``" #: ../Doc/howto/regex.rst:362 msgid "Determine if the RE matches at the beginning of the string." -msgstr "Determina si el RE coincide con el comienzo de la cadena." +msgstr "" +"Determina si la RE coincide con el comienzo de la cadena de caracteres." #: ../Doc/howto/regex.rst:365 msgid "``search()``" @@ -897,8 +898,8 @@ msgstr "``findall()``" #: ../Doc/howto/regex.rst:368 msgid "Find all substrings where the RE matches, and returns them as a list." msgstr "" -"Encuentra todas las subcadenas de caracteres donde coincide el RE y las " -"devuelve como una lista." +"Encuentra todas las subcadenas de caracteres donde coincide la RE y las " +"retorna como una lista." #: ../Doc/howto/regex.rst:371 msgid "``finditer()``" @@ -909,7 +910,7 @@ msgid "" "Find all substrings where the RE matches, and returns them as an :term:" "`iterator`." msgstr "" -"Encuentra todas las subcadenas donde el RE coincide y las devuelve como un " +"Encuentra todas las subcadenas donde la RE coincide y las retorna como un " "término iterado :term:`iterator`." #: ../Doc/howto/regex.rst:375 @@ -937,9 +938,9 @@ msgstr "" "Puede aprender sobre esto experimentando interactivamente con el módulo :mod:" "`re`. Si tiene :mod:`tkinter` disponible, también puede consultar :source:" "`Tools/demo/redemo.py`, un programa de demostración incluido con la " -"distribución de Python. Le permite ingresar RE y cadenas, y muestra si el RE " -"coincide o falla. :file:`redemo.py` puede ser bastante útil cuando se " -"intenta depurar un RE complicado." +"distribución de Python. Le permite ingresar RE y cadenas de caracteres, y " +"muestra si la RE coincide o falla. :file:`redemo.py` puede ser bastante útil " +"cuando se intenta depurar una RE complicado." #: ../Doc/howto/regex.rst:387 msgid "" @@ -958,12 +959,12 @@ msgid "" "which will cause the interpreter to print no output. You can explicitly " "print the result of :meth:`!match` to make this clear. ::" msgstr "" -"Ahora, puede intentar hacer coincidir varias cadenas con el RE ``[a-z]+``. " +"Ahora, puede intentar hacer coincidir varias cadenas con la RE ``[a-z]+``. " "Una cadena de caracteres vacía no debería coincidir en absoluto, ya que ``" -"+`` significa ‘una o más repeticiones’. :meth:`~ re.Pattern.match` debería " -"devolver``None`` en este caso, lo que hará que el intérprete no imprima " -"ningún resultado. Puede imprimir explícitamente el resultado de :meth:`!" -"match` para aclarar esto. ::" +"+`` significa que 'una o más repeticiones'. :meth:`~re.Pattern.match` " +"debería retornar ``None`` en este caso, lo que hará que el intérprete no " +"imprima ningún resultado. Puede imprimir explícitamente el resultado de :" +"meth:`!match` para aclarar esto. ::" #: ../Doc/howto/regex.rst:405 msgid "" @@ -972,9 +973,9 @@ msgid "" "objects>`, so you should store the result in a variable for later use. ::" msgstr "" "Ahora, intentémoslo en una cadena de caracteres que debería coincidir, como " -"``tempo``.En este caso ,:meth:`~re.Pattern.match` retornará un :ref:`match " +"``tempo``.En este caso , :meth:`~re.Pattern.match` retornará un :ref:`match " "object `, por lo que debe almacenar el resultado en una " -"variable para su uso posterior. ::" +"variable para su posterior uso. ::" #: ../Doc/howto/regex.rst:413 msgid "" @@ -982,7 +983,7 @@ msgid "" "about the matching string. Match object instances also have several methods " "and attributes; the most important ones are:" msgstr "" -"Ahora puede consultar: ref: `match object ` para obtener " +"Ahora puede consultar :ref:`match object ` para obtener " "información sobre la cadena coincidente. Las instancias de objetos " "coincidentes también tienen varios métodos y atributos; los más importantes " "son:" @@ -993,7 +994,7 @@ msgstr "``group()``" #: ../Doc/howto/regex.rst:420 msgid "Return the string matched by the RE" -msgstr "Retorna la cadena de caracteres que coincide con el RE" +msgstr "Retorna la cadena de caracteres que coincide con la RE" #: ../Doc/howto/regex.rst:422 msgid "``start()``" @@ -1036,13 +1037,14 @@ msgid "" "case. ::" msgstr "" ":meth:`~re.Match.group` retorna la subcadena de caracteres que coincide con " -"el RE. :meth:`~re.Match.start` y :meth:`~ re.Match.end` retornan el índice " -"inicial y final de la coincidencia. :meth:`~re.Match.span` retorna los " -"índices inicial y final en una única tupla. Dado que el método :meth:`~re." -"Pattern.match` solo verifica si el RE coincide al comienzo de una cadena , :" -"meth:`!start` siempre será cero. Sin embargo, el método de patrones :meth:" -"`~re.Pattern.search` escanea a través de la cadena de caracteres, por lo que " -"es posible que la coincidencia no comience en cero en ese caso. ::" +"la RE. :meth:`~re.Match.start` y :meth:`~re.Match.end` retornan el índice " +"inicial y final de la coincidencia. :meth:`~re.Match.span` retorna el índice " +"inicial y final en una única tupla. Dado que el método :meth:`~re.Pattern." +"match` solo verifica si la RE coincide al comienzo de una cadena de " +"caracteres, :meth:`!start` siempre será cero. Sin embargo, el método de " +"patrones :meth:`~re.Pattern.search` escanea a través de la cadena de " +"caracteres, por lo que es posible que la coincidencia no comience en cero en " +"ese caso. ::" #: ../Doc/howto/regex.rst:456 msgid "" @@ -1060,7 +1062,8 @@ msgid "" "Pattern.findall` returns a list of matching strings::" msgstr "" "Dos métodos de patrón retornan todas las coincidencias de un patrón. :meth:" -"`~re.Pattern.findall` retorna una lista de cadenas coincidentes::" +"`~re.Pattern.findall` retorna una lista de cadenas de caracteres " +"coincidentes::" #: ../Doc/howto/regex.rst:474 msgid "" @@ -1070,12 +1073,12 @@ msgid "" "in a :exc:`DeprecationWarning` and will eventually become a :exc:" "`SyntaxError`. See :ref:`the-backslash-plague`." msgstr "" -"El prefijo ``r``, que convierte al literal en un literal de cadena sin " -"formato, es necesario en este ejemplo porque las secuencias de escape en un " -"literal de cadena “cocinado” normal que no son reconocidas por Python, a " -"diferencia de las expresiones regulares, ahora dan como resultado :exc:" -"`DeprecationWarning` y eventualmente se convertirá en :exc:`SyntaxError`. " -"Ver :ref:`the-backslash-plague`." +"El prefijo ``r``, que convierte al literal en una cadena de caracteres " +"literal sin formato, es necesario en este ejemplo porque las secuencias de " +"escape en un cadena de caracteres literal “cocinado” normal que no son " +"reconocidas por Python, a diferencia de las expresiones regulares, ahora dan " +"como resultado :exc:`DeprecationWarning` y eventualmente se convertirá en :" +"exc:`SyntaxError`. Ver :ref:`the-backslash-plague`." #: ../Doc/howto/regex.rst:480 msgid "" @@ -1085,7 +1088,7 @@ msgid "" "`iterator`::" msgstr "" ":meth:`~re.Pattern.findall` tiene que crear la lista completa antes de que " -"pueda devolverse como resultado. El método :meth:`~re.Pattern.finditer` " +"pueda retornarse como resultado. El método :meth:`~re.Pattern.finditer` " "retorna una secuencia de :ref:`match object ` instancias como " "iterados :term:`iterator`::" @@ -1103,11 +1106,11 @@ msgid "" "``None`` or a :ref:`match object ` instance. ::" msgstr "" "No es necesario crear un objeto patrón y llamar a sus métodos; el módulo :" -"mod:`re` también proporciona funciones de nivel superior llamadas :func:`~ " -"re.match` , :func:`~re.search` , :func:`~re.findall` , :func:`~re.sub`, y " -"así sucesivamente. Estas funciones toman los mismos argumentos que el método " -"de patrón correspondiente con la cadena RE agregada como primer argumento, y " -"aún así devuelven una instancia de ``None`` o :ref:`match object `. ::" #: ../Doc/howto/regex.rst:510 @@ -1118,10 +1121,10 @@ msgid "" "cache, so future calls using the same RE won't need to parse the pattern " "again and again." msgstr "" -"Bajo el capó, estas funciones simplemente crean un objeto patrón para usted " -"y llaman al método apropiado en él. También almacenan el objeto compilado en " -"una caché, por lo que las futuras llamadas que usen el mismo RE no " -"necesitarán analizar el patrón una y otra vez." +"Bajo el capó (*hood*), estas funciones simplemente crean un objeto patrón " +"para usted y llaman al método apropiado en él. También almacenan el objeto " +"compilado en un caché, por lo que las futuras llamadas que usen el mismo RE " +"no necesitarán analizar el patrón una y otra vez." #: ../Doc/howto/regex.rst:515 msgid "" @@ -1151,13 +1154,12 @@ msgid "" "them; ``re.I | re.M`` sets both the :const:`I` and :const:`M` flags, for " "example." msgstr "" -"Lo flags de compilación le permiten modificar algunos aspectos de cómo " -"funcionan las expresiones regulares. Las banderas están disponibles en el " +"Las flags de compilación le permiten modificar algunos aspectos de cómo " +"funcionan las expresiones regulares. Las flags están disponibles en el " "módulo :mod:`re` con dos nombres, un nombre largo como :const:`IGNORECASE` y " "una forma corta de una letra como :const:`I`. (Si está familiarizado con los " "modificadores de patrones de Perl, las formas de una letra usan las mismas " -"letras; la forma corta de :const:`re.VERBOSE` es :const:`re.X`, por " -"ejemplo). \n" +"letras; la forma corta de :const:`re.VERBOSE` es :const:`re.X`, por ejemplo)." "Se pueden especificar varios indicadores colocándolos en *OR-ing* bit a bit; " "``re.I | re.M`` establece los flags :const:`I` and :const:`M`, por ejemplo." @@ -1166,8 +1168,8 @@ msgid "" "Here's a table of the available flags, followed by a more detailed " "explanation of each one." msgstr "" -"Aquí hay una tabla de las banderas disponibles, seguida de una explicación " -"más detallada de cada una." +"Aquí hay una tabla de las flags disponibles, seguida de una explicación más " +"detallada de cada una." #: ../Doc/howto/regex.rst:537 msgid "Flag" @@ -1196,7 +1198,7 @@ msgstr ":const:`DOTALL`, :const:`S`" #: ../Doc/howto/regex.rst:543 msgid "Make ``.`` match any character, including newlines." msgstr "" -"Hace que ``.`` Coincida con cualquier caracter, incluidas las nuevas líneas." +"Hace que ``.`` coincida con cualquier caracter, incluidas las nuevas líneas." #: ../Doc/howto/regex.rst:546 msgid ":const:`IGNORECASE`, :const:`I`" @@ -1224,7 +1226,7 @@ msgstr "Coincidencia de varias líneas, que afecta a ``^`` y ``$``." #: ../Doc/howto/regex.rst:553 msgid ":const:`VERBOSE`, :const:`X` (for 'extended')" -msgstr ":const:`VERBOSE`, :const:`X` (for ‘extended’)m" +msgstr ":const:`VERBOSE`, :const:`X` (for 'extended')" #: ../Doc/howto/regex.rst:553 msgid "" @@ -1250,18 +1252,19 @@ msgid "" msgstr "" "Realiza una coincidencia que no distinga entre mayúsculas y minúsculas; la " "clase de caracteres y las cadenas de caracteres literales coincidirán con " -"las letras ignorando el caso. Por ejemplo, ``[A-Z]`` también coincidirá con " -"letras minúsculas. La coincidencia completa de Unicode también funciona a " -"menos que se utilice la flag :const:`ASCII` para deshabilitar las " -"coincidencias que no sean ASCII. Cuando los patrones Unicode ``[a-z]`` o " -"``[A-Z]`` se utilizan 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 un punto arriba), ‘ı’ (U+0131, letra " -"minúscula latina sin punto i),’ſ’ (U+017F, letra minúscula latina larga s) y " -"‘K’ (U+212A, signo de *Kelvin*). ``Spam`` coincidirá ``’Spam’``, ``’spam’``, " -"``’spAM’``, o ``’ſpam’`` (este último solo coincide en modo Unicode). Esta " -"minúscula no tiene en cuenta la configuración regional actual; lo hará si " -"también establece la flag :const:`LOCALE`." +"las letras ignorando las mayúsculas. Por ejemplo, ``[A-Z]`` también " +"coincidirá con letras minúsculas. La coincidencia completa de Unicode " +"también funciona a menos que se utilice la flag :const:`ASCII` para " +"deshabilitar las coincidencias que no sean ASCII. Cuando los patrones " +"Unicode ``[a-z]`` o ``[A-Z]`` se utilizan 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 un punto " +"arriba), 'ı' (U+0131, letra minúscula latina sin punto i),'ſ' (U+017F, letra " +"minúscula latina larga s) y 'K' (U+212A, signo de *Kelvin*). ``Spam`` " +"coincidirá ``'Spam'``, ``'spam'``, ``'spAM'``, o ``'ſpam'`` (este último " +"solo coincide en modo Unicode). Estas minúsculas no tiene en cuenta la " +"configuración regional actual; lo hará si también establece la flag :const:" +"`LOCALE`." #: ../Doc/howto/regex.rst:580 msgid "" @@ -1302,8 +1305,8 @@ msgstr "" "indicador :const:`LOCALE` al compilar una expresión regular hará que el " "objeto compilado resultante use estas funciones C para ``\\w``; esto es más " "lento, pero también permite que ``\\w+`` coincida con las palabras en " -"francés como era de esperar. Se desaconseja el uso de esta bandera en Python " -"3 ya que el mecanismo de configuración regional es muy poco confiable, solo " +"francés como era de esperar. Se desaconseja el uso de esta flag en Python 3 " +"ya que el mecanismo de configuración regional es muy poco confiable, solo " "maneja una “cultura” a la vez y solo funciona con configuraciones regionales " "de 8 bits. La coincidencia Unicode ya está habilitada de forma " "predeterminada en Python 3 para patrones Unicode (str), y puede manejar " @@ -1327,23 +1330,23 @@ msgid "" "matches either at the end of the string and at the end of each line " "(immediately preceding each newline)." msgstr "" -"Por lo general, ``^`` coincide solo al principio de la cadena, y ``$`` solo " -"coincide con el final de la cadena de caracteres e inmediatamente antes del " -"salto de línea (si existe) al final de la cadena de caracteres. Cuando se " -"especifica esta bandera, ``^`` coincide al principio de la cadena y al " -"comienzo de cada línea dentro de la cadena, inmediatamente después de cada " -"nueva línea. De manera similar, el metacaracter ``$`` coincide al final de " -"la cadena de caracteres y al final de cada línea (inmediatamente antes de " -"cada nueva línea)." +"Por lo general, ``^`` coincide solo al principio de la cadena de caracteres, " +"y ``$`` solo coincide con el final de la cadena de caracteres e " +"inmediatamente antes del salto de línea (si existe) al final de la cadena de " +"caracteres. Cuando se especifica esta bandera, ``^`` coincide al principio " +"de la cadena y al comienzo de cada línea dentro de la cadena, inmediatamente " +"después de cada nueva línea. De manera similar, el metacarácter ``$`` " +"coincide al final de la cadena de caracteres y al final de cada línea " +"(inmediatamente antes de cada nueva línea)." #: ../Doc/howto/regex.rst:621 msgid "" "Makes the ``'.'`` special character match any character at all, including a " "newline; without this flag, ``'.'`` will match anything *except* a newline." msgstr "" -"Hace que el caracter especial ``'.'`` coincida con cualquier carácter, " +"Hace que el carácter especial ``'.'`` coincida con cualquier carácter, " "incluida una nueva línea; sin esta bandera, ``'.'`` coincidirá con cualquier " -"cosa *excepto* una nueva línea." +"cosa *except* una nueva línea." #: ../Doc/howto/regex.rst:629 msgid "" @@ -1374,7 +1377,7 @@ msgstr "" "una clase de caracteres o está precedido por una barra invertida sin escape; " "esto le permite organizar e indentar la RE más claramente. Esta flag también " "le permite poner comentarios dentro de una RE que serán ignorados por el " -"motor (*engine*); los comentarios están marcados con un ``’#’`` que no está " +"motor (*engine*); los comentarios están marcados con un ``'#'`` que no está " "en una clase de carácter ni está precedido por una barra invertida sin " "escape." @@ -1388,7 +1391,7 @@ msgstr "" #: ../Doc/howto/regex.rst:660 msgid "Without the verbose setting, the RE would look like this::" -msgstr "Sin la configuración detallada, el RE se vería así::" +msgstr "Sin la configuración detallada, la RE se vería así::" #: ../Doc/howto/regex.rst:666 msgid "" @@ -1396,9 +1399,10 @@ msgid "" "has been used to break up the RE into smaller pieces, but it's still more " "difficult to understand than the version using :const:`re.VERBOSE`." msgstr "" -"En el ejemplo anterior, la concatenación automática de cadenas literales de " -"Python se ha utilizado para dividir el RE en partes más pequeñas, pero aún " -"es más difícil de entender que la versión que usa :const:`re.VERBOSE`." +"En el ejemplo anterior, la concatenación automática de cadenas de caracteres " +"literales de Python se ha utilizado para dividir la RE en partes más " +"pequeñas, pero aún es más difícil de entender que la versión que usa :const:" +"`re.VERBOSE`." #: ../Doc/howto/regex.rst:672 msgid "More Pattern Power" @@ -1411,19 +1415,19 @@ msgid "" "retrieve portions of the text that was matched." msgstr "" "Hasta ahora solo hemos cubierto una parte de las características de las " -"expresiones regulares. En esta sección, cubriremos algunos metacaracteres " +"expresiones regulares. En esta sección, cubriremos algunos metacarácteres " "nuevos y cómo usar grupos para recuperar partes del texto que coincidió." #: ../Doc/howto/regex.rst:682 msgid "More Metacharacters" -msgstr "Más metacaracteres" +msgstr "Más metacarácteres" #: ../Doc/howto/regex.rst:684 msgid "" "There are some metacharacters that we haven't covered yet. Most of them " "will be covered in this section." msgstr "" -"Hay algunos metacaracteres que aún no hemos cubierto. La mayoría de ellos se " +"Hay algunos metacarácteres que aún no hemos cubierto. La mayoría de ellos se " "tratarán en esta sección." #: ../Doc/howto/regex.rst:687 @@ -1437,14 +1441,14 @@ msgid "" "once at a given location, they can obviously be matched an infinite number " "of times." msgstr "" -"Algunos de los metacaracteres restantes que se discutirán son :dfn:`zero-" -"width assertions`. No hacen que el motor avance a través de la cuerda; en " -"cambio, no consumen caracteres en absoluto y simplemente tienen éxito o " -"fracasan. Por ejemplo, ``\\b`` es una afirmación de que la posición actual " -"se encuentra en el límite de una palabra; la posición no cambia por la ``" -"\\b`` en absoluto. Esto significa que las aserciones de ancho cero nunca " -"deben repetirse, porque si coinciden una vez en una ubicación determinada, " -"obviamente pueden coincidir un número infinito de veces." +"Algunos de los metacarácteres restantes que se discutirán son :dfn:`zero-" +"width assertions`. No hacen que el motor avance a través de la cadena de " +"caracteres; en cambio, no consumen caracteres en absoluto y simplemente " +"tienen éxito o fracasan. Por ejemplo, ``\\b`` es una flag de que la posición " +"actual se encuentra en el límite de una palabra; la posición no cambia por " +"la ``\\b`` en absoluto. Esto significa que las aserciones de ancho cero " +"nunca deben repetirse, porque si coinciden una vez en una ubicación " +"determinada, obviamente pueden coincidir un número infinito de veces." #: ../Doc/howto/regex.rst:703 msgid "``|``" @@ -1463,16 +1467,16 @@ msgstr "" "B`` coincidirá con cualquier cadena de caracteres que coincida con *A* o " "*B*. ``|`` tiene una precedencia muy baja para que funcione razonablemente " "cuando está alternando cadenas de varios caracteres. ``Crow|Servo`` " -"coincidirá con `’Crow’`` o ``’Servo’``, no ``’Cro’``, un ``’w’`` o un " -"``’S’``, y ``’ervo’``." +"coincidirá con `'Crow'`` o ``'Servo'``, no ``'Cro'``, un ``'w'`` o un " +"``'S'``, y ``'ervo'``." #: ../Doc/howto/regex.rst:702 msgid "" "To match a literal ``'|'``, use ``\\|``, or enclose it inside a character " "class, as in ``[|]``." msgstr "" -"Para hacer coincidir un literal `` '|' ``, use `` \\|``, o enciérrelo dentro " -"de una clase de carácter, como en ``[|]``." +"Para hacer coincidir un literal ``'|'``, use ``\\|``, o enciérrelo dentro de " +"una clase de carácter, como en ``[|]``." #: ../Doc/howto/regex.rst:718 msgid "``^``" @@ -1500,7 +1504,7 @@ msgstr "" #: ../Doc/howto/regex.rst:718 msgid "To match a literal ``'^'``, use ``\\^``." -msgstr "Para una coincidencia literal ``’^’``, usar ``\\^``." +msgstr "Para una coincidencia literal ``'^'``, usar ``\\^``." #: ../Doc/howto/regex.rst:732 msgid "``$``" @@ -1509,7 +1513,7 @@ msgstr "``$``" #: ../Doc/howto/regex.rst:721 msgid "" "Matches at the end of a line, which is defined as either the end of the " -"string, or any location followed by a newline character. ::" +"string, or any location followed by a newline character. ::" msgstr "" "Coincide con el final de una línea, que se define como el final de la cadena " "o cualquier ubicación seguida de un carácter de nueva línea. ::" @@ -1519,7 +1523,7 @@ msgid "" "To match a literal ``'$'``, use ``\\$`` or enclose it inside a character " "class, as in ``[$]``." msgstr "" -"Para hacer coincidir un literal ``’$’``, usar ``\\$`` o enciérrelo dentro de " +"Para hacer coincidir un literal ``'$'``, usar ``\\$`` o enciérrelo dentro de " "una clase de carácter, como en ``[$]``." #: ../Doc/howto/regex.rst:738 @@ -1588,10 +1592,10 @@ msgstr "" "de Python y las secuencias de expresiones regulares. En las cadenas de " "caracteres literales de Python, ``\\b`` es el carácter de retroceso " "(*backspace*), valor ASCII 8. Si no está utilizando cadenas de caracteres " -"sin procesar, Python convertirá la ``\\b`` en un retroceso, y su RE no lo " -"hará coincidir como lo espera. El siguiente ejemplo tiene el mismo aspecto " -"que nuestra RE anterior, pero omite la ``’r’`` delante de la cadena de " -"caracteres de RE. ::" +"sin procesar, Python convertirá la ``\\b`` en una linea de retroceso, y su " +"RE no lo hará coincidir como lo espera. El siguiente ejemplo tiene el mismo " +"aspecto que nuestra RE anterior, pero omite la ``'r'`` delante de la cadena " +"de caracteres de RE. ::" #: ../Doc/howto/regex.rst:774 msgid "" @@ -1612,8 +1616,8 @@ msgid "" "Another zero-width assertion, this is the opposite of ``\\b``, only matching " "when the current position is not at a word boundary." msgstr "" -"Otra afirmación de ancho cero, esto es lo opuesto a ``\\b``, solo coincide " -"cuando la posición actual no está en el límite de una palabra." +"Otra flag de ancho cero, esto es lo opuesto a ``\\b``, solo coincide cuando " +"la posición actual no está en el límite de una palabra." #: ../Doc/howto/regex.rst:784 msgid "Grouping" @@ -1632,7 +1636,7 @@ msgstr "" "cadenas de caracteres escribiendo una RE dividido en varios subgrupos que " "coinciden con diferentes componentes de interés. Por ejemplo, una línea de " "encabezado RFC-822 se divide en un nombre de encabezado y un valor, " -"separados por un ``’:’``, así:" +"separados por un ``':'``, así:" #: ../Doc/howto/regex.rst:799 msgid "" @@ -1653,8 +1657,8 @@ msgid "" "+``, ``?``, or ``{m,n}``. For example, ``(ab)*`` will match zero or more " "repetitions of ``ab``. ::" msgstr "" -"Los grupos están marcados por los ``’(‘``, ``’)’`` metacaracteres. ``’(‘`` y " -"``’)’`` tienen el mismo significado que en las expresiones matemáticas; " +"Los grupos están marcados por los ``'('``, ``')'`` metacarácteres. ``'('`` y " +"``')'`` tienen el mismo significado que en las expresiones matemáticas; " "agrupan las expresiones contenidas en ellos, y puedes repetir el contenido " "de un grupo con un calificador repetitivo, como ``*``, ``+``, ``?``, o ``{m," "n}``. Por ejemplo, ``(ab)*`` coincidirá con cero o más repeticiones de " @@ -1697,7 +1701,7 @@ msgid "" "those groups. ::" msgstr "" ":meth:`~re.Match.group` se pueden pasar varios números de grupo a la vez, en " -"cuyo caso devolverá una tupla que contiene los valores correspondientes para " +"cuyo caso retornará una tupla que contiene los valores correspondientes para " "esos grupos. ::" #: ../Doc/howto/regex.rst:849 @@ -1705,8 +1709,9 @@ msgid "" "The :meth:`~re.Match.groups` method returns a tuple containing the strings " "for all the subgroups, from 1 up to however many there are. ::" msgstr "" -"El método :meth:`~ re.Match.groups` retorna una tupla que contiene las " -"cadenas de todos los subgrupos, desde 1 hasta la cantidad que haya. ::" +"El método :meth:`~re.Match.groups` retorna una tupla que contiene las " +"cadenas de caracteres de todos los subgrupos, desde 1 hasta la cantidad que " +"haya. ::" #: ../Doc/howto/regex.rst:855 msgid "" @@ -1743,7 +1748,7 @@ msgstr "" "Las referencias inversas como esta no suelen ser útiles para buscar a través " "de una cadena --- hay pocos formatos de texto que repiten datos de esta " "manera --- pero pronto descubrirá que son *muy* útiles al realizar " -"sustituciones de cadenas ." +"sustituciones de cadenas de caracteres." #: ../Doc/howto/regex.rst:875 msgid "Non-capturing and Named Groups" @@ -1776,7 +1781,7 @@ msgid "" msgstr "" "Perl 5 es bien conocido por sus poderosas adiciones a las expresiones " "regulares estándar. Para estas nuevas características, los desarrolladores " -"de Perl no podían elegir nuevos metacaracteres de una sola pulsación de " +"de Perl no podían elegir nuevos metacarácteres de una sola pulsación de " "tecla o nuevas secuencias especiales que comienzan con ``\\`` sin hacer que " "las expresiones regulares de Perl sean confusamente diferentes de las RE " "estándar. Si eligieran ``&`` como un nuevo metacarácter, por ejemplo, las " @@ -1798,8 +1803,8 @@ msgstr "" "había un error de sintaxis porque el ``?`` no tendría nada que repetir, por " "lo que esto no introdujo ningún problema de compatibilidad. Los caracteres " "inmediatamente después de ``?`` Indican qué extensión se está utilizando, " -"por lo que ``(?=foo)`` es una cosa (una afirmación de anticipación positiva) " -"y ``(?:foo)`` es otra cosa (un grupo de no captura que contiene la " +"por lo que ``(?=foo)`` es una cosa (una flag de anticipación positiva) y " +"``(?:foo)`` es otra cosa (un grupo de no captura que contiene la " "subexpresión ``foo``)." #: ../Doc/howto/regex.rst:898 @@ -1908,7 +1913,7 @@ msgid "" "It's obviously much easier to retrieve ``m.group('zonem')``, instead of " "having to remember to retrieve group 9." msgstr "" -"Obviamente, es mucho más fácil recuperar ``m.group(‘zonem’)``, en lugar de " +"Obviamente, es mucho más fácil recuperar ``m.group('zonem')``, en lugar de " "tener que recordar recuperar el grupo 9." #: ../Doc/howto/regex.rst:966 @@ -1945,7 +1950,7 @@ msgstr "" #: ../Doc/howto/regex.rst:989 msgid "``(?=...)``" -msgstr "``(?=…)``" +msgstr "``(?=...)``" #: ../Doc/howto/regex.rst:985 msgid "" @@ -1971,8 +1976,8 @@ msgid "" "assertion; it succeeds if the contained expression *doesn't* match at the " "current position in the string." msgstr "" -"Aserción de anticipación negativa. Esto es lo opuesto a la afirmación " -"positiva; tiene éxito si la expresión contenida *no* coincide con la " +"Aserción de anticipación negativa. Esto es lo opuesto a la flag positiva; " +"tiene éxito si la expresión contenida *no* (*doesn't*) coincide con la " "posición actual en la cadena." #: ../Doc/howto/regex.rst:996 @@ -2006,7 +2011,7 @@ msgid "" "``printers.conf``." msgstr "" "Tenga en cuenta que el ``.`` Debe tratarse especialmente porque es un " -"metacaracter, por lo que está dentro de una clase de carácter para coincidir " +"metacarácter, por lo que está dentro de una clase de carácter para coincidir " "solo con ese carácter específico. También observe el final ``$``; esto se " "agrega para garantizar que todo el resto de la cadena deba incluirse en la " "extensión. Esta expresión regular coincide con ``foo.bar`` y ``autoexec." @@ -2130,7 +2135,7 @@ msgstr "" #: ../Doc/howto/regex.rst:1066 msgid "``split()``" -msgstr "``split()`" +msgstr "``split()``" #: ../Doc/howto/regex.rst:1066 msgid "Split the string into a list, splitting it wherever the RE matches" @@ -2175,13 +2180,13 @@ msgid "" "splitting by whitespace or by a fixed string. As you'd expect, there's a " "module-level :func:`re.split` function, too." msgstr "" -"El método :meth:`~re.Pattern.split` de un patrón divide una cadena donde la " -"RE coincide, devolviendo una lista de las piezas. Es similar al método de " -"cadenas de caracteres :meth:`~str.split` pero proporciona mucha más " -"generalidad en los delimitadores por los que puede dividir; cadena de " -"caracteres :meth:`!split` solo admite la división por espacios en blanco o " -"por una cadena fija. Como era de esperar, también hay una función a nivel de " -"módulo :func:`re.split`." +"El método :meth:`~re.Pattern.split` de un patrón que divide una cadena de " +"caracteres donde la RE coincide, retornando una lista de las piezas. Es " +"similar al método de cadenas de caracteres :meth:`~str.split` pero " +"proporciona mucha más generalidad en los delimitadores por los que puede " +"dividir; cadena de caracteres :meth:`!split` solo admite la división por " +"espacios en blanco o por una cadena fija. Como era de esperar, también hay " +"una función a nivel de módulo :func:`re.split`." #: ../Doc/howto/regex.rst:1092 msgid "" @@ -2191,9 +2196,9 @@ msgid "" "splits are performed." msgstr "" "Dividir *string* por las coincidencias de la expresión regular. Si se " -"utilizan paréntesis de captura en la RE, su contenido también se devolverá " +"utilizan paréntesis de captura en la RE, su contenido también se retornará " "como parte de la lista resultante. Si *maxsplit* es distinto de cero, se " -"realizan como máximo *maxsplit* splits." +"realizan como máximo divisiones *maxsplit* ." #: ../Doc/howto/regex.rst:1097 msgid "" @@ -2252,7 +2257,7 @@ msgid "" "pattern isn't found, *string* is returned unchanged." msgstr "" "Retorna la cadena de caracteres obtenida al reemplazar las apariciones no " -"superpuestas del extremo izquierdo de la RE en *string* por el reemplazo " +"superpuestas del extremo izquierdo de la RE en *string* por el remplazo " "*replacement*. Si no se encuentra el patrón, el *string* se retorna sin " "cambios." @@ -2280,7 +2285,7 @@ msgid "" "tuple containing the new string value and the number of replacements that " "were performed::" msgstr "" -"El método :meth:`~re.Pattern.subn` hace el mismo trabajo, pero devuelve una " +"El método :meth:`~re.Pattern.subn` hace el mismo trabajo, pero retorna una " "tupla de 2 que contiene el nuevo valor de cadena de caracteres y el número " "de reemplazos que se realizaron::" @@ -2304,11 +2309,11 @@ msgid "" msgstr "" "Si *replacement* es una cadena, se procesan los escapes de barra invertida " "que contenga. Es decir, ``\\n`` se convierte en un solo carácter de nueva " -"línea, ``\\r`` se convierte en un retorno de carro, y así sucesivamente. Los " -"escapes desconocidos como ``\\&`` se dejan en paz. Las referencias inversas, " -"como ``\\6``, se reemplazan con la subcadena de caracteres que coincide con " -"el grupo correspondiente a la RE. Esto le permite incorporar partes del " -"texto original en la cadena de reemplazo resultante." +"línea, ``\\r`` se convierte en una REtorno de carro, y así sucesivamente. " +"Los escapes desconocidos como ``\\&`` se dejan en paz. Las referencias " +"inversas, como ``\\6``, se reemplazan con la subcadena de caracteres que " +"coincide con el grupo correspondiente a la RE. Esto le permite incorporar " +"partes del texto original en la cadena de reemplazo resultante." #: ../Doc/howto/regex.rst:1182 msgid "" @@ -2335,7 +2340,7 @@ msgstr "" "\\g`` usa el número de grupo correspondiente. ``\\g<2>`` es " "equivalente a ``\\2``, pero no es ambiguo en una cadena de reemplazo como ``" "\\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’``.) Las " +"como una referencia al grupo 2 seguido del carácter literal ``'0'``.) Las " "siguientes sustituciones son todas equivalentes, pero use las tres " "variaciones de la cadena de reemplazo. ::" @@ -2352,7 +2357,7 @@ msgstr "" "ocurrencia no superpuesta de *pattern*. En cada llamada, a la función se le " "pasa un argumento :ref:`match object ` para la coincidencia y " "puede usar esta información para calcular la cadena de reemplazo deseada y " -"devolverla." +"retornarla." #: ../Doc/howto/regex.rst:1212 msgid "" @@ -2371,12 +2376,12 @@ msgid "" "pattern string, e.g. ``sub(\"(?i)b+\", \"x\", \"bbbb BBBB\")`` returns ``'x " "x'``." msgstr "" -"Cuando se usa la función module-level :func:`re.sub`, el patrón se pasa como " -"primer argumento. El patrón puede proporcionarse como un objeto o como una " -"cuerda; Si necesita especificar marcas de expresión regular, debe usar un " -"objeto de patrón como primer parámetro o usar modificadores incrustados en " -"la cadena de patrón, por ejemplo ``sub(“(?i)b+”, “x”, “bbbb BBBB”)`` returns " -"``’x x’``." +"Cuando se usa la función *module-level* :func:`re.sub`, el patrón se pasa " +"como primer argumento. El patrón puede proporcionarse como un objeto o como " +"una cuerda; Si necesita especificar marcas de expresión regular, debe usar " +"un objeto de patrón como primer parámetro o usar modificadores incrustados " +"en la cadena de patrón, por ejemplo ``sub(\"(?i)b+\", \"x\", \"bbbb BBBB" +"\")`` retorna ``'x x'``." #: ../Doc/howto/regex.rst:1232 msgid "Common Problems" @@ -2432,14 +2437,14 @@ msgid "" "meth:`!replace`'s abilities.)" msgstr "" "Un ejemplo podría ser reemplazar una sola cadena fija por otra; por ejemplo, " -"puede reemplazar `` palabra ‘’ por `` escritura ‘’. : func: `re.sub` parece " -"la función a utilizar para esto, pero considere el método :meth:`~str." -"replace`. Tenga en cuenta que :meth:`!replace` también reemplazará` `word ‘’ " -"dentro de las palabras, convirtiendo ``swordfish`` en ``sdeedfish``, pero la " -"ingenua RE ``word`` también lo habría hecho. (Para evitar realizar la " -"sustitución en partes de palabras, el patrón tendría que ser ``\\bword\\b``, " -"para requerir que `` palabra ‘’ tenga un límite de palabra en cada lado. " -"Esto lleva el trabajo más allá de las habilidades de :meth:`!replace`.)" +"puede reemplazar ``word`` por ``deed``. :func:`re.sub` parece la función a " +"utilizar para esto, pero considere el método :meth:`~str.replace`. Tenga en " +"cuenta que :meth:`!replace` también reemplazará ``word`` dentro de las " +"palabras, convirtiendo ``swordfish`` en ``sdeedfish``, pero la RE naíf " +"``word`` también lo habría hecho. (Para evitar realizar la sustitución en " +"partes de palabras, el patrón tendría que ser ``\\bword\\b``, para requerir " +"que ``word`` tenga un límite de palabra en cada lado. Esto lleva el trabajo " +"más allá de las habilidades de :meth:`!replace`.)" #: ../Doc/howto/regex.rst:1259 msgid "" @@ -2451,7 +2456,7 @@ msgid "" msgstr "" "Otra tarea común es eliminar cada aparición de un solo carácter de una " "cadena o reemplazarlo con otro solo carácter. Puede hacer esto con algo como " -"``re.sub(‘\\n’, ‘ ‘, S)``, pero :meth:`~str.translate` es capaz de realizar " +"``re.sub('\\n', ' ', S)``, pero :meth:`~str.translate` es capaz de realizar " "ambas tareas y será más rápido que cualquier expresión regular la operación " "puede ser." @@ -2476,7 +2481,7 @@ msgid "" "start at 0; if the match wouldn't start at zero, :func:`!match` will *not* " "report it. ::" msgstr "" -"La función :func:`~re.match` solo verifica si el RE coincide con el comienzo " +"La función :func:`~re.match` solo verifica si la RE coincide con el comienzo " "de la cadena de caracteres, mientras que :func:`~re.search` buscará una " "coincidencia en la cadena de caracteres. Es importante tener en cuenta esta " "distinción. Recuerde :func:`!match` solo informará una coincidencia exitosa " @@ -2505,12 +2510,12 @@ msgstr "" "A veces, tendrá la tentación de seguir usando :func:`re.match`, y " "simplemente agregar ``.*`` al frente de su RE. Resista esta tentación y use :" "func:`re.search` en su lugar. El compilador de expresiones regulares realiza " -"un análisis de los RE para acelerar el proceso de búsqueda de coincidencias. " +"un análisis de las RE para acelerar el proceso de búsqueda de coincidencias. " "Uno de esos análisis determina cuál debe ser el primer carácter de una " "coincidencia; por ejemplo, un patrón que comienza con ``Crow`` debe " -"coincidir con una ``’C’``.El análisis permite que el motor escanee " +"coincidir con una ``'C'``.El análisis permite que el motor escanee " "rápidamente a través de la cadena en busca del carácter inicial, solo " -"probando la coincidencia completa si se encuentra una ``’C’``." +"probando la coincidencia completa si se encuentra una ``'C'``." #: ../Doc/howto/regex.rst:1300 msgid "" @@ -2520,7 +2525,7 @@ msgid "" msgstr "" "Agregar ``.*`` anula esta optimización, lo que requiere escanear hasta el " "final de la cadena y luego retroceder para encontrar una coincidencia para " -"el resto del RE. Utilice :func:`re.search` en su lugar." +"el resto de la RE. Utilice :func:`re.search` en su lugar." #: ../Doc/howto/regex.rst:1306 msgid "Greedy versus Non-Greedy" @@ -2550,12 +2555,12 @@ msgid "" "The final match extends from the ``'<'`` in ``''`` to the ``'>'`` in " "``''``, which isn't what you want." msgstr "" -"La RE coincide con el ``’<‘`` en ``’’``, y el ``.*`` consume el resto " +"La RE coincide con el ``'<'`` en ``''``, y el ``.*`` consume el resto " "de la cadena de caracteres. Sin embargo, aún queda más en la RE y el ``>`` " "no puede coincidir al final de la cadena de caracteres, por lo que el motor " -"de expresión regular tiene que retroceder caracter por caracter hasta que " +"de la expresión regular tiene que retroceder carácter por carácter hasta que " "encuentre una coincidencia para el “. La coincidencia final se extiende " -"desde el `’<‘`` en ``’’`` al ``’>’`` en ``’’``, que no es lo " +"desde el `'<'`` en ``''`` al ``'>'`` en ``''``, que no es lo " "que queremos." #: ../Doc/howto/regex.rst:1329 @@ -2568,9 +2573,9 @@ msgid "" msgstr "" "En este caso, la solución es utilizar los calificadores no codiciosos ``*?" "``, ``+?``, ``??``, o ``{m,n}?``, Que coinciden como *poco* texto como sea " -"posible. En el ejemplo anterior, el ``’>’`` se prueba inmediatamente después " -"de las primeras coincidencias ``’<‘``, y cuando falla, el motor avanza un " -"carácter a la vez, volviendo a intentar el ``’>’`` en cada paso. Esto " +"posible. En el ejemplo anterior, el ``'>'`` se prueba inmediatamente después " +"de las primeras coincidencias ``'<'``, y cuando falla, el motor avanza un " +"carácter a la vez, volviendo a intentar el ``'>'`` en cada paso. Esto " "produce el resultado correcto:" #: ../Doc/howto/regex.rst:1338 @@ -2600,10 +2605,10 @@ msgid "" "become lengthy collections of backslashes, parentheses, and metacharacters, " "making them difficult to read and understand." msgstr "" -"Probablemente ya hayas notado que las expresiones regulares son una notación " -"muy compacta, pero no son muy legibles. Los RE de complejidad moderada " +"Probablemente ya haya notado que las expresiones regulares son una notación " +"muy compacta, pero no son muy legibles. Las RE de complejidad moderada " "pueden convertirse en largas colecciones de barras invertidas, paréntesis y " -"metacaracteres, lo que dificulta su lectura y comprensión." +"metacarácteres, lo que dificulta su lectura y comprensión." #: ../Doc/howto/regex.rst:1353 msgid "" @@ -2625,15 +2630,15 @@ msgid "" "extend from a ``#`` character to the next newline. When used with triple-" "quoted strings, this enables REs to be formatted more neatly::" msgstr "" -"La `` re.VERBOSE ‘’ tiene varios efectos. Los espacios en blanco en la " -"expresión regular que * no están * dentro de una clase de caracteres se " -"ignoran. Esto significa que una expresión como `` perro | gato ‘’ es " -"equivalente al menos legible `` perro | gato ‘’, pero `` [a b] ‘’ seguirá " -"coincidiendo con los caracteres `` ‘a’``, ``’ b’`` o un espacio. Además, " -"también puede poner comentarios dentro de un RE; los comentarios se " -"extienden desde un carácter `` # ‘’ hasta la siguiente línea nueva. Cuando " -"se usa con cadenas entre comillas triples, esto permite que los REs sean " -"formateados de manera más ordenada:" +"La flag ``re.VERBOSE`` tiene varios efectos. Los espacios en blanco en la " +"expresión regular que *no están* dentro de una clase de caracteres se " +"ignoran. Esto significa que una expresión como ``dog | cat`` es equivalente " +"al menos legible ``dog | cat``, pero ``[a b]`` seguirá coincidiendo con los " +"caracteres ``'a'``, ``'b'`` o un espacio. Además, también puede poner " +"comentarios dentro de una RE; los comentarios se extienden desde un carácter " +"``#`` hasta la siguiente línea nueva. Cuando se usa con cadenas entre " +"comillas triples, esto permite que las REs sean formateados de manera más " +"ordenada:" #: ../Doc/howto/regex.rst:1374 msgid "This is far more readable than::" @@ -2652,7 +2657,7 @@ msgid "" "improvements to the author." msgstr "" "Las expresiones regulares son un tema complicado. ¿Le ayudó este documento a " -"comprenderlos? ¿Hubo partes que no estaban claras o problemas que encontró " +"comprenderlas? ¿Hubo partes que no estaban claras o problemas que encontró " "que no se trataron aquí? Si es así, envíe sugerencias de mejora al autor." #: ../Doc/howto/regex.rst:1387 @@ -2666,7 +2671,7 @@ msgid "" "you much.) Consider checking it out from your library." msgstr "" "El libro más completo sobre expresiones regulares es casi con certeza " -"*Mastering Regular Expressions de Jeffrey Friedl*, publicado por *O’Reilly*. " +"*Mastering Regular Expressions de Jeffrey Friedl*, publicado por *O'Reilly*. " "Desafortunadamente, se concentra exclusivamente en los tipos de expresiones " "regulares de Perl y Java, y no contiene ningún material de Python, por lo " "que no será útil como referencia para la programación en Python. (La primera " From 4d574eb9d58cf4b271fa0ca830a7c2bfd148368a Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Contreras <32220621+mjmolina@users.noreply.github.com> Date: Thu, 29 Oct 2020 20:01:06 +0100 Subject: [PATCH 3/9] Update dictionaries/howto_regex.txt --- dictionaries/howto_regex.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/dictionaries/howto_regex.txt b/dictionaries/howto_regex.txt index 4d93fac625..b458f08686 100644 --- a/dictionaries/howto_regex.txt +++ b/dictionaries/howto_regex.txt @@ -8,9 +8,8 @@ subexpresión subgrupos anidarlo hexadecimales -colocándolos colocándolas reemplácelas comprenderlas precediéndolos -precederlos \ No newline at end of file +precederlos From 584a381218985a38c043e9ef98f494f0fbb6f743 Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Thu, 29 Oct 2020 22:50:20 +0100 Subject: [PATCH 4/9] cambiando algunas palabras --- howto/regex.po | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/howto/regex.po b/howto/regex.po index 615a4ddef6..0d5da66783 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -357,7 +357,7 @@ msgid "" "``[^a-zA-Z0-9_]``." msgstr "" "Coincide con cualquier carácter no alfanumérico; esto es equivalente a la " -"clase``[^a-zA-Z0-9_]``." +"clase ``[^a-zA-Z0-9_]``." #: ../Doc/howto/regex.rst:152 msgid "" @@ -689,7 +689,7 @@ msgstr "" "expresarlas. (Hay aplicaciones que no necesitan RE en absoluto, por lo que " "no hay necesidad de aumentar la especificación del lenguaje incluyéndolas). " "En cambio, el módulo :mod:`re` es simplemente un módulo de extensión C " -"incluido en Python, al igual que los módulos :mod:`socket` o :mod:zlib`." +"incluido en Python, al igual que los módulos :mod:`socket` o :mod:`zlib`." #: ../Doc/howto/regex.rst:289 msgid "" @@ -1490,9 +1490,9 @@ msgid "" "the string." msgstr "" "Coincide con el comienzo de las líneas. A menos que se haya establecido la " -"flag :const:`MULTILINE`, esto solo coincidirá al principio de la cadena de " -"caracteres. En modo :const:`MULTILINE`, esto también coincide inmediatamente " -"después de cada nueva línea dentro de la cadena." +"flag :const:`MULTILINE` , esto solo coincidirá al principio de la cadena de " +"caracteres. En modo :const:`MULTILINE` , esto también coincide " +"inmediatamente después de cada nueva línea dentro de la cadena." #: ../Doc/howto/regex.rst:710 msgid "" @@ -1539,7 +1539,7 @@ msgid "" "newline character." msgstr "" "Coincide solo al comienzo de la cadena de caracteres. Cuando no está en el " -"modo :const:`MULTILINE`,``\\A`` y ``^``son efectivamente lo mismo. En el " +"modo :const:`MULTILINE`,``\\A`` y ``^`` son efectivamente lo mismo. En el " "modo :const:`MULTILINE`, son diferentes: ``\\ A`` todavía coincide solo al " "principio de la cadena, pero``^``puede coincidir en cualquier ubicación " "dentro de la cadena de caracteres que sigue a un carácter de nueva línea." From f366cd2c43de6ea9ae286eb6c5a40775a9ac19e9 Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Contreras <32220621+mjmolina@users.noreply.github.com> Date: Fri, 30 Oct 2020 19:46:53 +0100 Subject: [PATCH 5/9] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Cristián Maureira-Fredes --- dictionaries/howto_regex.txt | 1 + howto/regex.po | 78 +++++++++++++++++------------------- 2 files changed, 38 insertions(+), 41 deletions(-) diff --git a/dictionaries/howto_regex.txt b/dictionaries/howto_regex.txt index b458f08686..fab7bbe657 100644 --- a/dictionaries/howto_regex.txt +++ b/dictionaries/howto_regex.txt @@ -13,3 +13,4 @@ reemplácelas comprenderlas precediéndolos precederlos +TeX diff --git a/howto/regex.po b/howto/regex.po index 0d5da66783..e115719671 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -71,9 +71,9 @@ msgstr "" "mod:`re`. Usando este pequeño lenguaje, especificas las reglas para el " "conjunto de cadenas de caracteres posibles que deseas hacer coincidir; este " "conjunto puede contener frases en inglés, o direcciones de correo " -"electrónico, o comandos *TeX*, o cualquier cosa que desee. A continuación, " -"puede hacer preguntas como “¿Coincide esta cadena con el patrón?” O “¿Hay " -"alguna coincidencia con el patrón en alguna parte de esta cadena?”. También " +"electrónico, o comandos TeX, o cualquier cosa que desee. A continuación, " +"puede hacer preguntas como \"¿Coincide esta cadena con el patrón?\" o \"¿Hay " +"alguna coincidencia con el patrón en alguna parte de esta cadena?\". También " "puede utilizar RE para modificar una cadena de caracteres o dividirla de " "varias formas." @@ -224,7 +224,7 @@ msgstr "" "Puede hacer coincidir los caracteres que no figuran en la clase mediante el " "conjunto :dfn:`complementing`. Esto se indica mediante la inclusión de un " "``'^'`` como primer carácter de la clase. Por ejemplo, ``[^5]`` coincidirá " -"con cualquier carácter excepto con ``'5'``.Si el símbolo de intercalación " +"con cualquier carácter excepto con ``'5'``. Si el símbolo de intercalación " "aparece en otra parte de una clase de caracter, no tiene un significado " "especial. Por ejemplo: ``[5^] `` coincidirá con un ``'5'`` o un ``'^'``." @@ -379,11 +379,11 @@ msgstr "" "El metacarácter final en esta sección es ``.``. Coincide con cualquier cosa " "excepto un carácter de nueva línea, y hay un modo alternativo (:const:`re." "DOTALL`) donde coincidirá incluso con una nueva línea. ``.`` se usa a menudo " -"cuando se desea hacer coincidir “cualquier carácter”." +"cuando se desea hacer coincidir \"cualquier carácter\"." #: ../Doc/howto/regex.rst:163 msgid "Repeating Things" -msgstr "Repitiendo cosas (*Repeating Things*)" +msgstr "Repitiendo cosas" #: ../Doc/howto/regex.rst:165 msgid "" @@ -418,7 +418,7 @@ msgid "" "(1 ``'a'``), ``'caaat'`` (3 ``'a'`` characters), and so forth." msgstr "" "Por ejemplo, ``ca*t`` coincidirá con ``'ct'`` (0 ``'a'`` caracteres), " -"``'cat'`` (1 ``'a'``), ``'caaat'`` (3 ``'a'`` caracteres), etcétera." +"``'cat'`` (1 ``'a'``), ``'caaat'`` (3 ``'a'`` caracteres), etc." #: ../Doc/howto/regex.rst:178 msgid "" @@ -497,7 +497,7 @@ msgid "" "The engine tries to match ``b``, but the current position is at the end of " "the string, so it fails." msgstr "" -"El motor intenta hacer coincidir ``b``,pero la posición actual está al final " +"El motor intenta hacer coincidir ``b``, pero la posición actual está al final " "de la cadena de caracteres, por lo que falla." #: ../Doc/howto/regex.rst:202 @@ -576,7 +576,7 @@ msgid "" msgstr "" "Otro metacarácter que se repite es ``+``, que coincide una o más veces. " "Preste especial atención a la diferencia entre ``*`` and ``+``; coincide con " -"*zero* o más veces, por lo que cualquier cosa que se repita puede no estar " +"*cero* o más veces, por lo que cualquier cosa que se repita puede no estar " "presente en absoluto, mientras que ``+`` requiere al menos *one* aparición. " "Para usar un ejemplo similar, ``'cat'`` (1 ``'a'``), ``'caaat'`` (3 ``'a'``" "\\ s), pero no coincidirá con ``'ct'``." @@ -633,7 +633,7 @@ msgstr "" #: ../Doc/howto/regex.rst:256 msgid "Using Regular Expressions" -msgstr "Usando Expresiones regulares" +msgstr "Usando Expresiones Regulares" #: ../Doc/howto/regex.rst:258 msgid "" @@ -700,9 +700,8 @@ msgstr "" "pero tiene una desventaja que es el tema de la siguiente sección." #: ../Doc/howto/regex.rst:296 -#, fuzzy msgid "The Backslash Plague" -msgstr "La maldita barra invertida (*The Backslash Plague*)" +msgstr "La plaga de la barra invertida (*The Backslash Plague*)" #: ../Doc/howto/regex.rst:298 msgid "" @@ -729,11 +728,11 @@ msgid "" "*again*." msgstr "" "Supongamos que desea escribir una RE que coincida con la cadena de " -"caracteres ``\\section``, que podría encontrarse en un archivo *LaTeX*. Para " +"caracteres ``\\section``, que podría encontrarse en un archivo LaTeX. Para " "averiguar qué escribir en el código del programa, comience con la cadena " "deseada para que coincida. A continuación, debe escapar de las barras " "invertidas y otros metacarácteres precediéndolos con una barra invertida, lo " -"que da como resultado la cadena `` \\\\ sección ''. La cadena resultante que " +"que da como resultado la cadena ``\\\\section``. La cadena resultante que " "debe pasarse a :func:`re.compile` debe ser ``\\\\section``. Sin embargo, " "para expresar esto como una cadena literal de Python, ambas barras " "invertidas deben escaparse *nuevamente*." @@ -764,12 +763,12 @@ msgstr "Barra invertida de escape para :func:`re.compile`" #: ../Doc/howto/regex.rst:318 ../Doc/howto/regex.rst:345 msgid "``\"\\\\\\\\section\"``" -msgstr "``”\\\\\\\\section”``" +msgstr "``\"\\\\\\\\section\"``" #: ../Doc/howto/regex.rst:318 msgid "Escaped backslashes for a string literal" msgstr "" -"Barra diagonal inversa de escape para un literal de cadena de caracteres" +"Barra invertida de escape para un literal de cadena de caracteres" #: ../Doc/howto/regex.rst:321 msgid "" @@ -820,34 +819,33 @@ msgstr "" #: ../Doc/howto/regex.rst:341 msgid "Regular String" -msgstr "Cadena de caracteres regular" +msgstr "Cadena de caracteres regulares" #: ../Doc/howto/regex.rst:341 msgid "Raw string" -msgstr "Cadena de caracteres cruda (*Raw string*)" +msgstr "Cadena de caracteres crudas (*Raw string*)" #: ../Doc/howto/regex.rst:343 msgid "``\"ab*\"``" -msgstr "``”ab*”``" +msgstr "``\"ab*\"``" #: ../Doc/howto/regex.rst:343 msgid "``r\"ab*\"``" -msgstr "``r”ab*”``" +msgstr "``r\"ab*\"``" #: ../Doc/howto/regex.rst:345 msgid "``r\"\\\\section\"``" -msgstr "``r”\\\\section”``" +msgstr "``r\"\\\\section\"``" #: ../Doc/howto/regex.rst:347 msgid "``\"\\\\w+\\\\s+\\\\1\"``" -msgstr "``”\\\\w+\\\\s+\\\\1”``" +msgstr "``\"\\\\w+\\\\s+\\\\1\"``" #: ../Doc/howto/regex.rst:347 msgid "``r\"\\w+\\s+\\1\"``" -msgstr "``r”\\w+\\s+\\1”``" +msgstr "``r\"\\w+\\s+\\1\"``" #: ../Doc/howto/regex.rst:352 -#, fuzzy msgid "Performing Matches" msgstr "Realizando coincidencias" @@ -1019,7 +1017,7 @@ msgstr "``span()``" #: ../Doc/howto/regex.rst:426 msgid "Return a tuple containing the (start, end) positions of the match" msgstr "" -"Retorna una dupla que contiene (inicio, final) las posiciones de coincidencia" +"Retorna una tupla que contiene (inicio, final) las posiciones de coincidencia" #: ../Doc/howto/regex.rst:430 msgid "Trying these methods will soon clarify their meaning::" @@ -1075,7 +1073,7 @@ msgid "" msgstr "" "El prefijo ``r``, que convierte al literal en una cadena de caracteres " "literal sin formato, es necesario en este ejemplo porque las secuencias de " -"escape en un cadena de caracteres literal “cocinado” normal que no son " +"escape en un cadena de caracteres literal \"cocinado\" normal que no son " "reconocidas por Python, a diferencia de las expresiones regulares, ahora dan " "como resultado :exc:`DeprecationWarning` y eventualmente se convertirá en :" "exc:`SyntaxError`. Ver :ref:`the-backslash-plague`." @@ -1114,7 +1112,6 @@ msgstr "" "objects>`. ::" #: ../Doc/howto/regex.rst:510 -#, fuzzy msgid "" "Under the hood, these functions simply create a pattern object for you and " "call the appropriate method on it. They also store the compiled object in a " @@ -1160,7 +1157,7 @@ msgstr "" "una forma corta de una letra como :const:`I`. (Si está familiarizado con los " "modificadores de patrones de Perl, las formas de una letra usan las mismas " "letras; la forma corta de :const:`re.VERBOSE` es :const:`re.X`, por ejemplo)." -"Se pueden especificar varios indicadores colocándolos en *OR-ing* bit a bit; " +"Se pueden especificar varios indicadores uniendolos con *OR* bit a bit; " "``re.I | re.M`` establece los flags :const:`I` and :const:`M`, por ejemplo." #: ../Doc/howto/regex.rst:533 @@ -1244,7 +1241,7 @@ msgid "" "z]`` or ``[A-Z]`` are used in combination with the :const:`IGNORECASE` flag, " "they will match the 52 ASCII letters and 4 additional non-ASCII letters: " "'İ' (U+0130, Latin capital letter I with dot above), 'ı' (U+0131, Latin " -"small letter dotless i), 'ſ' (U+017F, Latin small letter long s) and 'K' (U" +"small letter dotless i), 'ſ' (U+017F, Latin small letter long s) and 'K' (U" "+212A, Kelvin sign). ``Spam`` will match ``'Spam'``, ``'spam'``, " "``'spAM'``, or ``'ſpam'`` (the latter is matched only in Unicode mode). This " "lowercasing doesn't take the current locale into account; it will if you " @@ -1260,7 +1257,7 @@ msgstr "" "const:ʻIGNORECASE`, coincidirán con las 52 letras ASCII y 4 letras " "adicionales no ASCII 'İ' (U+0130, letra mayúscula latina I con un punto " "arriba), 'ı' (U+0131, letra minúscula latina sin punto i),'ſ' (U+017F, letra " -"minúscula latina larga s) y 'K' (U+212A, signo de *Kelvin*). ``Spam`` " +"minúscula latina larga s) y 'K' (U+212A, signo de Kelvin). ``Spam`` " "coincidirá ``'Spam'``, ``'spam'``, ``'spAM'``, o ``'ſpam'`` (este último " "solo coincide en modo Unicode). Estas minúsculas no tiene en cuenta la " "configuración regional actual; lo hará si también establece la flag :const:" @@ -1406,7 +1403,7 @@ msgstr "" #: ../Doc/howto/regex.rst:672 msgid "More Pattern Power" -msgstr "Más poder de coincidencia" +msgstr "Más poder de patrones" #: ../Doc/howto/regex.rst:674 msgid "" @@ -1463,7 +1460,7 @@ msgid "" "``'Crow'`` or ``'Servo'``, not ``'Cro'``, a ``'w'`` or an ``'S'``, and " "``'ervo'``." msgstr "" -"Alternancia, o el operador “or”. Si *A* y *B* son expresiones regulares, ``A|" +"Alternancia, o el operador \"or\". Si *A* y *B* son expresiones regulares, ``A|" "B`` coincidirá con cualquier cadena de caracteres que coincida con *A* o " "*B*. ``|`` tiene una precedencia muy baja para que funcione razonablemente " "cuando está alternando cadenas de varios caracteres. ``Crow|Servo`` " @@ -1513,7 +1510,7 @@ msgstr "``$``" #: ../Doc/howto/regex.rst:721 msgid "" "Matches at the end of a line, which is defined as either the end of the " -"string, or any location followed by a newline character. ::" +"string, or any location followed by a newline character. ::" msgstr "" "Coincide con el final de una línea, que se define como el final de la cadena " "o cualquier ubicación seguida de un carácter de nueva línea. ::" @@ -1540,8 +1537,8 @@ msgid "" msgstr "" "Coincide solo al comienzo de la cadena de caracteres. Cuando no está en el " "modo :const:`MULTILINE`,``\\A`` y ``^`` son efectivamente lo mismo. En el " -"modo :const:`MULTILINE`, son diferentes: ``\\ A`` todavía coincide solo al " -"principio de la cadena, pero``^``puede coincidir en cualquier ubicación " +"modo :const:`MULTILINE`, son diferentes: ``\\A`` todavía coincide solo al " +"principio de la cadena, pero ``^`` puede coincidir en cualquier ubicación " "dentro de la cadena de caracteres que sigue a un carácter de nueva línea." #: ../Doc/howto/regex.rst:741 @@ -1577,7 +1574,6 @@ msgstr "" "completa; no coincidirá cuando esté contenido dentro de otra palabra. ::" #: ../Doc/howto/regex.rst:760 -#, fuzzy msgid "" "There are two subtleties you should remember when using this special " "sequence. First, this is the worst collision between Python's string " @@ -1961,14 +1957,14 @@ msgid "" "is tried right where the assertion started." msgstr "" "Aserción de anticipación positiva. Esto tiene éxito si la expresión regular " -"contenida, representada aquí por ``…``, coincide con éxito en la ubicación " +"contenida, representada aquí por ``...``, coincide con éxito en la ubicación " "actual y falla en caso contrario. Pero, una vez que se ha probado la " "expresión contenida, el motor de comparación no avanza en absoluto; el resto " "del patrón se intenta justo donde comenzó la aserción." #: ../Doc/howto/regex.rst:994 msgid "``(?!...)``" -msgstr "``(?!…)``" +msgstr "``(?!...)``" #: ../Doc/howto/regex.rst:992 msgid "" @@ -1977,7 +1973,7 @@ msgid "" "current position in the string." msgstr "" "Aserción de anticipación negativa. Esto es lo opuesto a la flag positiva; " -"tiene éxito si la expresión contenida *no* (*doesn't*) coincide con la " +"tiene éxito si la expresión contenida *no* coincide con la " "posición actual en la cadena." #: ../Doc/howto/regex.rst:996 @@ -2152,8 +2148,8 @@ msgid "" "Find all substrings where the RE matches, and replace them with a different " "string" msgstr "" -"Encuentre todas las subcadenas de caracteres donde coincida la RE y " -"reemplácelas con una cadena de caracteres diferente" +"Encuentra todas las subcadenas de caracteres donde coincida la RE y " +"las reemplaza con una cadena de caracteres diferente" #: ../Doc/howto/regex.rst:1072 msgid "``subn()``" From a171edc626179cf656fda62b785edb05797648ed Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Fri, 30 Oct 2020 19:53:03 +0100 Subject: [PATCH 6/9] updating changes --- dictionaries/howto_regex.txt | 2 +- howto/regex.po | 23 +++++++++++------------ 2 files changed, 12 insertions(+), 13 deletions(-) diff --git a/dictionaries/howto_regex.txt b/dictionaries/howto_regex.txt index fab7bbe657..0ed84fe8d0 100644 --- a/dictionaries/howto_regex.txt +++ b/dictionaries/howto_regex.txt @@ -13,4 +13,4 @@ reemplácelas comprenderlas precediéndolos precederlos -TeX +uniéndolos \ No newline at end of file diff --git a/howto/regex.po b/howto/regex.po index e115719671..d2406a5ba5 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -497,8 +497,8 @@ msgid "" "The engine tries to match ``b``, but the current position is at the end of " "the string, so it fails." msgstr "" -"El motor intenta hacer coincidir ``b``, pero la posición actual está al final " -"de la cadena de caracteres, por lo que falla." +"El motor intenta hacer coincidir ``b``, pero la posición actual está al " +"final de la cadena de caracteres, por lo que falla." #: ../Doc/howto/regex.rst:202 msgid "4" @@ -767,8 +767,7 @@ msgstr "``\"\\\\\\\\section\"``" #: ../Doc/howto/regex.rst:318 msgid "Escaped backslashes for a string literal" -msgstr "" -"Barra invertida de escape para un literal de cadena de caracteres" +msgstr "Barra invertida de escape para un literal de cadena de caracteres" #: ../Doc/howto/regex.rst:321 msgid "" @@ -1157,8 +1156,8 @@ msgstr "" "una forma corta de una letra como :const:`I`. (Si está familiarizado con los " "modificadores de patrones de Perl, las formas de una letra usan las mismas " "letras; la forma corta de :const:`re.VERBOSE` es :const:`re.X`, por ejemplo)." -"Se pueden especificar varios indicadores uniendolos con *OR* bit a bit; " -"``re.I | re.M`` establece los flags :const:`I` and :const:`M`, por ejemplo." +"Se pueden especificar varios indicadores uniéndolos con *OR* bit a bit; ``re." +"I | re.M`` establece los flags :const:`I` and :const:`M`, por ejemplo." #: ../Doc/howto/regex.rst:533 msgid "" @@ -1460,8 +1459,8 @@ msgid "" "``'Crow'`` or ``'Servo'``, not ``'Cro'``, a ``'w'`` or an ``'S'``, and " "``'ervo'``." msgstr "" -"Alternancia, o el operador \"or\". Si *A* y *B* son expresiones regulares, ``A|" -"B`` coincidirá con cualquier cadena de caracteres que coincida con *A* o " +"Alternancia, o el operador \"or\". Si *A* y *B* son expresiones regulares, " +"``A|B`` coincidirá con cualquier cadena de caracteres que coincida con *A* o " "*B*. ``|`` tiene una precedencia muy baja para que funcione razonablemente " "cuando está alternando cadenas de varios caracteres. ``Crow|Servo`` " "coincidirá con `'Crow'`` o ``'Servo'``, no ``'Cro'``, un ``'w'`` o un " @@ -1973,8 +1972,8 @@ msgid "" "current position in the string." msgstr "" "Aserción de anticipación negativa. Esto es lo opuesto a la flag positiva; " -"tiene éxito si la expresión contenida *no* coincide con la " -"posición actual en la cadena." +"tiene éxito si la expresión contenida *no* coincide con la posición actual " +"en la cadena." #: ../Doc/howto/regex.rst:996 msgid "" @@ -2148,8 +2147,8 @@ msgid "" "Find all substrings where the RE matches, and replace them with a different " "string" msgstr "" -"Encuentra todas las subcadenas de caracteres donde coincida la RE y " -"las reemplaza con una cadena de caracteres diferente" +"Encuentra todas las subcadenas de caracteres donde coincida la RE y las " +"reemplaza con una cadena de caracteres diferente" #: ../Doc/howto/regex.rst:1072 msgid "``subn()``" From f10c23b9920787c3ef764bbc7e167e339f477bdd Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Fri, 30 Oct 2020 20:13:23 +0100 Subject: [PATCH 7/9] adding changes --- howto/regex.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/howto/regex.po b/howto/regex.po index d2406a5ba5..f8aba2dc29 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -1253,7 +1253,7 @@ msgstr "" "también funciona a menos que se utilice la flag :const:`ASCII` para " "deshabilitar las coincidencias que no sean ASCII. Cuando los patrones " "Unicode ``[a-z]`` o ``[A-Z]`` se utilizan en combinación con el indicador :" -"const:ʻIGNORECASE`, coincidirán con las 52 letras ASCII y 4 letras " +"const:ʻIGNORECASE` , coincidirán con las 52 letras ASCII y 4 letras " "adicionales no ASCII 'İ' (U+0130, letra mayúscula latina I con un punto " "arriba), 'ı' (U+0131, letra minúscula latina sin punto i),'ſ' (U+017F, letra " "minúscula latina larga s) y 'K' (U+212A, signo de Kelvin). ``Spam`` " From fd32fbe8cda207a7140bddc7172ec5642c890e3d Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Date: Fri, 30 Oct 2020 22:08:42 +0100 Subject: [PATCH 8/9] adding changes --- howto/regex.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/howto/regex.po b/howto/regex.po index f8aba2dc29..d33f08289b 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -1260,7 +1260,7 @@ msgstr "" "coincidirá ``'Spam'``, ``'spam'``, ``'spAM'``, o ``'ſpam'`` (este último " "solo coincide en modo Unicode). Estas minúsculas no tiene en cuenta la " "configuración regional actual; lo hará si también establece la flag :const:" -"`LOCALE`." +"`LOCALE` ." #: ../Doc/howto/regex.rst:580 msgid "" From 65373a22ecc975b9097beb6567b8072211cfc708 Mon Sep 17 00:00:00 2001 From: Maria Jose Molina Contreras <32220621+mjmolina@users.noreply.github.com> Date: Fri, 30 Oct 2020 22:22:42 +0100 Subject: [PATCH 9/9] Update howto/regex.po --- howto/regex.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/howto/regex.po b/howto/regex.po index d33f08289b..f99f626fce 100644 --- a/howto/regex.po +++ b/howto/regex.po @@ -1253,7 +1253,7 @@ msgstr "" "también funciona a menos que se utilice la flag :const:`ASCII` para " "deshabilitar las coincidencias que no sean ASCII. Cuando los patrones " "Unicode ``[a-z]`` o ``[A-Z]`` se utilizan en combinación con el indicador :" -"const:ʻIGNORECASE` , coincidirán con las 52 letras ASCII y 4 letras " +"const:`IGNORECASE` , coincidirán con las 52 letras ASCII y 4 letras " "adicionales no ASCII 'İ' (U+0130, letra mayúscula latina I con un punto " "arriba), 'ı' (U+0131, letra minúscula latina sin punto i),'ſ' (U+017F, letra " "minúscula latina larga s) y 'K' (U+212A, signo de Kelvin). ``Spam`` "