example - beautifulsoup python
Analizando HTML en python-lxml o BeautifulSoup? ¿Cuál de estos es mejor para qué tipo de propósitos? (7)
Por lo que puedo ver, las dos principales bibliotecas de análisis de HTML en Python son lxml y BeautifulSoup. Elegí BeautifulSoup para un proyecto en el que estoy trabajando, pero lo elegí sin más motivo que encontrar la sintaxis un poco más fácil de aprender y entender. Pero veo que mucha gente parece favorecer a lxml y he escuchado que lxml es más rápido.
Entonces, me pregunto cuáles son las ventajas de una sobre la otra. ¿Cuándo quisiera usar lxml y cuándo sería mejor usar BeautifulSoup? ¿Hay alguna otra biblioteca que valga la pena considerar?
De seguro, usaría EHP. Es más rápido que lxml, mucho más elegante y simple de usar.
Revisa. https://github.com/iogf/ehp
<body ><em > foo <font color="red" ></font></em></body>
from ehp import *
data = ''''''<html> <body> <em> Hello world. </em> </body> </html>''''''
html = Html()
dom = html.feed(data)
for ind in dom.find(''em''):
print ind.text()
Salida:
Hello world.
En resumen, lxml se posiciona como un analizador html y xml de calidad de producción ultrarrápida que, dicho sea de paso, también incluye un módulo de soupparser para recurrir a la funcionalidad de BeautifulSoup. BeautifulSoup es un proyecto para una sola persona, diseñado para ahorrarle tiempo y extraer datos rápidamente de html o xml pobremente formados.
La documentación de lxml dice que ambos analizadores tienen ventajas y desventajas. Por esta razón, lxml proporciona un soupparser para que pueda cambiar de un lado a otro. Citando
BeautifulSoup utiliza un enfoque de análisis diferente. No es un analizador de HTML real, pero usa expresiones regulares para sumergirse en la sopa de etiquetas. Por lo tanto, es más indulgente en algunos casos y menos bueno en otros. No es raro que lxml / libxml2 analice y corrija mejor el código HTML roto, pero BeautifulSoup tiene soporte adicional para la detección de codificación. Depende mucho de la entrada que el analizador funcione mejor.
Al final están diciendo,
La desventaja de usar este analizador es que es mucho más lento que el analizador HTML de lxml. Por lo tanto, si el rendimiento es importante, es posible que desee considerar el uso del analizador de sopa solo como alternativa para ciertos casos.
Si los entiendo correctamente, significa que el analizador de sopa es más robusto; puede tratar con una "sopa" de etiquetas mal formadas mediante el uso de expresiones regulares, mientras que lxml es más sencillo y solo analiza cosas y construye un árbol como usted esperaría Supongo que también se aplica a BeautifulSoup sí, no solo al soupparser de lxml para lxml .
También muestran cómo beneficiarse de la detección de codificación de BeautifulSoup , mientras aún se analiza rápidamente con lxml :
>>> from BeautifulSoup import UnicodeDammit
>>> def decode_html(html_string):
... converted = UnicodeDammit(html_string, isHTML=True)
... if not converted.unicode:
... raise UnicodeDecodeError(
... "Failed to detect encoding, tried [%s]",
... '', ''.join(converted.triedEncodings))
... # print converted.originalEncoding
... return converted.unicode
>>> root = lxml.html.fromstring(decode_html(tag_soup))
(Misma fuente: http://lxml.de/elementsoup.html ).
En palabras del creador de BeautifulSoup ,
¡Eso es! ¡Que te diviertas! Escribí Beautiful Soup para ahorrarle tiempo a todos. Una vez que te hayas acostumbrado, deberías poder intercambiar datos de sitios web mal diseñados en solo unos minutos. Envíeme un correo electrónico si tiene algún comentario, tiene problemas o desea que sepa sobre su proyecto que utiliza Beautiful Soup.
--Leonard
Citado de la documentación de Beautiful Soup .
Espero que esto esté ahora claro. La sopa es un brillante proyecto de una sola persona diseñado para ahorrarle tiempo para extraer datos de sitios web mal diseñados. El objetivo es ahorrarle tiempo en este momento, para hacer el trabajo, no necesariamente para ahorrarle tiempo a largo plazo, y definitivamente no para optimizar el rendimiento de su software.
Además, desde el sitio web lxml ,
lxml se ha descargado del Python Package Index más de dos millones de veces y también está disponible directamente en muchas distribuciones de paquetes, por ejemplo, para Linux o MacOS-X.
Y, ¿Por qué lxml? ,
Las bibliotecas C libxml2 y libxslt tienen enormes beneficios: ... Cumple con los estándares ... Con todas las funciones ... rápido. ¡rápido! ¡RÁPIDO! ... lxml es un nuevo enlace de Python para libxml2 y libxslt ...
He utilizado lxml con gran éxito para analizar HTML. Parece que también hace un buen trabajo al manejar HTML "espeso". Lo recomiendo encarecidamente
Aquí hay una prueba rápida que tuve por ahí para tratar de manejar algunos feos HTML:
import unittest
from StringIO import StringIO
from lxml import etree
class TestLxmlStuff(unittest.TestCase):
bad_html = """
<html>
<head><title>Test!</title></head>
<body>
<h1>Here''s a heading
<p>Here''s some text
<p>And some more text
<b>Bold!</b></i>
<table>
<tr>row
<tr><td>test1
<td>test2
</tr>
<tr>
<td colspan=2>spanning two
</table>
</body>
</html>"""
def test_soup(self):
"""Test lxml''s parsing of really bad HTML"""
parser = etree.HTMLParser()
tree = etree.parse(StringIO(self.bad_html), parser)
self.assertEqual(len(tree.xpath(''//tr'')), 3)
self.assertEqual(len(tree.xpath(''//td'')), 3)
self.assertEqual(len(tree.xpath(''//i'')), 0)
#print(etree.tostring(tree.getroot(), pretty_print=False, method="html"))
if __name__ == ''__main__'':
unittest.main()
No use BeautifulSoup, use lxml.soupparser, entonces está sentado sobre el poder de lxml y puede usar los buenos trozos de BeautifulSoup que es lidiar con HTML realmente roto y horrible.
here se puede encontrar una comparación de velocidad algo obsoleta, que recomienda claramente lxml, ya que las diferencias de velocidad parecen drásticas.
Pyquery proporciona la interfaz del selector jQuery a Python (usando lxml bajo el capó).
http://pypi.python.org/pypi/pyquery
Es realmente increíble, ya no uso nada más.
Para empezar, BeautifulSoup ya no se mantiene activamente, y el autor incluso recomienda alternativas como lxml.
Citando de la página vinculada:
La versión 3.1.0 de Beautiful Soup es significativamente peor en el mundo real que en la versión 3.0.8. Los problemas más comunes son el manejo incorrecto de etiquetas, los errores de "etiqueta de inicio mal formada" y los errores de "etiqueta de finalización incorrecta". Esta página explica qué sucedió, cómo se abordará el problema y qué puede hacer ahora mismo.
Esta página fue escrita originalmente en marzo de 2009. Desde entonces, la serie 3.2 ha sido lanzada, reemplazando la serie 3.1, y el desarrollo de la serie 4.x ha comenzado. Esta página permanecerá para propósitos históricos.
tl; dr
Use 3.2.0 en su lugar.