html.parser.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: 2026-02-26 18:44-0300\n"
"PO-Revision-Date: 2020-07-06 20:56+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.18.0\n"

#: ../Doc/library/html.parser.rst:2
#, fuzzy
msgid ":mod:`!html.parser` --- Simple HTML and XHTML parser"
msgstr ":mod:`html.parser` --- Analizador simple de HTML y XHTML"

#: ../Doc/library/html.parser.rst:7
msgid "**Source code:** :source:`Lib/html/parser.py`"
msgstr "**Código fuente:** :source:`Lib/html/parser.py`"

#: ../Doc/library/html.parser.rst:15
msgid ""
"This module defines a class :class:`HTMLParser` which serves as the basis "
"for parsing text files formatted in HTML (HyperText Mark-up Language) and "
"XHTML."
msgstr ""
"Este módulo define una clase :class:`HTMLParser` que sirve como base para "
"analizar archivos de texto formateados en HTML (*HyperText Mark-up "
"Language*) y XHTML."

#: ../Doc/library/html.parser.rst:20
msgid "Create a parser instance able to parse invalid markup."
msgstr "Cree una instancia de analizador capaz de analizar marcado no válido."

#: ../Doc/library/html.parser.rst:22
msgid ""
"If *convert_charrefs* is ``True`` (the default), all character references "
"(except the ones in ``script``/``style`` elements) are automatically "
"converted to the corresponding Unicode characters."
msgstr ""
"Si *convert_charrefs* es ``True`` (el valor predeterminado), todas las "
"referencias de caracteres (excepto las de los elementos ``script``/"
"``style``) se convierten automáticamente en los caracteres Unicode "
"correspondientes."

#: ../Doc/library/html.parser.rst:26
msgid ""
"An :class:`.HTMLParser` instance is fed HTML data and calls handler methods "
"when start tags, end tags, text, comments, and other markup elements are "
"encountered.  The user should subclass :class:`.HTMLParser` and override its "
"methods to implement the desired behavior."
msgstr ""
"Una instancia de :class:`.HTMLParser` se alimenta de datos HTML y llama a "
"métodos de manejo cuando se encuentran etiquetas de inicio, etiquetas "
"finales, texto, comentarios y otros elementos de marcado. El usuario debe "
"subclasificar :class:`.HTMLParser` y anular sus métodos para implementar el "
"comportamiento deseado."

#: ../Doc/library/html.parser.rst:31
msgid ""
"This parser does not check that end tags match start tags or call the end-"
"tag handler for elements which are closed implicitly by closing an outer "
"element."
msgstr ""
"Este analizador no verifica que las etiquetas finales coincidan con las "
"etiquetas iniciales ni llame al manejador de etiquetas finales para los "
"elementos que se cierran implícitamente al cerrar un elemento externo."

#: ../Doc/library/html.parser.rst:34
msgid "*convert_charrefs* keyword argument added."
msgstr "argumento de palabra clave *convert_charrefs* agregado."

#: ../Doc/library/html.parser.rst:37
msgid "The default value for argument *convert_charrefs* is now ``True``."
msgstr ""
"El valor predeterminado para el argumento *convert_charrefs* ahora es "
"``True``."

#: ../Doc/library/html.parser.rst:42
msgid "Example HTML Parser Application"
msgstr "Aplicación ejemplo de un analizador sintáctico (*parser*) de HTML"

#: ../Doc/library/html.parser.rst:44
#, fuzzy
msgid ""
"As a basic example, below is a simple HTML parser that uses the :class:"
"`HTMLParser` class to print out start tags, end tags, and data as they are "
"encountered:"
msgstr ""
"Como ejemplo básico, a continuación hay un analizador HTML simple que usa la "
"clase :class:`HTMLParser` para imprimir etiquetas de inicio, etiquetas "
"finales y datos a medida que se encuentran:"

#: ../Doc/library/html.parser.rst:48
msgid ""
"from html.parser import HTMLParser\n"
"\n"
"class MyHTMLParser(HTMLParser):\n"
"    def handle_starttag(self, tag, attrs):\n"
"        print(\"Encountered a start tag:\", tag)\n"
"\n"
"    def handle_endtag(self, tag):\n"
"        print(\"Encountered an end tag :\", tag)\n"
"\n"
"    def handle_data(self, data):\n"
"        print(\"Encountered some data  :\", data)\n"
"\n"
"parser = MyHTMLParser()\n"
"parser.feed('<html><head><title>Test</title></head>'\n"
"            '<body><h1>Parse me!</h1></body></html>')"
msgstr ""

#: ../Doc/library/html.parser.rst:66
msgid "The output will then be:"
msgstr "La salida será entonces:"

#: ../Doc/library/html.parser.rst:68
msgid ""
"Encountered a start tag: html\n"
"Encountered a start tag: head\n"
"Encountered a start tag: title\n"
"Encountered some data  : Test\n"
"Encountered an end tag : title\n"
"Encountered an end tag : head\n"
"Encountered a start tag: body\n"
"Encountered a start tag: h1\n"
"Encountered some data  : Parse me!\n"
"Encountered an end tag : h1\n"
"Encountered an end tag : body\n"
"Encountered an end tag : html"
msgstr ""

#: ../Doc/library/html.parser.rst:85
msgid ":class:`.HTMLParser` Methods"
msgstr "Métodos :class:`.HTMLParser`"

#: ../Doc/library/html.parser.rst:87
msgid ":class:`HTMLParser` instances have the following methods:"
msgstr "instancias de :class:`HTMLParser` tienen los siguientes métodos:"

#: ../Doc/library/html.parser.rst:92
msgid ""
"Feed some text to the parser.  It is processed insofar as it consists of "
"complete elements; incomplete data is buffered until more data is fed or :"
"meth:`close` is called.  *data* must be :class:`str`."
msgstr ""
"Alimente un poco de texto al analizador. Se procesa en la medida en que "
"consta de elementos completos; los datos incompletos se almacenan en el "
"búfer hasta que se introducen más datos o se llama a :meth:`close`. *data* "
"debe ser :class:`str`."

#: ../Doc/library/html.parser.rst:99
msgid ""
"Force processing of all buffered data as if it were followed by an end-of-"
"file mark.  This method may be redefined by a derived class to define "
"additional processing at the end of the input, but the redefined version "
"should always call the :class:`HTMLParser` base class method :meth:`close`."
msgstr ""
"Fuerce el procesamiento de todos los datos almacenados como si fueran "
"seguidos por una marca de fin de archivo. Este método puede ser redefinido "
"por una clase derivada para definir un procesamiento adicional al final de "
"la entrada, pero la versión redefinida siempre debe llamar a :class:"
"`HTMLParser` método de clase base :meth:`close`."

#: ../Doc/library/html.parser.rst:107
msgid ""
"Reset the instance.  Loses all unprocessed data.  This is called implicitly "
"at instantiation time."
msgstr ""
"Restablecer la instancia. Pierde todos los datos no procesados. Esto se "
"llama implícitamente en el momento de la instanciación."

#: ../Doc/library/html.parser.rst:113
msgid "Return current line number and offset."
msgstr "Retorna el número de línea actual y el desplazamiento."

#: ../Doc/library/html.parser.rst:118
msgid ""
"Return the text of the most recently opened start tag.  This should not "
"normally be needed for structured processing, but may be useful in dealing "
"with HTML \"as deployed\" or for re-generating input with minimal changes "
"(whitespace between attributes can be preserved, etc.)."
msgstr ""
"Retorna el texto de la etiqueta de inicio abierta más recientemente. "
"Normalmente, esto no debería ser necesario para el procesamiento "
"estructurado, pero puede ser útil para tratar con HTML \"como implementado\" "
"o para volver a generar entradas con cambios mínimos (se puede preservar el "
"espacio en blanco entre los atributos, etc.)."

#: ../Doc/library/html.parser.rst:124
msgid ""
"The following methods are called when data or markup elements are "
"encountered and they are meant to be overridden in a subclass.  The base "
"class implementations do nothing (except for :meth:`~HTMLParser."
"handle_startendtag`):"
msgstr ""
"Los siguientes métodos se invocan cuando se encuentran datos o elementos de "
"marcado y deben anularse en una subclase. Las implementaciones de la clase "
"base no hacen nada (excepto :meth:`~HTMLParser.handle_startendtag`):"

#: ../Doc/library/html.parser.rst:131
#, fuzzy
msgid ""
"This method is called to handle the start tag of an element (e.g. ``<div "
"id=\"main\">``)."
msgstr ""
"Este método se llama para manejar el inicio de una etiqueta (por ejemplo, "
"``<div id=\"main\">``)."

#: ../Doc/library/html.parser.rst:133
msgid ""
"The *tag* argument is the name of the tag converted to lower case. The "
"*attrs* argument is a list of ``(name, value)`` pairs containing the "
"attributes found inside the tag's ``<>`` brackets.  The *name* will be "
"translated to lower case, and quotes in the *value* have been removed, and "
"character and entity references have been replaced."
msgstr ""
"El argumento *tag* es el nombre de la etiqueta convertida a minúsculas. El "
"argumento *attrs* es una lista de pares ``(nombre, valor)`` que contienen "
"los atributos encontrados dentro de los corchetes ``<>`` de la etiqueta. El "
"*name* se traducirá a minúsculas, se eliminarán las comillas en el *value* y "
"se reemplazarán las referencias de caracteres y entidades."

#: ../Doc/library/html.parser.rst:139
msgid ""
"For instance, for the tag ``<A HREF=\"https://www.cwi.nl/\">``, this method "
"would be called as ``handle_starttag('a', [('href', 'https://www.cwi."
"nl/')])``."
msgstr ""
"Por ejemplo, para la etiqueta ``<A HREF=\"https://www.cwi.nl/\">``, este "
"método se llamaría como ``handle_starttag('a', [('href', 'https : //www.cwi."
"nl/ ')])``."

#: ../Doc/library/html.parser.rst:142
msgid ""
"All entity references from :mod:`html.entities` are replaced in the "
"attribute values."
msgstr ""
"Todas las referencias de entidad de :mod:`html.entities` se reemplazan en "
"los valores de los atributos."

#: ../Doc/library/html.parser.rst:148
msgid ""
"This method is called to handle the end tag of an element (e.g. ``</div>``)."
msgstr ""
"Este método se llama para manejar la etiqueta final de un elemento (por "
"ejemplo, ``</div>``)"

#: ../Doc/library/html.parser.rst:150
msgid "The *tag* argument is the name of the tag converted to lower case."
msgstr ""
"El argumento *tag* es el nombre de la etiqueta convertida a minúsculas."

#: ../Doc/library/html.parser.rst:155
msgid ""
"Similar to :meth:`handle_starttag`, but called when the parser encounters an "
"XHTML-style empty tag (``<img ... />``).  This method may be overridden by "
"subclasses which require this particular lexical information; the default "
"implementation simply calls :meth:`handle_starttag` and :meth:"
"`handle_endtag`."
msgstr ""
"Similar a :meth:`handle_starttag`, pero llamado cuando el analizador "
"encuentra una etiqueta vacía de estilo XHTML (``<img .../>``). Este método "
"puede ser anulado por subclases que requieren esta información léxica "
"particular; la implementación predeterminada simplemente llama :meth:"
"`handle_starttag` y :meth:`handle_endtag`."

#: ../Doc/library/html.parser.rst:163
msgid ""
"This method is called to process arbitrary data (e.g. text nodes and the "
"content of ``<script>...</script>`` and ``<style>...</style>``)."
msgstr ""
"Este método se llama para procesar datos arbitrarios (por ejemplo, nodos de "
"texto y el contenido de ``<script>...</script>`` y ``<style>...</style>``)."

#: ../Doc/library/html.parser.rst:169
msgid ""
"This method is called to process a named character reference of the form "
"``&name;`` (e.g. ``&gt;``), where *name* is a general entity reference (e.g. "
"``'gt'``).  This method is never called if *convert_charrefs* is ``True``."
msgstr ""
"Este método se llama para procesar una referencia de caracteres con nombre "
"del formulario ``&name;`` (por ejemplo, ``&gt;``), donde *name* es una "
"referencia de entidad general (por ejemplo, ``'gt'``). Este método nunca se "
"llama si *convert_charrefs* es ``True``."

#: ../Doc/library/html.parser.rst:177
#, fuzzy, python-brace-format
msgid ""
"This method is called to process decimal and hexadecimal numeric character "
"references of the form :samp:`&#{NNN};` and :samp:`&#x{NNN};`.  For example, "
"the decimal equivalent for ``&gt;`` is ``&#62;``, whereas the hexadecimal is "
"``&#x3E;``; in this case the method will receive ``'62'`` or ``'x3E'``.  "
"This method is never called if *convert_charrefs* is ``True``."
msgstr ""
"Este método se llama para procesar referencias de caracteres numéricos "
"decimales y hexadecimales de la forma ``&#NNN;`` y ``&#xNNN;``. Por ejemplo, "
"el equivalente decimal para ``&gt;`` es ``&#62;``, mientras que el "
"hexadecimal es ``&#x3E;``; en este caso, el método recibirá ``'62'`` o "
"``'x3E'``. Este método nunca se llama si *convert_charrefs* es ``True``."

#: ../Doc/library/html.parser.rst:186
msgid ""
"This method is called when a comment is encountered (e.g. ``<!--comment--"
">``)."
msgstr ""
"Este método se llama cuando se encuentra un comentario (por ejemplo, ``<!--"
"comment-->``)."

#: ../Doc/library/html.parser.rst:188
msgid ""
"For example, the comment ``<!-- comment -->`` will cause this method to be "
"called with the argument ``' comment '``."
msgstr ""
"Por ejemplo, el comentario ``<! - comment ->`` hará que se llame a este "
"método con el argumento ``'comment'``."

#: ../Doc/library/html.parser.rst:191
msgid ""
"The content of Internet Explorer conditional comments (condcoms) will also "
"be sent to this method, so, for ``<!--[if IE 9]>IE9-specific content<!"
"[endif]-->``, this method will receive ``'[if IE 9]>IE9-specific content<!"
"[endif]'``."
msgstr ""
"El contenido de los comentarios condicionales de Internet Explorer "
"(*condcoms*) también se enviará a este método, por lo tanto, para ``<!--[if "
"IE 9]>IE9-specific content<![endif]-->``, este método recibirá ``'[if IE "
"9]>IE9-specific content<![endif]'``."

#: ../Doc/library/html.parser.rst:198
msgid ""
"This method is called to handle an HTML doctype declaration (e.g. ``<!"
"DOCTYPE html>``)."
msgstr ""
"Este método se llama para manejar una declaración de tipo de documento HTML "
"(por ejemplo, ``<!DOCTYPE html>``)."

#: ../Doc/library/html.parser.rst:201
msgid ""
"The *decl* parameter will be the entire contents of the declaration inside "
"the ``<!...>`` markup (e.g. ``'DOCTYPE html'``)."
msgstr ""
"El parámetro *decl* será todo el contenido de la declaración dentro del "
"``<!...>`` *markup* (por ejemplo, ``'DOCTYPE html'``)."

#: ../Doc/library/html.parser.rst:207
msgid ""
"Method called when a processing instruction is encountered.  The *data* "
"parameter will contain the entire processing instruction. For example, for "
"the processing instruction ``<?proc color='red'>``, this method would be "
"called as ``handle_pi(\"proc color='red'\")``.  It is intended to be "
"overridden by a derived class; the base class implementation does nothing."
msgstr ""
"Método llamado cuando se encuentra una instrucción de procesamiento. El "
"parámetro *data* contendrá toda la instrucción de procesamiento. Por "
"ejemplo, para la instrucción de procesamiento ``<?proc color='red'>``, este "
"método se llamaría como ``handle_pi(\"proc color='red'\")``. Está destinado "
"a ser anulado por una clase derivada; La implementación de la clase base no "
"hace nada."

#: ../Doc/library/html.parser.rst:215
msgid ""
"The :class:`HTMLParser` class uses the SGML syntactic rules for processing "
"instructions.  An XHTML processing instruction using the trailing ``'?'`` "
"will cause the ``'?'`` to be included in *data*."
msgstr ""
"La clase :class:`HTMLParser` utiliza las reglas sintácticas SGML para "
"procesar instrucciones. Una instrucción de procesamiento XHTML que use el "
"``'?'`` final hará que se incluya el ``'?'`` en *data*."

#: ../Doc/library/html.parser.rst:222
msgid ""
"This method is called when an unrecognized declaration is read by the parser."
msgstr ""
"Se llama a este método cuando el analizador lee una declaración no "
"reconocida."

#: ../Doc/library/html.parser.rst:224
msgid ""
"The *data* parameter will be the entire contents of the declaration inside "
"the ``<![...]>`` markup.  It is sometimes useful to be overridden by a "
"derived class.  The base class implementation does nothing."
msgstr ""
"El parámetro *data* será el contenido completo de la declaración dentro del "
"marcado ``<! [...]>``. A veces es útil ser reemplazado por una clase "
"derivada. La implementación de la clase base no hace nada."

#: ../Doc/library/html.parser.rst:232
msgid "Examples"
msgstr "Ejemplos"

#: ../Doc/library/html.parser.rst:234
#, fuzzy
msgid ""
"The following class implements a parser that will be used to illustrate more "
"examples:"
msgstr ""
"La siguiente clase implementa un analizador que se utilizará para ilustrar "
"más ejemplos::"

#: ../Doc/library/html.parser.rst:237
msgid ""
"from html.parser import HTMLParser\n"
"from html.entities import name2codepoint\n"
"\n"
"class MyHTMLParser(HTMLParser):\n"
"    def handle_starttag(self, tag, attrs):\n"
"        print(\"Start tag:\", tag)\n"
"        for attr in attrs:\n"
"            print(\"     attr:\", attr)\n"
"\n"
"    def handle_endtag(self, tag):\n"
"        print(\"End tag  :\", tag)\n"
"\n"
"    def handle_data(self, data):\n"
"        print(\"Data     :\", data)\n"
"\n"
"    def handle_comment(self, data):\n"
"        print(\"Comment  :\", data)\n"
"\n"
"    def handle_entityref(self, name):\n"
"        c = chr(name2codepoint[name])\n"
"        print(\"Named ent:\", c)\n"
"\n"
"    def handle_charref(self, name):\n"
"        if name.startswith('x'):\n"
"            c = chr(int(name[1:], 16))\n"
"        else:\n"
"            c = chr(int(name))\n"
"        print(\"Num ent  :\", c)\n"
"\n"
"    def handle_decl(self, data):\n"
"        print(\"Decl     :\", data)\n"
"\n"
"parser = MyHTMLParser()"
msgstr ""

#: ../Doc/library/html.parser.rst:273
#, fuzzy
msgid "Parsing a doctype:"
msgstr "Analizando un *doctype*::"

#: ../Doc/library/html.parser.rst:275
msgid ""
">>> parser.feed('<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" '\n"
"...             '\"http://www.w3.org/TR/html4/strict.dtd\">')\n"
"Decl     : DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3."
"org/TR/html4/strict.dtd\""
msgstr ""

#: ../Doc/library/html.parser.rst:281
#, fuzzy
msgid "Parsing an element with a few attributes and a title:"
msgstr "Analizando un elemento con algunos atributos y un título::"

#: ../Doc/library/html.parser.rst:283
msgid ""
">>> parser.feed('<img src=\"python-logo.png\" alt=\"The Python logo\">')\n"
"Start tag: img\n"
"     attr: ('src', 'python-logo.png')\n"
"     attr: ('alt', 'The Python logo')\n"
">>>\n"
">>> parser.feed('<h1>Python</h1>')\n"
"Start tag: h1\n"
"Data     : Python\n"
"End tag  : h1"
msgstr ""

#: ../Doc/library/html.parser.rst:295
#, fuzzy
msgid ""
"The content of ``script`` and ``style`` elements is returned as is, without "
"further parsing:"
msgstr ""
"El contenido de los elementos ``script`` y ``style`` se retorna tal cual, "
"sin más análisis ::"

#: ../Doc/library/html.parser.rst:298
#, python-brace-format
msgid ""
">>> parser.feed('<style type=\"text/css\">#python { color: green }</"
"style>')\n"
"Start tag: style\n"
"     attr: ('type', 'text/css')\n"
"Data     : #python { color: green }\n"
"End tag  : style\n"
"\n"
">>> parser.feed('<script type=\"text/javascript\">'\n"
"...             'alert(\"<strong>hello!</strong>\");</script>')\n"
"Start tag: script\n"
"     attr: ('type', 'text/javascript')\n"
"Data     : alert(\"<strong>hello!</strong>\");\n"
"End tag  : script"
msgstr ""

#: ../Doc/library/html.parser.rst:313
#, fuzzy
msgid "Parsing comments:"
msgstr "Analizando comentarios::"

#: ../Doc/library/html.parser.rst:315
msgid ""
">>> parser.feed('<!--a comment-->'\n"
"...             '<!--[if IE 9]>IE-specific content<![endif]-->')\n"
"Comment  : a comment\n"
"Comment  : [if IE 9]>IE-specific content<![endif]"
msgstr ""

#: ../Doc/library/html.parser.rst:322
#, fuzzy
msgid ""
"Parsing named and numeric character references and converting them to the "
"correct char (note: these 3 references are all equivalent to ``'>'``):"
msgstr ""
"Analizar referencias de caracteres con nombre y numéricos y convertirlos al "
"carácter correcto (nota: estas 3 referencias son todas equivalentes a "
"``'>'``)::"

#: ../Doc/library/html.parser.rst:325
msgid ""
">>> parser = MyHTMLParser()\n"
">>> parser.feed('&gt;&#62;&#x3E;')\n"
"Data     : >>>\n"
"\n"
">>> parser = MyHTMLParser(convert_charrefs=False)\n"
">>> parser.feed('&gt;&#62;&#x3E;')\n"
"Named ent: >\n"
"Num ent  : >\n"
"Num ent  : >"
msgstr ""

#: ../Doc/library/html.parser.rst:337
#, fuzzy
msgid ""
"Feeding incomplete chunks to :meth:`~HTMLParser.feed` works, but :meth:"
"`~HTMLParser.handle_data` might be called more than once (unless "
"*convert_charrefs* is set to ``True``):"
msgstr ""
"La alimentación de fragmentos incompletos a :meth:`~HTMLParser.feed` "
"funciona, pero :meth:`~HTMLParser.handle_data` podría llamarse más de una "
"vez (a menos que *convert_charrefs* esté configurado como ``True``)::"

#: ../Doc/library/html.parser.rst:341
msgid ""
">>> for chunk in ['<sp', 'an>buff', 'ered', ' text</s', 'pan>']:\n"
"...     parser.feed(chunk)\n"
"...\n"
"Start tag: span\n"
"Data     : buff\n"
"Data     : ered\n"
"Data     :  text\n"
"End tag  : span"
msgstr ""

#: ../Doc/library/html.parser.rst:352
#, fuzzy
msgid "Parsing invalid HTML (e.g. unquoted attributes) also works:"
msgstr ""
"Analizar HTML no válido (por ejemplo, atributos sin comillas) también "
"funciona::"

#: ../Doc/library/html.parser.rst:354
msgid ""
">>> parser.feed('<p><a class=link href=#main>tag soup</p ></a>')\n"
"Start tag: p\n"
"Start tag: a\n"
"     attr: ('class', 'link')\n"
"     attr: ('href', '#main')\n"
"Data     : tag soup\n"
"End tag  : p\n"
"End tag  : a"
msgstr ""

#: ../Doc/library/html.parser.rst:9
msgid "HTML"
msgstr ""

#: ../Doc/library/html.parser.rst:9
msgid "XHTML"
msgstr ""