# 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: 2026-02-26 18:44-0300\n"

"PO-Revision-Date: 2023-10-16 13:17-0500\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.18.0\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>*"

#: ../Doc/howto/regex.rst:-1

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 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:79

#, python-brace-format

msgid ". ^ $ * + ? { } [ ] \\ | ( )"

msgstr ""

#: ../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 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 ""

"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 metacaracteres (excepto ``\\``) no están activos dentro de las clases. "

"Por ejemplo, ``[akm$]`` coincidirá con cualquiera de los caracteres ``'a'``, "

"``'k'``, ``'m'``, o ``'$'``; ``'$'`` 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 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 ""

"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:130

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:133

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:136

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:140

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:144

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:148

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

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 otros dos operadores de repetición o cuantificadores. El carácter de "

"interrogación, ``?``, coincide una vez o cero veces; puede pensar en ello "

"como marcar algo como opcional. Por ejemplo, ``home-?brew`` coincide con "

"``'homebrew'`` o ``'home-brew'``."

#: ../Doc/howto/regex.rst:238

#, python-brace-format

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 cuantificador más complicado es ``{m,n}``, donde *m* y *n* son enteros "

"decimales. Este cuantificador 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'``, y ``'a///b'``. No coincidirá con ``'ab'``, que no "

"tiene barras diagonales, 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

#, python-brace-format

msgid ""

"The simplest case ``{m}`` matches the preceding item exactly *m* times. For "

"example, ``a/{2}b`` will only match ``'a//b'``."

msgstr ""

#: ../Doc/howto/regex.rst:251

#, python-brace-format

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 con una inclinación reduccionista pueden notar que los otros "

"tres cuantificadores se pueden expresar todos utilizando esta notación. "

"``{0,}`` es lo mismo que ``*``, ``{1,}`` es equivalente a ``+``, y ``{0,1}`` "

"es lo mismo que ``?``. Es mejor usar ``*``, ``+``, o ``?`` cuando sea "

"posible, simplemente porque son más cortos y más fáciles de leer."

#: ../Doc/howto/regex.rst:259

msgid "Using Regular Expressions"

msgstr "Usando expresiones regulares"

#: ../Doc/howto/regex.rst:261

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:268

msgid "Compiling Regular Expressions"

msgstr "Compilando expresiones regulares"

#: ../Doc/howto/regex.rst:270

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:274

msgid ""

">>> import re\n"

">>> p = re.compile('ab*')\n"

">>> p\n"

"re.compile('ab*')"

msgstr ""

#: ../Doc/howto/regex.rst:279

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:283

msgid ">>> p = re.compile('ab*', re.IGNORECASE)"

msgstr ""

#: ../Doc/howto/regex.rst:285

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:292

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:299

msgid "The Backslash Plague"

msgstr "La plaga de la barra invertida (*The Backslash Plague*)"

#: ../Doc/howto/regex.rst:301

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:306

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 metacaracteres 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:315

msgid "Characters"

msgstr "Caracteres"

#: ../Doc/howto/regex.rst:315

msgid "Stage"

msgstr "Explicación"

#: ../Doc/howto/regex.rst:317

msgid "``\\section``"

msgstr "``\\section``"

#: ../Doc/howto/regex.rst:317

msgid "Text string to be matched"

msgstr "Cadena de texto que debe coincidir"

#: ../Doc/howto/regex.rst:319

msgid "``\\\\section``"

msgstr "``\\\\section``"

#: ../Doc/howto/regex.rst:319

msgid "Escaped backslash for :func:`re.compile`"

msgstr "Barra invertida de escape para :func:`re.compile`"

#: ../Doc/howto/regex.rst:321 ../Doc/howto/regex.rst:348

msgid "``\"\\\\\\\\section\"``"

msgstr "``\"\\\\\\\\section\"``"

#: ../Doc/howto/regex.rst:321

msgid "Escaped backslashes for a string literal"

msgstr "Barra invertida de escape para un literal de cadena de caracteres"

#: ../Doc/howto/regex.rst:324

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:330

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:336

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:344

msgid "Regular String"

msgstr "Cadena de caracteres regulares"

#: ../Doc/howto/regex.rst:344

msgid "Raw string"

msgstr "Cadena de caracteres crudas (*Raw string*)"

#: ../Doc/howto/regex.rst:346

msgid "``\"ab*\"``"

msgstr "``\"ab*\"``"

#: ../Doc/howto/regex.rst:346

msgid "``r\"ab*\"``"

msgstr "``r\"ab*\"``"

#: ../Doc/howto/regex.rst:348

msgid "``r\"\\\\section\"``"

msgstr "``r\"\\\\section\"``"

#: ../Doc/howto/regex.rst:350

msgid "``\"\\\\w+\\\\s+\\\\1\"``"

msgstr "``\"\\\\w+\\\\s+\\\\1\"``"

#: ../Doc/howto/regex.rst:350

msgid "``r\"\\w+\\s+\\1\"``"

msgstr "``r\"\\w+\\s+\\1\"``"

#: ../Doc/howto/regex.rst:355

msgid "Performing Matches"

msgstr "Realizando coincidencias"

#: ../Doc/howto/regex.rst:357

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:363 ../Doc/howto/regex.rst:417

#: ../Doc/howto/regex.rst:1072

msgid "Method/Attribute"

msgstr "Método/atributo"

#: ../Doc/howto/regex.rst:363 ../Doc/howto/regex.rst:417

#: ../Doc/howto/regex.rst:1072

msgid "Purpose"

msgstr "Objetivo"

#: ../Doc/howto/regex.rst:365

msgid "``match()``"

msgstr "``match()``"

#: ../Doc/howto/regex.rst:365

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:368

msgid "``search()``"

msgstr "``search()``"

#: ../Doc/howto/regex.rst:368

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:371

msgid "``findall()``"

msgstr "``findall()``"

#: ../Doc/howto/regex.rst:371

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:374

msgid "``finditer()``"

msgstr "``finditer()``"

#: ../Doc/howto/regex.rst:374

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:378

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:383

msgid ""

"You can learn about this by interactively experimenting with the :mod:`re` "

"module."

msgstr ""

"Puedes aprender sobre esto experimentando de forma interactiva con el "

"módulo :mod:`re`."

#: ../Doc/howto/regex.rst:386

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:389

msgid ""

">>> import re\n"

">>> p = re.compile('[a-z]+')\n"

">>> p\n"

"re.compile('[a-z]+')"

msgstr ""

#: ../Doc/howto/regex.rst:394

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:400

msgid ""

">>> p.match(\"\")\n"

">>> print(p.match(\"\"))\n"

"None"

msgstr ""

#: ../Doc/howto/regex.rst:404

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-"