regex.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-08-04 17:34+0200\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@gmail.com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.10.3\n"

#: ../Doc/howto/regex.rst:5
msgid "Regular Expression HOWTO"
msgstr "Expresiones regulares COMOS (*HOWTO*)"

#: ../Doc/howto/regex.rst
msgid "Author"
msgstr "Autor"

#: ../Doc/howto/regex.rst:7
msgid "A.M. Kuchling <amk@amk.ca>"
msgstr "*A.M. Kuchling <amk@amk.ca>*"

msgid "Abstract"
msgstr "Resumen"

#: ../Doc/howto/regex.rst:18
msgid ""
"This document is an introductory tutorial to using regular expressions in "
"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 "Introducción"

#: ../Doc/howto/regex.rst:26
msgid ""
"Regular expressions (called REs, or regexes, or regex patterns) are "
"essentially a tiny, highly specialized programming language embedded inside "
"Python and made available through the :mod:`re` module. Using this little "
"language, you specify the rules for the set of possible strings that you "
"want to match; this set might contain English sentences, or e-mail "
"addresses, or TeX commands, or anything you like.  You can then ask "
"questions such as \"Does this string match the pattern?\", or \"Is there a "
"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 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 "
"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 ""
"Regular expression patterns are compiled into a series of bytecodes which "
"are then executed by a matching engine written in C.  For advanced use, it "
"may be necessary to pay careful attention to how the engine will execute a "
"given RE, and write the RE in a certain way in order to produce bytecode "
"that runs faster. Optimization isn't covered in this document, because it "
"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á 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."

#: ../Doc/howto/regex.rst:42
msgid ""
"The regular expression language is relatively small and restricted, so not "
"all possible string processing tasks can be done using regular expressions.  "
"There are also tasks that *can* be done with regular expressions, but the "
"expressions turn out to be very complicated.  In these cases, you may be "
"better off writing Python code to do the processing; while Python code will "
"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 "Patrones simples"

#: ../Doc/howto/regex.rst:53
msgid ""
"We'll start by learning about the simplest possible regular expressions.  "
"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 ""
"For a detailed explanation of the computer science underlying regular "
"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 "Coincidencia de Caracteres (*Matching Characters*)"

#: ../Doc/howto/regex.rst:65
msgid ""
"Most letters and characters will simply match themselves.  For example, the "
"regular expression ``test`` will match the string ``test`` exactly.  (You "
"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 ""
"There are exceptions to this rule; some characters are special :dfn:"
"`metacharacters`, and don't match themselves.  Instead, they signal that "
"some out-of-the-ordinary thing should be matched, or they affect other "
"portions of the RE by repeating them or changing their meaning.  Much of "
"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 de la RE repitiéndolos o "
"cambiando su significado. Gran parte de este documento está dedicado a "
"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 metacarácteres; sus significados se "
"discutirán en el resto de este COMO (*HOWTO*)."

#: ../Doc/howto/regex.rst:83
msgid ""
"The first metacharacters we'll look at are ``[`` and ``]``. They're used for "
"specifying a character class, which is a set of characters that you wish to "
"match.  Characters can be listed individually, or a range of characters can "
"be indicated by giving two characters and separating them by a ``'-'``.  For "
"example, ``[abc]`` will match any of the characters ``a``, ``b``, or ``c``; "
"this is the same as ``[a-c]``, which uses a range to express the same set of "
"characters.  If you wanted to match only lowercase letters, your RE would be "
"``[a-z]``."
msgstr ""
"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 "
"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
#, fuzzy
msgid ""
"Metacharacters (except ``\\``) are not active inside classes.  For example, "
"``[akm$]`` will match any of the characters ``'a'``, ``'k'``, ``'m'``, or "
"``'$'``; ``'$'`` is usually a metacharacter, but inside a character class "
"it's stripped of its special nature."
msgstr ""
"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 ""
"You can match the characters not listed within the class by :dfn:"
"`complementing` the set.  This is indicated by including a ``'^'`` as the "
"first character of the class. For example, ``[^5]`` will match any character "
"except ``'5'``.  If the caret appears elsewhere in a character class, it "
"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 ""
"Perhaps the most important metacharacter is the backslash, ``\\``.   As in "
"Python string literals, the backslash can be followed by various characters "
"to signal various special sequences.  It's also used to escape all the "
"metacharacters so you can still match them in patterns; for example, if you "
"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 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 ``\\\\``."

#: ../Doc/howto/regex.rst:110
msgid ""
"Some of the special sequences beginning with ``'\\'`` represent predefined "
"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 ""
"Let's take an example: ``\\w`` matches any alphanumeric character.  If the "
"regex pattern is expressed in bytes, this is equivalent to the class ``[a-zA-"
"Z0-9_]``.  If the regex pattern is a string, ``\\w`` will match all the "
"characters marked as letters in the Unicode database provided by the :mod:"
"`unicodedata` module.  You can use the more restricted definition of ``\\w`` "
"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 ""
"The following list of special sequences isn't complete. For a complete list "
"of sequences and expanded class definitions for Unicode string patterns, see "
"the last part of :ref:`Regular Expression Syntax <re-syntax>` in the "
"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 <re-syntax>` en la referencia de la biblioteca estándar. "
"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
msgid "``\\d``"
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 "``\\D``"

#: ../Doc/howto/regex.rst:134
msgid ""
"Matches any non-digit character; this is equivalent to the class ``[^0-9]``."
msgstr ""
"Coincide con cualquier carácter que no sea un dígito; esto es equivalente a "
"la clase ``[^0-9]``."

#: ../Doc/howto/regex.rst:138
msgid "``\\s``"
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 carácter de espacio en blanco; esto es equivalente a "
"la clase ``[ \\t\\n\\r\\f\\v]``."

#: ../Doc/howto/regex.rst:142
msgid "``\\S``"
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 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
msgid "``\\w``"
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 carácter alfanumérico; esto es equivalente a la clase "
"``[a-zA-Z0-9_]``."

#: ../Doc/howto/regex.rst:150
msgid "``\\W``"
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 carácter no alfanumérico; esto es equivalente a la "
"clase ``[^a-zA-Z0-9_]``."

#: ../Doc/howto/regex.rst:152
msgid ""
"These sequences can be included inside a character class.  For example, "
"``[\\s,.]`` is a character class that will match any whitespace character, "
"or ``','`` or ``'.'``."
msgstr ""
"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 ""
"The final metacharacter in this section is ``.``.  It matches anything "
"except a newline character, and there's an alternate mode (:const:`re."
"DOTALL`) where it will match even a newline.  ``.`` is often used where you "
"want to match \"any character\"."
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\"."

#: ../Doc/howto/regex.rst:163
msgid "Repeating Things"
msgstr "Repitiendo cosas"

#: ../Doc/howto/regex.rst:165
msgid ""
"Being able to match varying sets of characters is the first thing regular "
"expressions can do that isn't already possible with the methods available on "
"strings.  However, if that was the only additional capability of regexes, "
"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 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 ""
"The first metacharacter for repeating things that we'll look at is ``*``.  "
"``*`` doesn't match the literal character ``'*'``; instead, it specifies "
"that the previous character can be matched zero or more times, instead of "
"exactly once."
msgstr ""
"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."

#: ../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'`` caracteres), etc."

#: ../Doc/howto/regex.rst:178
msgid ""
"Repetitions such as ``*`` are :dfn:`greedy`; when repeating a RE, the "
"matching engine will try to repeat it as many times as possible. If later "
"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 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."

#: ../Doc/howto/regex.rst:183
msgid ""
"A step-by-step example will make this more obvious.  Let's consider the "
"expression ``a[bcd]*b``.  This matches the letter ``'a'``, zero or more "
"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 "Pasos"

#: ../Doc/howto/regex.rst:189
msgid "Matched"
msgstr "Coincidencias"

#: ../Doc/howto/regex.rst:189
msgid "Explanation"
msgstr "Explicación"

#: ../Doc/howto/regex.rst:191
msgid "1"
msgstr "1"

#: ../Doc/howto/regex.rst:191
msgid "``a``"
msgstr "``a``"

#: ../Doc/howto/regex.rst:191
msgid "The ``a`` in the RE matches."
msgstr "La ``a`` en las RE coincide."

#: ../Doc/howto/regex.rst:193
msgid "2"
msgstr "2"

#: ../Doc/howto/regex.rst:193
msgid "``abcbd``"
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 "3"

#: ../Doc/howto/regex.rst:197 ../Doc/howto/regex.rst:205
msgid "*Failure*"
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 "4"

#: ../Doc/howto/regex.rst:202 ../Doc/howto/regex.rst:213
msgid "``abcb``"
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 "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 "6"

#: ../Doc/howto/regex.rst:209
msgid "``abc``"
msgstr "``abc``"

#: ../Doc/howto/regex.rst:209
msgid "Back up again, so that ``[bcd]*`` is only matching ``bc``."
msgstr ""
"Haga 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 ""
"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 ""
"The end of the RE has now been reached, and it has matched ``'abcb'``.  This "
"demonstrates how the matching engine goes as far as it can at first, and if "
"no match is found it will then progressively back up and retry the rest of "
"the RE again and again.  It will back up until it has tried zero matches for "
"``[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 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 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 ""
"Another repeating metacharacter is ``+``, which matches one or more times.  "
"Pay careful attention to the difference between ``*`` and ``+``; ``*`` "
"matches *zero* or more times, so whatever's being repeated may not be "
"present at all, while ``+`` requires at least *one* occurrence.  To use a "
"similar example, ``ca+t`` will match ``'cat'`` (1 ``'a'``), ``'caaat'`` (3 "
"``'a'``\\ s), but won't match ``'ct'``."
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 "
"*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'``."

#: ../Doc/howto/regex.rst:233
#, fuzzy
msgid ""
"There are two more repeating operators or quantifiers.  The question mark "
"character, ``?``, matches either once or zero times; you can think of it as "
"marking 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
#, fuzzy
msgid ""
"The most complicated quantifier is ``{m,n}``, where *m* and *n* are decimal "
"integers.  This quantifier means there must be at least *m* repetitions, and "
"at most *n*.  For example, ``a/{1,3}b`` will match ``'a/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 ""
"You can omit either *m* or *n*; in that case, a reasonable value is assumed "
"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
#, fuzzy
msgid ""
"Readers of a reductionist bent may notice that the three other quantifiers "
"can all be expressed using this notation.  ``{0,}`` is the same as ``*``, "
"``{1,}`` is equivalent to ``+``, and ``{0,1}`` is the same as ``?``.  It's "
"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 "Usando Expresiones Regulares"

#: ../Doc/howto/regex.rst:258
msgid ""
"Now that we've looked at some simple regular expressions, how do we actually "
"use them in Python?  The :mod:`re` module provides an interface to the "
"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 "Compilando Expresiones regulares"

#: ../Doc/howto/regex.rst:267
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 ""
":func:`re.compile` also accepts an optional *flags* argument, used to enable "
"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 ""
"The RE is passed to :func:`re.compile` as a string.  REs are handled as "
"strings because regular expressions aren't part of the core Python language, "
"and no special syntax was created for expressing them.  (There are "
"applications that don't need REs at all, so there's no need to bloat the "
"language specification by including them.) Instead, the :mod:`re` module is "
"simply a C extension module included with Python, just like the :mod:"
"`socket` or :mod:`zlib` modules."
msgstr ""
"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 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
msgid "The Backslash Plague"
msgstr "La plaga de la barra invertida (*The Backslash Plague*)"

#: ../Doc/howto/regex.rst:298
msgid ""
"As stated earlier, regular expressions use the backslash character "
"(``'\\'``) to indicate special forms or to allow special characters to be "
"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 ""
"Let's say you want to write a RE that matches the string ``\\section``, "
"which might be found in a LaTeX file.  To figure out what to write in the "
"program code, start with the desired string to be matched.  Next, you must "
"escape any backslashes and other metacharacters by preceding them with a "
"backslash, resulting in the string ``\\\\section``.  The resulting string "
"that must be passed to :func:`re.compile` must be ``\\\\section``.  However, "
"to express this as a Python string literal, both backslashes must be escaped "
"*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 "
"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 ``\\\\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*."

#: ../Doc/howto/regex.rst:312
msgid "Characters"
msgstr "Caracteres"

#: ../Doc/howto/regex.rst:312
msgid "Stage"
msgstr "Explicación"

#: ../Doc/howto/regex.rst:314
msgid "``\\section``"
msgstr "``\\section``"

#: ../Doc/howto/regex.rst:314
msgid "Text string to be matched"
msgstr "Cadena de texto que debe coincidir"

#: ../Doc/howto/regex.rst:316
msgid "``\\\\section``"
msgstr "``\\\\section``"

#: ../Doc/howto/regex.rst:316
msgid "Escaped backslash for :func:`re.compile`"
msgstr "Barra invertida de escape para :func:`re.compile`"

#: ../Doc/howto/regex.rst:318 ../Doc/howto/regex.rst:345
msgid "``\"\\\\\\\\section\"``"
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"

#: ../Doc/howto/regex.rst:321
msgid ""
"In short, to match a literal backslash, one has to write ``'\\\\\\\\'`` as "
"the RE string, because the regular expression must be ``\\\\``, and each "
"backslash must be expressed as ``\\\\`` inside a regular Python string "
"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 las 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 ""
"The solution is to use Python's raw string notation for regular expressions; "
"backslashes are not handled in any special way in a string literal prefixed "
"with ``'r'``, so ``r\"\\n\"`` is a two-character string containing ``'\\'`` "
"and ``'n'``, while ``\"\\n\"`` is a one-character string containing a "
"newline. 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 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 ""
"In addition, special escape sequences that are valid in regular expressions, "
"but not valid as Python string literals, now result in a :exc:"
"`DeprecationWarning` and will eventually become a :exc:`SyntaxError`, which "
"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 "Cadena de caracteres regulares"

#: ../Doc/howto/regex.rst:341
msgid "Raw string"
msgstr "Cadena de caracteres crudas (*Raw string*)"

#: ../Doc/howto/regex.rst:343
msgid "``\"ab*\"``"
msgstr "``\"ab*\"``"

#: ../Doc/howto/regex.rst:343
msgid "``r\"ab*\"``"
msgstr "``r\"ab*\"``"

#: ../Doc/howto/regex.rst:345
msgid "``r\"\\\\section\"``"
msgstr "``r\"\\\\section\"``"

#: ../Doc/howto/regex.rst:347
msgid "``\"\\\\w+\\\\s+\\\\1\"``"
msgstr "``\"\\\\w+\\\\s+\\\\1\"``"

#: ../Doc/howto/regex.rst:347
msgid "``r\"\\w+\\s+\\1\"``"
msgstr "``r\"\\w+\\s+\\1\"``"

#: ../Doc/howto/regex.rst:352
msgid "Performing Matches"
msgstr "Realizando coincidencias"

#: ../Doc/howto/regex.rst:354
msgid ""
"Once you have an object representing a compiled regular expression, what do "
"you do with it?  Pattern objects have several methods and attributes. Only "
"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 "Método/atributo"

#: ../Doc/howto/regex.rst:360 ../Doc/howto/regex.rst:418
#: ../Doc/howto/regex.rst:1064
msgid "Purpose"
msgstr "Objetivo"

#: ../Doc/howto/regex.rst:362
msgid "``match()``"
msgstr "``match()``"

#: ../Doc/howto/regex.rst:362
msgid "Determine if the RE matches at the beginning of the string."
msgstr ""
"Determina si la RE coincide con el comienzo de la cadena de caracteres."

#: ../Doc/howto/regex.rst:365
msgid "``search()``"
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 "``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 la RE y las "
"retorna como una lista."

#: ../Doc/howto/regex.rst:371
msgid "``finditer()``"
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 la RE coincide y las retorna como un "
"término iterado :term:`iterator`."

#: ../Doc/howto/regex.rst:375
msgid ""
":meth:`~re.Pattern.match` and :meth:`~re.Pattern.search` return ``None`` if "
"no match can be found.  If they're successful, a :ref:`match object <match-"
"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 <match-objects>`, 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 ""
"You can learn about this by interactively experimenting with the :mod:`re` "
"module.  If you have :mod:`tkinter` available, you may also want to look at :"
"source:`Tools/demo/redemo.py`, a demonstration program included with the "
"Python distribution.  It allows you to enter REs and strings, and displays "
"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 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 ""
"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 ""
"Now, you can try matching various strings against the RE ``[a-z]+``.  An "
"empty string shouldn't match at all, since ``+`` means 'one or more "
"repetitions'. :meth:`~re.Pattern.match` should return ``None`` in this case, "
"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 la RE ``[a-z]+``. "
"Una cadena de caracteres vacía no debería coincidir en absoluto, ya que "
"``+`` 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 ""
"Now, let's try it on a string that it should match, such as ``tempo``.  In "
"this case, :meth:`~re.Pattern.match` will return a :ref:`match object <match-"
"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 "
"object <match-objects>`, por lo que debe almacenar el resultado en una "
"variable para su posterior uso. ::"

#: ../Doc/howto/regex.rst:413
msgid ""
"Now you can query the :ref:`match object <match-objects>` for information "
"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 <match-objects>` 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 "``group()``"

#: ../Doc/howto/regex.rst:420
msgid "Return the string matched by the RE"
msgstr "Retorna la cadena de caracteres que coincide con la RE"

#: ../Doc/howto/regex.rst:422
msgid "``start()``"
msgstr "``start()``"