Cómo detectar la cadena contiene un html (puede ser de html4, html5, sólo parciales de html dentro de texto)? No necesito una versión de HTML, sino más bien si la cadena es sólo un texto o contiene un html. El texto es normalmente de varias líneas con líneas vacías

Actualización:

entradas de ejemplo:

html:

<head><title>I'm title</title></head>
Hello, <b>world</b>

no html:

<ht fldf d><
<html><head> head <body></body> html
¿por qué necesita saber? ¿qué estás planeando hacer de manera diferente?
sólo detectar si la cadena contiene html, a continuación, quite la cadena o imprimir

OriginalEl autor static | 2014-07-20

4 Comentarios

  1. 25

    Puede utilizar un analizador de HTML, como BeautifulSoup. Tenga en cuenta que lo que realmente trata de hacer lo mejor para analizar un HTML, incluso HTML roto, puede ser muy y no muy indulgentes dependiendo de la analizador subyacente:

    >>> from bs4 import BeautifulSoup
    >>> html = """<html>
    ... <head><title>I'm title</title></head>
    ... </html>"""
    >>> non_html = "This is not an html"
    >>> bool(BeautifulSoup(html, "html.parser").find())
    True
    >>> bool(BeautifulSoup(non_html, "html.parser").find())
    False

    Esto, básicamente, trata de encontrar cualquier elemento html en el interior de la cadena. Si se encuentra – el resultado es True.

    Otro ejemplo con un fragmento de HTML:

    >>> html = "Hello, <b>world</b>"
    >>> bool(BeautifulSoup(html, "html.parser").find())
    True

    Como alternativa, puede utilizar lxml.html:

    >>> import lxml.html
    >>> html = 'Hello, <b>world</b>'
    >>> non_html = "<ht fldf d><"
    >>> lxml.html.fromstring(html).find('.//*') is not None
    True
    >>> lxml.html.fromstring(non_html).find('.//*') is not None
    False
    En este trabajo de fragmentos de HTML?
    sí, se añadió un ejemplo.
    ¿qué acerca de non-html = "<html><head> head <body></body> html" bool(BeautifulSoup(non_html, "html.parser").find()) => True? No es un fragmento de código html
    incluso non_html = "<html head> head <body jdkjs /body> html dkslfjglangaiowmgiowe" pasará la prueba 🙁
    bueno, esta sería True, causa BeautifulSoup trata de hacer lo mejor para parsear el html y ser tolerantes. Se iba a transformar en <html><head> head <body></body> html</head></html>.

    OriginalEl autor alecxe

  2. 7

    Una manera en que yo pensaba era cruzan etiquetas de inicio y fin encontró al intentar analizar el texto como HTML y la intersección de este conjunto con un conocido conjunto de aceptable a los elementos HTMl.

    Ejemplo:

    #!/usr/bin/env python
    
    from __future__ import print_function
    
    from HTMLParser import HTMLParser
    
    
    from html5lib.sanitizer import HTMLSanitizerMixin
    
    
    class TestHTMLParser(HTMLParser):
    
        def __init__(self, *args, **kwargs):
            HTMLParser.__init__(self, *args, **kwargs)
    
            self.elements = set()
    
        def handle_starttag(self, tag, attrs):
            self.elements.add(tag)
    
        def handle_endtag(self, tag):
            self.elements.add(tag)
    
    
    def is_html(text):
        elements = set(HTMLSanitizerMixin.acceptable_elements)
    
        parser = TestHTMLParser()
        parser.feed(text)
    
        return True if parser.elements.intersection(elements) else False
    
    
    print(is_html("foo bar"))
    print(is_html("<p>Hello World!</p>"))
    print(is_html("<html><head><title>Title</title></head><body><p>Hello!</p></body></html>"))  # noqa

    De salida:

    $ python foo.py
    False
    True
    True

    Esto funciona para el parcial de texto que contiene un subconjunto de los elementos HTML.

    NB: Esto hace que el uso de la html5lib por lo que puede no funcionar para otros tipos de documentos, necesariamente, pero la técnica se puede adaptar fácilmente.

    Es básicamente la misma solución como el suyo, sólo una biblioteca diferente y el uso de intersección de conjuntos de elementos conocidos 😛

    OriginalEl autor James Mills

  3. -1

    De verificación para poner fin a las etiquetas. Este es el más simple y más robusto que yo creo.

    "</html>" in possibly_html

    Si hay un final etiqueta html, luego se ve como html, de lo contrario no tanto.

    Esta es una buena respuesta, suponiendo que la entrada es una completa página HTML (ha </html> en ella. No trabajo para el parcial de HTML (como <b>some word</b>).
    Este método puede ser ampliado a la búsqueda de cualquier html etiqueta final, como b. Una expresión regular podría hacerlo más rápido, pero el principio sigue siendo el mismo.
    Como usted no sabe lo que el potencial de las etiquetas HTML en el texto inicial de esta técnica no funciona tan bien :/

    OriginalEl autor Andrew Johnson

  4. -5

    Expansión en el anterior post me gustaría hacer algo como esto, por algo rápido y sencillo:

    import sys, os
    
    if os.path.exists("file.html"):
        checkfile=open("file.html", mode="r", encoding="utf-8")
        ishtml = False
        for line in checkfile:
            line=line.strip()
            if line == "</html>"
                ishtml = True
        if ishtml:
            print("This is an html file")
        else:
            print("This is not an html file")
    ¿qué acerca de los parciales y de lo que acerca de la no-estilo html (es decir, </html> no es toda la línea) (ok, aquí uno puede usar lo que «contiene» en lugar de «==»)
    Tienes razón, no creo de que, en ese caso, probablemente voy a modificar si == «</html>»: si «</html>» en línea:

    OriginalEl autor Donkyhotay

Dejar respuesta

Please enter your comment!
Please enter your name here