Extraindo texto do arquivo HTML usando Python

243

Eu gostaria de extrair o texto de um arquivo HTML usando Python. Quero essencialmente a mesma saída que obteria se copiasse o texto de um navegador e o colasse no bloco de notas.

Eu gostaria de algo mais robusto do que usar expressões regulares que podem falhar em HTML mal formado. Eu já vi muitas pessoas recomendando Sopa Bonita, mas tive alguns problemas ao usá-lo. Por um lado, ele captou texto indesejado, como fonte JavaScript. Além disso, ele não interpretou entidades HTML. Por exemplo, eu esperaria que o & # 39; na fonte HTML para ser convertido em um apóstrofo no texto, como se eu tivesse colado o conteúdo do navegador no bloco de notas.

A atualização html2text parece promissora. Ele lida com entidades HTML corretamente e ignora JavaScript. No entanto, ele não produz exatamente texto sem formatação; produz reduções que teriam que ser transformadas em texto sem formatação. Ele vem sem exemplos ou documentação, mas o código parece limpo.

Perguntas relacionadas:

python html text html-content-extraction John D. Cook
fonte

Por um bom tempo, as pessoas parecem achar a minha resposta NLTK (bastante recente) extremamente útil, portanto, considere alterar a resposta aceita. Obrigado!

Shatu

1

Eu nunca pensei em encontrar uma pergunta feita pelo autor do meu blog favorito! O esforço!

Ryan G

1

@Shatu Agora que sua solução não se tornou mais válida, você pode excluir seu comentário. Obrigado! ;)

Sнаđошƒаӽ

136

html2text é um programa Python que faz um bom trabalho nisso.

RexE
fonte

5

mordeu de gpl 3,0 o que significa que podem ser incompatíveis

frog32

138

Surpreendente! seu autor é RIP Aaron Swartz.

Atul Arvind

2

Alguém encontrou alguma alternativa ao html2text por causa da GPL 3.0?

jontsai

1

A GPL não é tão ruim quanto as pessoas querem. Aaron sabia melhor.

18710 Steve

2

Eu tentei o html2text e o nltk, mas eles não funcionaram para mim. Acabei optando pelo Beautiful Soup 4, que funciona lindamente (sem trocadilhos).

30515 Ryan

149

O melhor pedaço de código que encontrei para extrair texto sem obter javascript ou coisas não desejadas:

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)

Você só precisa instalar o BeautifulSoup antes:

pip install beautifulsoup4

PeYoTlL
fonte

2

Como se quisermos selecionar uma linha, apenas disse, a linha 3?

hepidad 26/08

3

Os scripts de matar pouco, salvador !!

Nanda

2

Depois de passar por muitas respostas de fluxo de pilha, sinto que essa é a melhor opção para mim. Um problema que encontrei é que as linhas foram adicionadas em alguns casos. Eu era capaz de superá-lo adicionando um separador na função get_text:text = soup.get_text(separator=' ')

Joswin KJ 2/15

5

Em vez de soup.get_text()eu usá- soup.body.get_text()lo, para não receber nenhum texto do <headelemento>, como o título.

Sjoerd

10

Para Python 3,from urllib.request import urlopen

Jacob Kalakal Joseph

99

NOTA: O NTLK não suporta mais a clean_htmlfunção

Resposta original abaixo e uma alternativa nas seções de comentários.

Use NLTK

Eu perdi minhas 4-5 horas corrigindo os problemas com o html2text. Felizmente eu poderia encontrar o NLTK.
Funciona magicamente.

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
fonte

8

por vezes, que é :) suficiente

Sharmila

8

Eu quero votar isso mil vezes. Eu estava preso no inferno regex, mas eis que agora vejo a sabedoria do NLTK.

BenDundee

26

Aparentemente, clean_html não é suportado mais: github.com/nltk/nltk/commit/...

alexanderlukanin13

5

importação de uma biblioteca pesado como nltk para uma tarefa tão simples seria demais

Richie

54

@ alexanderlukanin13 Da fonte:raise NotImplementedError ("To remove HTML markup, use BeautifulSoup's get_text() function")

Chris Arena

54

Me vi enfrentando o mesmo problema hoje. Escrevi um analisador HTML muito simples para remover o conteúdo de todas as marcações, retornando o texto restante com apenas um mínimo de formatação.

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
fonte

5

Essa parece ser a maneira mais direta de fazer isso no Python (2.7) usando apenas os módulos padrão. O que é realmente bobo, pois isso é uma coisa tão necessária e não há uma boa razão para que não haja um analisador para isso no módulo HTMLParser padrão.

Ingmar Hupp

2

Eu não acho que irá converter caracteres html em unicode, certo? Por exemplo, &não será convertido em &, certo?

speedplane

Para uso em Python 3from html.parser import HTMLParser

sebhaase

14

Aqui está uma versão da resposta do xperroni, que é um pouco mais completa. Ignora as seções de script e estilo e converte charrefs (por exemplo, & # 39;) e entidades HTML (por exemplo, & & amp;).

Ele também inclui um conversor inverso trivial de texto sem formatação para 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
fonte

python 3 Versão: gist.github.com/Crazometer/af441bc7dc7353d41390a59f20f07b51

Crazometer

Em get_text, '' .join deve ser '' .join. Deve haver um espaço vazio, caso contrário, alguns dos textos se juntarão.

Obinna Nnenanya

1

Além disso, isso não irá capturar TODOS os textos, exceto se você incluir outras tags de contêiner de texto como H1, H2 ...., extensão, etc. Eu tive que ajustá-lo para obter uma cobertura melhor.

Obinna Nnenanya

11

Sei que já existem muitas respostas, mas a solução mais elegante e pitônica que encontrei é descrita, em parte, aqui .

from bs4 import BeautifulSoup

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

Atualizar

Com base no comentário de Fraser, aqui está uma solução mais elegante:

from bs4 import BeautifulSoup

clean_text = ''.join(BeautifulSoup(some_html_string, "html.parser").stripped_strings)

Floyd
fonte

2

Para evitar um aviso, especifique um analisador para o BeautifulSoup usar:text = ''.join(BeautifulSoup(some_html_string, "lxml").findAll(text=True))

Floyd

É possível utilizar o gerador stripped_strings para evitar branco-espaço excessivo - isto éclean_text = ''.join(BeautifulSoup(some_html_string, "html.parser").stripped_strings

Fraser

8

Você também pode usar o método html2text na biblioteca de stripogramas.

from stripogram import html2text
text = html2text(your_html_string)

Para instalar o stripogram, execute sudo easy_install stripogram

GeekTantra
fonte

23

Este módulo, de acordo com sua página pypi , está obsoleto: "A menos que você tenha algum motivo histórico para usar este pacote, eu desaconselharia!"

intuited

7

Existe uma biblioteca de padrões para mineração de dados.

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

Você pode até decidir quais tags manter:

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

Nuncjo
fonte

6

PyParsing faz um ótimo trabalho. O wiki do PyParsing foi eliminado, então aqui está outro local onde há exemplos de uso do PyParsing ( link de exemplo ). Uma razão para investir um pouco de tempo com o pyparsing é que ele também escreveu um manual muito breve e muito bem organizado da O'Reilly Short Cut, que também é barato.

Dito isto, eu uso muito o BeautifulSoup e não é tão difícil lidar com os problemas das entidades, você pode convertê-los antes de executar o BeautifulSoup.

Boa sorte

PyNEwbie
fonte

1

O link está inativo ou azedo.

Yvette

4

Esta não é exatamente uma solução Python, mas converterá o texto que o Javascript geraria em texto, o que eu acho importante (EG google.com). O navegador Links (não o Lynx) tem um mecanismo Javascript e converterá a fonte em texto com a opção -dump.

Então você pode fazer 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()

Andrew
fonte

4

Em vez do módulo HTMLParser, confira htmllib. Ele tem uma interface semelhante, mas faz mais trabalho para você. (É bastante antigo, por isso não ajuda muito em termos de se livrar de javascript e css. Você pode criar uma classe derivada, mas adicionar métodos com nomes como start_script e end_style (consulte os documentos em python para obter detalhes), mas é difícil para fazer isso de forma confiável em html malformado.) De qualquer forma, aqui está algo simples que imprime o texto sem formatação no console

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
fonte

Nota: HTMLError e HTMLParserError devem ler HTMLParseError. Isso funciona, mas faz um trabalho ruim de manutenção de quebras de linha.

Dave Cavaleiro

4

Eu recomendo que um pacote Python chamado goose-extractor Goose tente extrair as seguintes informações:

Texto principal de um artigo Imagem principal do artigo Quaisquer filmes do Youtube / Vimeo incorporados no artigo Meta Descrição Meta tags

Mais: https://pypi.python.org/pypi/goose-extractor/

Li Yingjun
fonte

4

se você precisar de mais velocidade e menos precisão, poderá usar o lxml bruto.

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
fonte

4

instale o html2text usando

pip install html2text

então,

>>> 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
fonte

4

Sei que já há muitas respostas aqui, mas acho que o newspaper3k também merece uma menção. Recentemente, eu precisei concluir uma tarefa semelhante de extrair o texto de artigos na Web e essa biblioteca fez um excelente trabalho para conseguir isso até agora em meus testes. Ele ignora o texto encontrado nos itens de menu e barras laterais, bem como qualquer JavaScript que aparece na página conforme o pedido do OP.

from newspaper import Article

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

Se você já tiver baixado os arquivos HTML, poderá fazer algo assim:

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

Ele ainda possui alguns recursos de PNL para resumir os tópicos dos artigos:

article.nlp()
article.summary

spatel4140
fonte

3

Sopa bonita converte entidades html. Provavelmente, é a sua melhor aposta, considerando que o HTML geralmente é buggy e está cheio de problemas de codificação unicode e html. Este é o código que eu uso para converter html em texto bruto:

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
fonte

3

Outra opção é executar o html através de um navegador da Web baseado em texto e despejá-lo. Por exemplo (usando o Lynx):

lynx -dump html_to_convert.html > converted_html.txt

Isso pode ser feito dentro de um script python da seguinte maneira:

import subprocess

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

Não fornecerá exatamente o texto do arquivo HTML, mas dependendo do seu caso de uso, pode ser preferível à saída do html2text.

John Lucas
fonte

3

O melhor que funcionou para mim é a inscrição.

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)

Os resultados são realmente bons

Vim
fonte

2

Outra solução não-python: Libre Office:

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

A razão pela qual prefiro esta sobre outras alternativas é que todo parágrafo HTML é convertido em uma única linha de texto (sem quebras de linha), que é o que eu estava procurando. Outros métodos requerem pós-processamento. O Lynx produz resultados agradáveis, mas não exatamente o que eu estava procurando. Além disso, o Libre Office pode ser usado para converter de todos os tipos de formatos ...

YakovK
fonte

2

Alguém já tentou bleach.clean(html,tags=[],strip=True)com água sanitária ? está funcionando para mim.

rox
fonte

Parece funcionar para mim também, mas eles não recomendam usá-lo para este fim: "Esta função é uma função focada na segurança cujo único objetivo é remover conteúdo malicioso de uma string, para que possa ser exibido como conteúdo em uma Web. página." -> bleach.readthedocs.io/en/latest/clean.html#bleach.clean

Loktopus

2

Eu tive bons resultados com o Apache Tika . Seu objetivo é a extração de metadados e texto do conteúdo; portanto, o analisador subjacente é ajustado de maneira apropriada.

O Tika pode ser executado como um servidor , é trivial para executar / implantar em um contêiner do Docker e a partir daí pode ser acessado por meio de ligações do Python .

u-phoria
fonte

1

de uma maneira simples

import re

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

esse código localiza todas as partes do html_text iniciadas com '<' e terminando com '>' e substituem todas as encontradas por uma sequência vazia

David Fraga
fonte

1

A resposta da @ PeYoTIL usando BeautifulSoup e eliminando o estilo e o conteúdo do script não funcionou para mim. Eu tentei usando em decomposevez de, extractmas ainda não funcionou. Então eu criei o meu próprio, que também formata o texto usando as <p>tags e as substitui <a>pelo link href. Também lida com links dentro do texto. Disponível nesta essência com um documento de teste incorporado.

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
fonte

1

Obrigado, esta resposta é subestimada. Para aqueles de nós que desejam ter uma representação de texto limpo que se comporte mais como um navegador (ignorando novas linhas e levando em consideração apenas parágrafos e quebras de linha), a BeautifulSoup get_textsimplesmente não resolve.

jrial

@ jrial feliz que você achou útil, também obrigado pelo contrib. Para qualquer outra pessoa, a essência ligada foi aprimorada bastante. O que o OP parece aludir é uma ferramenta que renderiza html em texto, muito parecido com um navegador baseado em texto como o lynx. É isso que esta solução tenta. O que a maioria das pessoas está contribuindo são apenas extratores de texto.

racitup

1

No Python 3.x, você pode fazer isso de uma maneira muito fácil, importando os pacotes 'imaplib' e 'email'. Embora este seja um post antigo, talvez minha resposta possa ajudar os novatos nesse post.

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

Agora você pode imprimir a variável do corpo e ela estará no formato de texto sem formatação :) Se for bom o suficiente para você, seria bom selecioná-la como resposta aceita.

Wahib Ul Haq
fonte

Isso não converte nada.

Antti Haapala

1

Isso mostra como extrair uma text/plainparte de um email se outra pessoa colocar uma lá. Ele não faz nada para converter o HTML em texto sem formatação e não faz nada remotamente útil se você estiver tentando converter HTML de, digamos, um site.

tripleee

1

você pode extrair apenas texto do HTML com 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
fonte

1

Embora muitas pessoas mencionem o uso do regex para remover as tags html, há muitas desvantagens.

por exemplo:

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

Deve ser analisado para:

Hello world
I love you

Aqui está um trecho que eu criei, você pode personalizá-lo para suas necessidades específicas e funciona como um encanto

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
fonte

1

Outro exemplo usando BeautifulSoup4 em Python 2.7.9+

inclui:

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:

Leia os dados da url como html (usando BeautifulSoup), remova todos os elementos de script e estilo e obtenha apenas o texto usando .get_text (). Divida em linhas e remova o espaço inicial e final de cada uma e, em seguida, divida as várias manchetes em uma linha de cada pedaço = (frase.strip () para linha em linhas para frase em line.split ("")). Em seguida, usando text = '\ n'.join, solte as linhas em branco e, finalmente, retorne como utf-8 sancionado.

Notas:

Alguns sistemas em que é executado falham com conexões https: // devido a um problema de SSL. Você pode desativar a verificação para corrigir esse problema. Correção de exemplo: http://blog.pengyifan.com/how-to-fix-python-ssl-certificate_verify_failed/
Python <2.7.9 pode ter algum problema ao executar este
text.encode ('utf-8') pode deixar uma codificação estranha, mas pode retornar apenas str (text).

Mike Q
fonte

0

Aqui está o código que eu 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 ajude.

troymyname00
fonte

0

O comentário do gravador do LibreOffice tem mérito, pois o aplicativo pode empregar macros python. Parece oferecer vários benefícios, tanto para responder a essa pergunta quanto para promover a base macro do LibreOffice. Se esta resolução for uma implementação pontual, em vez de ser usada como parte de um programa de produção maior, abrir o HTML no gravador e salvar a página como texto pareceria resolver os problemas discutidos aqui.

1of7
fonte

0

Perl way (desculpe mãe, eu nunca vou fazer isso em produção).

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
fonte

Esta é uma prática ruim por muitos motivos, por exemplo 

Uri Goren

Sim! É verdade! Não faça isso em nenhum lugar!

Brunql 22/01/19

Extraindo texto do arquivo HTML usando Python

Respostas:

Atualizar