Skip to content

Traducido archivo howto/regex.po #2686

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Oct 17, 2023
Merged

Traducido archivo howto/regex.po #2686

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
88727c5
Traducido archivo `howto/regex.po`
Yenniferh Oct 16, 2023
c4194c1
Merge branch '3.12' of https://github.com/python/python-docs-es into …
Yenniferh Oct 16, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
100 changes: 48 additions & 52 deletions howto/regex.po
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,15 +11,16 @@ msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2021-08-04 17:34+0200\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"
"Language: es\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Generated-By: Babel 2.13.0\n"
"X-Generator: Poedit 3.4\n"

#: ../Doc/howto/regex.rst:5
msgid "Regular Expression HOWTO"
Expand Down Expand Up @@ -168,14 +169,14 @@ msgstr ""
"`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."
"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 metacarácteres; sus significados se "
"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
Expand All @@ -189,7 +190,7 @@ msgid ""
"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 "
"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 "
Expand All @@ -199,17 +200,16 @@ msgstr ""
"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."
"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 ""
Expand Down Expand Up @@ -239,7 +239,7 @@ 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 "
"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 ``\\\\``."
Expand Down Expand Up @@ -581,32 +581,30 @@ msgstr ""
"``'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 "
"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
#, 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."
"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 ""
Expand All @@ -619,19 +617,18 @@ msgstr ""
"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."
"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:256
msgid "Using Regular Expressions"
Expand Down Expand Up @@ -732,7 +729,7 @@ msgstr ""
"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 "
"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 "
Expand Down Expand Up @@ -929,6 +926,8 @@ 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:383
msgid ""
Expand Down Expand Up @@ -1402,19 +1401,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 metacarácteres "
"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:680
msgid "More Metacharacters"
msgstr "Más metacarácteres"
msgstr "Más metacaracteres"

#: ../Doc/howto/regex.rst:682
msgid ""
"There are some metacharacters that we haven't covered yet. Most of them "
"will be covered in this section."
msgstr ""
"Hay algunos metacarácteres que aún no hemos cubierto. La mayoría de ellos se "
"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:685
Expand All @@ -1428,7 +1427,7 @@ msgid ""
"once at a given location, they can obviously be matched an infinite number "
"of times."
msgstr ""
"Algunos de los metacarácteres restantes que se discutirán son :dfn:`zero-"
"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 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 "
Expand Down Expand Up @@ -1635,7 +1634,6 @@ msgstr ""
"del encabezado y otro grupo que coincida con el valor del encabezado."

#: ../Doc/howto/regex.rst:801
#, fuzzy
msgid ""
"Groups are marked by the ``'('``, ``')'`` metacharacters. ``'('`` and "
"``')'`` have much the same meaning as they do in mathematical expressions; "
Expand All @@ -1644,12 +1642,12 @@ msgid ""
"``, or ``{m,n}``. For example, ``(ab)*`` will match zero or more "
"repetitions of ``ab``. ::"
msgstr ""
"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 "
"``ab``. ::"
"Los grupos se marcan con los metacaracteres ``'('`` y ``')'``. ``'('`` y "
"``')'`` tienen prácticamente el mismo significado que en las expresiones "
"matemáticas; agrupan las expresiones contenidas dentro de ellos, y puedes "
"repetir el contenido de un grupo con un cuantificador, como ``*``, ``+``, ``?"
"``, o ``{m,n}``. Por ejemplo, ``(ab)*`` coincidirá con cero o más "
"repeticiones de ``ab``. ::"

#: ../Doc/howto/regex.rst:812
msgid ""
Expand Down Expand Up @@ -1768,7 +1766,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 metacarácteres de una sola pulsación de "
"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 "
Expand Down Expand Up @@ -1886,15 +1884,14 @@ msgstr ""
"Match.groupdict`::"

#: ../Doc/howto/regex.rst:950
#, fuzzy
msgid ""
"Named groups are handy because they let you use easily remembered names, "
"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`::"
"Los grupos nombrados son útiles porque le permiten usar nombres fáciles de "
"recordar en lugar de tener que recordar números. Aquí hay un ejemplo de una "
"RE del módulo :mod:`imaplib`::"

#: ../Doc/howto/regex.rst:961
msgid ""
Expand Down Expand Up @@ -2552,20 +2549,19 @@ msgstr ""
"que queremos."

#: ../Doc/howto/regex.rst:1327
#, fuzzy
msgid ""
"In this case, the solution is to use the non-greedy quantifiers ``*?``, ``+?"
"``, ``??``, or ``{m,n}?``, which match as *little* text as possible. In the "
"above example, the ``'>'`` is tried immediately after the first ``'<'`` "
"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:"
"En este caso, la solución es utilizar los cuantificadores no codiciosos ``*?"
"``, ``+?``, ``??``, o ``{m,n}?``, que coinciden con la *menor* cantidad de "
"texto posible. En el ejemplo anterior, el ``'>'`` se prueba inmediatamente "
"después de que el primer ``'<'`` coincida, 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:1336
msgid ""
Expand Down