Extraer texto de un archivo HTML usando Python

243

Me gustaría extraer el texto de un archivo HTML usando Python. Quiero esencialmente el mismo resultado que obtendría si copiara el texto de un navegador y lo pegue en el bloc de notas.

Me gustaría algo más robusto que usar expresiones regulares que pueden fallar en HTML mal formado. He visto a muchas personas recomendar Beautiful Soup, pero he tenido algunos problemas para usarlo. Por un lado, recogió texto no deseado, como la fuente de JavaScript. Además, no interpretó entidades HTML. Por ejemplo, esperaría & # 39; en la fuente HTML para convertirlo en un apóstrofe en el texto, como si hubiera pegado el contenido del navegador en el bloc de notas.

La actualización html2text parece prometedora. Maneja las entidades HTML correctamente e ignora JavaScript. Sin embargo, no produce exactamente texto plano; produce rebajas que luego tendrían que convertirse en texto sin formato. Viene sin ejemplos ni documentación, pero el código se ve limpio.

Preguntas relacionadas:

python html text html-content-extraction John D. Cook
fuente
Durante bastante tiempo, las personas parecen encontrar que mi respuesta NLTK (bastante reciente) es extremadamente útil, por lo que es posible que desee considerar cambiar la respuesta aceptada. ¡Gracias!
Shatu
1
¡Nunca pensé que me encontraría con una pregunta del autor de mi blog favorito! El esfuerzo!
Ryan G
1
@Shatu Ahora que su solución ya no es válida, es posible que desee eliminar su comentario. ¡Gracias! ;)
Sanađошƒаӽ

Respuestas:

136

html2text es un programa de Python que hace un trabajo bastante bueno en esto.

RexE
fuente
55
bit es gpl 3.0, lo que significa que puede ser incompatible
frog32
138
¡Asombroso! Su autor es RIP Aaron Swartz.
Atul Arvind
2
¿Alguien encontró alguna alternativa a html2text debido a GPL 3.0?
jontsai
1
La GPL no es tan mala como la gente quiere que sea. Aaron lo sabía mejor.
Steve K
2
Intenté html2text y nltk pero no funcionaron para mí. Terminé yendo con Beautiful Soup 4, que funciona muy bien (sin juego de palabras).
Ryan
149

El mejor fragmento de código que encontré para extraer texto sin obtener JavaScript o cosas no deseadas:

import urllib
from bs4 import BeautifulSoup

url = "http://news.bbc.co.uk/2/hi/health/2284783.stm"
html = urllib.urlopen(url).read()
soup = BeautifulSoup(html)

# kill all script and style elements
for script in soup(["script", "style"]):
    script.extract()    # rip it out

# get text
text = soup.get_text()

# break into lines and remove leading and trailing space on each
lines = (line.strip() for line in text.splitlines())
# break multi-headlines into a line each
chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
# drop blank lines
text = '\n'.join(chunk for chunk in chunks if chunk)

print(text)

Solo tiene que instalar BeautifulSoup antes:

pip install beautifulsoup4
PeYoTlL
fuente
2
¿Cómo si queremos seleccionar alguna línea, acabo de decir, línea # 3?
hepidad
3
¡Los guiones asesinos mordieron, salvador!
Nanda
2
Después de pasar por muchas respuestas de stackoverflow, siento que esta es la mejor opción para mí. Un problema que encontré es que las líneas se agregaron juntas en algunos casos. Pude superarlo agregando un separador en la función get_text:text = soup.get_text(separator=' ')
Joswin KJ
55
En lugar de lo soup.get_text()que solía soup.body.get_text(), para no obtener ningún texto del <headelemento>, como el título.
Sjoerd
10
Para Python 3,from urllib.request import urlopen
Jacob Kalakal Joseph
99

NOTA: NTLK ya no admite la clean_htmlfunción

Respuesta original a continuación, y una alternativa en las secciones de comentarios.

Use NLTK

Perdí mis 4-5 horas arreglando los problemas con html2text. Afortunadamente pude encontrar NLTK.
Funciona por arte de magia. 

import nltk   
from urllib import urlopen

url = "http://news.bbc.co.uk/2/hi/health/2284783.stm"    
html = urlopen(url).read()    
raw = nltk.clean_html(html)  
print(raw)
Shatu
fuente
8
a veces eso es suficiente :)
Sharmila
8
Quiero votar esto miles de veces. Estaba atrapado en el infierno de expresiones regulares, pero ahora veo la sabiduría de NLTK.
BenDundee
26
Aparentemente, clean_html ya no es compatible: github.com/nltk/nltk/commit/…
alexanderlukanin13
55
importar una biblioteca pesada como nltk para una tarea tan simple sería demasiado
richie
54
@ alexanderlukanin13 De la fuente:raise NotImplementedError ("To remove HTML markup, use BeautifulSoup's get_text() function")
Chris Arena
54

Me encontré enfrentando el mismo problema hoy. Escribí un analizador HTML muy simple para eliminar el contenido entrante de todas las marcas, devolviendo el texto restante con solo un mínimo de formato.

from HTMLParser import HTMLParser
from re import sub
from sys import stderr
from traceback import print_exc

class _DeHTMLParser(HTMLParser):
    def __init__(self):
        HTMLParser.__init__(self)
        self.__text = []

    def handle_data(self, data):
        text = data.strip()
        if len(text) > 0:
            text = sub('[ \t\r\n]+', ' ', text)
            self.__text.append(text + ' ')

    def handle_starttag(self, tag, attrs):
        if tag == 'p':
            self.__text.append('\n\n')
        elif tag == 'br':
            self.__text.append('\n')

    def handle_startendtag(self, tag, attrs):
        if tag == 'br':
            self.__text.append('\n\n')

    def text(self):
        return ''.join(self.__text).strip()


def dehtml(text):
    try:
        parser = _DeHTMLParser()
        parser.feed(text)
        parser.close()
        return parser.text()
    except:
        print_exc(file=stderr)
        return text


def main():
    text = r'''
        <html>
            <body>
                <b>Project:</b> DeHTML<br>
                <b>Description</b>:<br>
                This small script is intended to allow conversion from HTML markup to 
                plain text.
            </body>
        </html>
    '''
    print(dehtml(text))


if __name__ == '__main__':
    main()
xperroni
fuente
55
Esta parece ser la forma más sencilla de hacer esto en Python (2.7) utilizando solo los módulos predeterminados. Lo cual es realmente tonto, ya que esto es algo tan comúnmente necesario y no hay una buena razón por la cual no haya un analizador para esto en el módulo HTMLParser predeterminado.
Ingmar Hupp
2
No creo que convierta los caracteres HTML en Unicode, ¿verdad? Por ejemplo, &amp;no se convertirá en &, ¿verdad?
Speedplane
Para uso en Python 3from html.parser import HTMLParser
sebhaase
14

Aquí hay una versión de la respuesta de xperroni que es un poco más completa. Omite secciones de guiones y estilos y traduce charrefs (por ejemplo, & # 39;) y entidades HTML (por ejemplo, & amp;).

También incluye un convertidor inverso trivial de texto plano a HTML.

"""
HTML <-> text conversions.
"""
from HTMLParser import HTMLParser, HTMLParseError
from htmlentitydefs import name2codepoint
import re

class _HTMLToText(HTMLParser):
    def __init__(self):
        HTMLParser.__init__(self)
        self._buf = []
        self.hide_output = False

    def handle_starttag(self, tag, attrs):
        if tag in ('p', 'br') and not self.hide_output:
            self._buf.append('\n')
        elif tag in ('script', 'style'):
            self.hide_output = True

    def handle_startendtag(self, tag, attrs):
        if tag == 'br':
            self._buf.append('\n')

    def handle_endtag(self, tag):
        if tag == 'p':
            self._buf.append('\n')
        elif tag in ('script', 'style'):
            self.hide_output = False

    def handle_data(self, text):
        if text and not self.hide_output:
            self._buf.append(re.sub(r'\s+', ' ', text))

    def handle_entityref(self, name):
        if name in name2codepoint and not self.hide_output:
            c = unichr(name2codepoint[name])
            self._buf.append(c)

    def handle_charref(self, name):
        if not self.hide_output:
            n = int(name[1:], 16) if name.startswith('x') else int(name)
            self._buf.append(unichr(n))

    def get_text(self):
        return re.sub(r' +', ' ', ''.join(self._buf))

def html_to_text(html):
    """
    Given a piece of HTML, return the plain text it contains.
    This handles entities and char refs, but not javascript and stylesheets.
    """
    parser = _HTMLToText()
    try:
        parser.feed(html)
        parser.close()
    except HTMLParseError:
        pass
    return parser.get_text()

def text_to_html(text):
    """
    Convert the given text to html, wrapping what looks like URLs with <a> tags,
    converting newlines to <br> tags and converting confusing chars into html
    entities.
    """
    def f(mo):
        t = mo.group()
        if len(t) == 1:
            return {'&':'&amp;', "'":'&#39;', '"':'&quot;', '<':'&lt;', '>':'&gt;'}.get(t)
        return '<a href="%s">%s</a>' % (t, t)
    return re.sub(r'https?://[^] ()"\';]+|[&\'"<>]', f, text)
bit4
fuente
versión de python 3: gist.github.com/Crazometer/af441bc7dc7353d41390a59f20f07b51
Crazometer
En get_text, '' .join debería ser '' .join. Debe haber un espacio vacío, de lo contrario, algunos de los textos se unirán.
Obinna Nnenanya
1
Además, esto no capturará TODOS los textos, excepto que incluya otras etiquetas de contenedor de texto como H1, H2 ..., span, etc. Tuve que ajustarlo para una mejor cobertura.
Obinna Nnenanya
11

Sé que hay una gran cantidad de respuestas ya, pero el más elegentPackage y Pythonic solución que he encontrado es descrita, en parte, aquí .

from bs4 import BeautifulSoup

text = ''.join(BeautifulSoup(some_html_string, "html.parser").findAll(text=True))

Actualizar

Según el comentario de Fraser, aquí hay una solución más elegante:

from bs4 import BeautifulSoup

clean_text = ''.join(BeautifulSoup(some_html_string, "html.parser").stripped_strings)
Floyd
fuente
2
Para evitar una advertencia, especifique un analizador para que BeautifulSoup lo use:text = ''.join(BeautifulSoup(some_html_string, "lxml").findAll(text=True))
Floyd el
Puede usar el generador stripped_strings para evitar espacios en blanco excesivos, es decirclean_text = ''.join(BeautifulSoup(some_html_string, "html.parser").stripped_strings
Fraser,
8

También puede usar el método html2text en la biblioteca de stripogram.

from stripogram import html2text
text = html2text(your_html_string)

Para instalar stripogram, ejecute sudo easy_install stripogram

GeekTantra
fuente
23
Este módulo, de acuerdo con su página de pypi , está en desuso: "¡A menos que tenga alguna razón histórica para usar este paquete, le aconsejaría que no lo haga!"
intuido
7

Hay una biblioteca de patrones para la minería de datos.

http://www.clips.ua.ac.be/pages/pattern-web

Incluso puedes decidir qué etiquetas guardar:

s = URL('http://www.clips.ua.ac.be').download()
s = plaintext(s, keep={'h1':[], 'h2':[], 'strong':[], 'a':['href']})
print s
Nuncjo
fuente
6

PyParsing hace un gran trabajo. La wiki de PyParsing fue eliminada, así que aquí hay otra ubicación donde hay ejemplos del uso de PyParsing ( enlace de ejemplo ). Una razón para invertir un poco de tiempo con el pirateo es que también ha escrito un manual muy breve, muy bien organizado, O'Reilly Short Cut, que también es económico.

Dicho esto, uso mucho BeautifulSoup y no es tan difícil tratar los problemas de las entidades, puedes convertirlos antes de ejecutar BeautifulSoup.

Buena suerte

PyNEwbie
fuente
1
El enlace está muerto o agrio.
Yvette
4

Esta no es exactamente una solución de Python, pero convertirá el texto que Javascript generaría en texto, lo que creo que es importante (por ejemplo, google.com). El navegador Enlaces (no Lynx) tiene un motor Javascript y convertirá la fuente a texto con la opción -dump.

Entonces podrías hacer algo como:

fname = os.tmpnam()
fname.write(html_source)
proc = subprocess.Popen(['links', '-dump', fname], 
                        stdout=subprocess.PIPE,
                        stderr=open('/dev/null','w'))
text = proc.stdout.read()
Andrés
fuente
4

En lugar del módulo HTMLParser, consulte htmllib. Tiene una interfaz similar, pero hace más del trabajo por usted. (Es bastante antiguo, por lo que no es de mucha ayuda en términos de deshacerse de javascript y css. Podría crear una clase derivada, y agregar métodos con nombres como start_script y end_style (consulte los documentos de Python para más detalles), pero es difícil hacer esto de manera confiable para HTML mal formado.) De todos modos, aquí hay algo simple que imprime el texto plano en la consola

from htmllib import HTMLParser, HTMLParseError
from formatter import AbstractFormatter, DumbWriter
p = HTMLParser(AbstractFormatter(DumbWriter()))
try: p.feed('hello<br>there'); p.close() #calling close is not usually needed, but let's play it safe
except HTMLParseError: print ':(' #the html is badly malformed (or you found a bug)
marca
fuente
NB: HTMLError y HTMLParserError deberían leer HTMLParseError. Esto funciona, pero hace un mal trabajo al mantener los saltos de línea.
Dave Knight
4

Recomiendo un paquete de Python llamado goose-extractor Goose intentará extraer la siguiente información:

Texto principal de un artículo Imagen principal del artículo Cualquier película de Youtube / Vimeo incrustada en el artículo Meta Descripción Metaetiquetas

Más: https://pypi.python.org/pypi/goose-extractor/

Li Yingjun
fuente
4

Si necesita más velocidad y menos precisión, puede usar lxml sin formato.

import lxml.html as lh
from lxml.html.clean import clean_html

def lxml_to_text(html):
    doc = lh.fromstring(html)
    doc = clean_html(doc)
    return doc.text_content()
Anton Shelin
fuente
4

instalar html2text usando

pip install html2text

luego,

>>> import html2text
>>>
>>> h = html2text.HTML2Text()
>>> # Ignore converting links from HTML
>>> h.ignore_links = True
>>> print h.handle("<p>Hello, <a href='http://earth.google.com/'>world</a>!")
Hello, world!
Pravitha V
fuente
4

Sé que ya hay muchas respuestas aquí, pero creo que el periódico3k también merece una mención. Recientemente necesitaba completar una tarea similar de extraer el texto de los artículos en la web y esta biblioteca ha hecho un excelente trabajo para lograr esto hasta ahora en mis pruebas. Ignora el texto que se encuentra en los elementos del menú y las barras laterales, así como cualquier JavaScript que aparece en la página como lo solicita el OP.

from newspaper import Article

article = Article(url)
article.download()
article.parse()
article.text

Si ya tiene los archivos HTML descargados, puede hacer algo como esto:

article = Article('')
article.set_html(html)
article.parse()
article.text

Incluso tiene algunas características de PNL para resumir los temas de los artículos:

article.nlp()
article.summary
spatel4140
fuente
3

Hermosa sopa convierte entidades html. Probablemente sea su mejor opción teniendo en cuenta que HTML a menudo tiene errores y está lleno de problemas de codificación Unicode y HTML. Este es el código que uso para convertir HTML a texto sin formato:

import BeautifulSoup
def getsoup(data, to_unicode=False):
    data = data.replace("&nbsp;", " ")
    # Fixes for bad markup I've seen in the wild.  Remove if not applicable.
    masssage_bad_comments = [
        (re.compile('<!-([^-])'), lambda match: '<!--' + match.group(1)),
        (re.compile('<!WWWAnswer T[=\w\d\s]*>'), lambda match: '<!--' + match.group(0) + '-->'),
    ]
    myNewMassage = copy.copy(BeautifulSoup.BeautifulSoup.MARKUP_MASSAGE)
    myNewMassage.extend(masssage_bad_comments)
    return BeautifulSoup.BeautifulSoup(data, markupMassage=myNewMassage,
        convertEntities=BeautifulSoup.BeautifulSoup.ALL_ENTITIES 
                    if to_unicode else None)

remove_html = lambda c: getsoup(c, to_unicode=True).getText(separator=u' ') if c else ""
Speedplane
fuente
3

Otra opción es ejecutar el html a través de un navegador web basado en texto y volcarlo. Por ejemplo (usando Lynx):

lynx -dump html_to_convert.html > converted_html.txt

Esto se puede hacer dentro de un script de Python de la siguiente manera:

import subprocess

with open('converted_html.txt', 'w') as outputFile:
    subprocess.call(['lynx', '-dump', 'html_to_convert.html'], stdout=testFile)

No le dará exactamente el texto del archivo HTML, pero dependiendo de su caso de uso, puede ser preferible a la salida de html2text.

John Lucas
fuente
3

Lo que mejor funcionó para mí son las inscripciones.

https://github.com/weblyzard/inscriptis

import urllib.request
from inscriptis import get_text

url = "http://www.informationscience.ch"
html = urllib.request.urlopen(url).read().decode('utf-8')

text = get_text(html)
print(text)

Los resultados son realmente buenos.

Empuje
fuente
2

Otra solución que no es Python: Libre Office:

soffice --headless --invisible --convert-to txt input1.html

La razón por la que prefiero esta sobre otras alternativas es que cada párrafo HTML se convierte en una sola línea de texto (sin saltos de línea), que es lo que estaba buscando. Otros métodos requieren post-procesamiento. Lynx produce una buena salida, pero no exactamente lo que estaba buscando. Además, Libre Office se puede usar para convertir de todo tipo de formatos ...

YakovK
fuente
2

Alguien ha intentado bleach.clean(html,tags=[],strip=True)con lejía ? Me está funcionando.

rox
fuente
Parece que también funciona para mí, pero no recomiendan usarlo para este propósito: "Esta función es una función centrada en la seguridad cuyo único propósito es eliminar el contenido malicioso de una cadena para que pueda mostrarse como contenido en una web página." -> bleach.readthedocs.io/en/latest/clean.html#bleach.clean
Loktopus
2

He tenido buenos resultados con Apache Tika . Su propósito es la extracción de metadatos y texto del contenido, por lo tanto, el analizador subyacente se ajusta en consecuencia de forma inmediata.

Tika se puede ejecutar como un servidor , es trivial ejecutar / implementar en un contenedor Docker, y desde allí se puede acceder a través de enlaces de Python .

u-phoria
fuente
1

de una manera simple

import re

html_text = open('html_file.html').read()
text_filtered = re.sub(r'<(.*?)>', '', html_text)

este código encuentra todas las partes del html_text comenzadas con '<' y terminando con '>' y reemplaza todas las encontradas por una cadena vacía

David Fraga
fuente
1

La respuesta de @ PeYoTIL usando BeautifulSoup y eliminando el estilo y el contenido del script no funcionó para mí. Lo intenté usando en decomposelugar de extractpero todavía no funcionó. Así que creé el mío, que también formatea el texto usando las <p>etiquetas y reemplaza las <a>etiquetas con el enlace href. También hace frente a enlaces dentro del texto. Disponible en esta esencia con un documento de prueba incrustado.

from bs4 import BeautifulSoup, NavigableString

def html_to_text(html):
    "Creates a formatted text email message as a string from a rendered html template (page)"
    soup = BeautifulSoup(html, 'html.parser')
    # Ignore anything in head
    body, text = soup.body, []
    for element in body.descendants:
        # We use type and not isinstance since comments, cdata, etc are subclasses that we don't want
        if type(element) == NavigableString:
            # We use the assumption that other tags can't be inside a script or style
            if element.parent.name in ('script', 'style'):
                continue

            # remove any multiple and leading/trailing whitespace
            string = ' '.join(element.string.split())
            if string:
                if element.parent.name == 'a':
                    a_tag = element.parent
                    # replace link text with the link
                    string = a_tag['href']
                    # concatenate with any non-empty immediately previous string
                    if (    type(a_tag.previous_sibling) == NavigableString and
                            a_tag.previous_sibling.string.strip() ):
                        text[-1] = text[-1] + ' ' + string
                        continue
                elif element.previous_sibling and element.previous_sibling.name == 'a':
                    text[-1] = text[-1] + ' ' + string
                    continue
                elif element.parent.name == 'p':
                    # Add extra paragraph formatting newline
                    string = '\n' + string
                text += [string]
    doc = '\n'.join(text)
    return doc
racitup
fuente
1
Gracias, esta respuesta está subestimada. Para aquellos de nosotros que queremos tener una representación de texto limpio que se comporte más como un navegador (ignorando las nuevas líneas y solo teniendo en cuenta los párrafos y los saltos de línea), BeautifulSoup's get_textsimplemente no lo corta.
jrial
@jrial me alegra que lo hayas encontrado útil, también gracias por la contribución. Para cualquier otra persona, la esencia vinculada se ha mejorado bastante. A lo que el OP parece aludir es a una herramienta que representa html en texto, muy similar a un navegador basado en texto como lynx. Eso es lo que intenta esta solución. Lo que la mayoría de la gente está contribuyendo son solo extractores de texto.
racitup
1

En Python 3.x puede hacerlo de una manera muy sencilla importando paquetes 'imaplib' y 'email'. Aunque esta es una publicación anterior, tal vez mi respuesta pueda ayudar a los recién llegados en esta publicación.

status, data = self.imap.fetch(num, '(RFC822)')
email_msg = email.message_from_bytes(data[0][1]) 
#email.message_from_string(data[0][1])

#If message is multi part we only want the text version of the body, this walks the message and gets the body.

if email_msg.is_multipart():
    for part in email_msg.walk():       
        if part.get_content_type() == "text/plain":
            body = part.get_payload(decode=True) #to control automatic email-style MIME decoding (e.g., Base64, uuencode, quoted-printable)
            body = body.decode()
        elif part.get_content_type() == "text/html":
            continue

Ahora puede imprimir la variable del cuerpo y estará en formato de texto sin formato :) Si es lo suficientemente bueno para usted, sería bueno seleccionarlo como respuesta aceptada.

Wahib Ul Haq
fuente
Esto no convierte nada.
Antti Haapala
1
Esto le muestra cómo extraer una text/plainparte de un correo electrónico si alguien más puso una allí. No hace nada para convertir el HTML en texto sin formato, y no hace nada remotamente útil si está intentando convertir HTML de, por ejemplo, un sitio web.
tripleee
1

puedes extraer solo texto de HTML con BeautifulSoup

url = "https://www.geeksforgeeks.org/extracting-email-addresses-using-regular-expressions-python/"
con = urlopen(url).read()
soup = BeautifulSoup(con,'html.parser')
texts = soup.get_text()
print(texts)
Sai Gopi N
fuente
1

Si bien muchas personas mencionaron el uso de expresiones regulares para eliminar las etiquetas html, hay muchas desventajas.

por ejemplo:

<p>hello&nbsp;world</p>I love you

Debe analizarse para:

Hello world
I love you

Aquí hay un fragmento que se me ocurrió, puedes personalizarlo según tus necesidades específicas, y funciona de maravilla

import re
import html
def html2text(htm):
    ret = html.unescape(htm)
    ret = ret.translate({
        8209: ord('-'),
        8220: ord('"'),
        8221: ord('"'),
        160: ord(' '),
    })
    ret = re.sub(r"\s", " ", ret, flags = re.MULTILINE)
    ret = re.sub("<br>|<br />|</p>|</div>|</h\d>", "\n", ret, flags = re.IGNORECASE)
    ret = re.sub('<.*?>', ' ', ret, flags=re.DOTALL)
    ret = re.sub(r"  +", " ", ret)
    return ret
Uri Goren
fuente
1

Otro ejemplo usando BeautifulSoup4 en Python 2.7.9+

incluye:

import urllib2
from bs4 import BeautifulSoup

Código:

def read_website_to_text(url):
    page = urllib2.urlopen(url)
    soup = BeautifulSoup(page, 'html.parser')
    for script in soup(["script", "style"]):
        script.extract() 
    text = soup.get_text()
    lines = (line.strip() for line in text.splitlines())
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    text = '\n'.join(chunk for chunk in chunks if chunk)
    return str(text.encode('utf-8'))

Explicado:

Lea los datos de la URL como html (usando BeautifulSoup), elimine todos los elementos de estilo y script, y también obtenga solo el texto usando .get_text (). Divida en líneas y elimine el espacio inicial y final de cada una, luego divida los encabezados múltiples en una línea cada uno = (frase.strip () para línea en línea para frase en línea.split ("")). Luego, usando text = '\ n'.join, suelte líneas en blanco, finalmente regrese como sancionado utf-8.

Notas:

  • Algunos sistemas en los que se ejecuta fallarán con las conexiones https: // debido a un problema de SSL, puede desactivar la verificación para solucionar ese problema. Solución de ejemplo: http://blog.pengyifan.com/how-to-fix-python-ssl-certificate_verify_failed/

  • Python <2.7.9 puede tener algún problema al ejecutar esto

  • text.encode ('utf-8') puede dejar una codificación extraña, puede que solo desee devolver str (text) en su lugar.

Mike Q
fuente
0

Aquí está el código que uso regularmente.

from bs4 import BeautifulSoup
import urllib.request


def processText(webpage):

    # EMPTY LIST TO STORE PROCESSED TEXT
    proc_text = []

    try:
        news_open = urllib.request.urlopen(webpage.group())
        news_soup = BeautifulSoup(news_open, "lxml")
        news_para = news_soup.find_all("p", text = True)

        for item in news_para:
            # SPLIT WORDS, JOIN WORDS TO REMOVE EXTRA SPACES
            para_text = (' ').join((item.text).split())

            # COMBINE LINES/PARAGRAPHS INTO A LIST
            proc_text.append(para_text)

    except urllib.error.HTTPError:
        pass

    return proc_text

Espero que eso ayude.

troymyname00
fuente
0

El comentario del escritor de LibreOffice tiene mérito ya que la aplicación puede emplear macros de Python. Parece ofrecer múltiples beneficios tanto para responder a esta pregunta como para ampliar la base macro de LibreOffice. Si esta resolución es una implementación única, en lugar de usarse como parte de un programa de producción mayor, abrir el HTML en el escritor y guardar la página como texto parecería resolver los problemas discutidos aquí.

1 de 7
fuente
0

Perl way (lo siento mamá, nunca lo haré en producción).

import re

def html2text(html):
    res = re.sub('<.*?>', ' ', html, flags=re.DOTALL | re.MULTILINE)
    res = re.sub('\n+', '\n', res)
    res = re.sub('\r+', '', res)
    res = re.sub('[\t ]+', ' ', res)
    res = re.sub('\t+', '\t', res)
    res = re.sub('(\n )+', '\n ', res)
    return res
brunql
fuente
Esta es una mala práctica por muchas razones, por ejemplo&nbsp;
Uri Goren el
¡Si! ¡Es verdad! ¡No lo hagas allí!
brunql