पायथन का उपयोग करके HTML फ़ाइल से पाठ निकालना

243

मैं Python का उपयोग करके HTML फ़ाइल से पाठ निकालना चाहूंगा। मैं अनिवार्य रूप से वही आउटपुट चाहता हूं जो मुझे मिलेगा अगर मैंने एक ब्राउज़र से टेक्स्ट कॉपी किया और इसे नोटपैड में पेस्ट किया।

मैं नियमित अभिव्यक्ति का उपयोग करने की तुलना में कुछ अधिक मजबूत होना चाहूंगा जो खराब तरीके से गठित HTML पर विफल हो सकता है। मैंने देखा है कि बहुत से लोग सुंदर सूप की सलाह देते हैं, लेकिन मुझे इसका उपयोग करने में कुछ समस्याएं हैं। एक के लिए, इसने अवांछित पाठ को उठाया, जैसे कि जावास्क्रिप्ट स्रोत। साथ ही, यह HTML संस्थाओं की व्याख्या नहीं करता था। उदाहरण के लिए, मुझे उम्मीद है कि & # 39; HTML स्रोत में पाठ में एक एपॉस्ट्रॉफी में परिवर्तित होने के लिए, जैसे कि मैंने ब्राउज़र सामग्री को नोटपैड में चिपकाया है।

अद्यतन html2text होनहार लग रहा है। यह HTML संस्थाओं को सही ढंग से संभालता है और जावास्क्रिप्ट को अनदेखा करता है। हालाँकि, यह बिल्कुल सादे पाठ का उत्पादन नहीं करता है; यह ऐसे मार्कडाउन का निर्माण करता है जिसे फिर सादे पाठ में बदलना होगा। यह कोई उदाहरण या प्रलेखन के साथ आता है, लेकिन कोड साफ दिखता है।

संबंधित सवाल:

python  html  text  html-content-extraction 
— जॉन डी। कुक
स्रोत
काफी समय से, लोगों को लगता है कि मेरा एनएलटीके उत्तर (हाल ही में) अत्यंत उपयोगी है, इसलिए आप स्वीकृत उत्तर को बदलने पर विचार कर सकते हैं। धन्यवाद!
— शतु
1
मैंने कभी नहीं सोचा था कि मैं अपने पसंदीदा ब्लॉग के लेखक द्वारा पूछे गए एक सवाल पर आऊंगा! एंडेवर!
— रयान जी
1
@ शत्रु अब जब कि आपका समाधान वैध नहीं रह गया है, तो आप अपनी टिप्पणी हटाना चाहते हैं। धन्यवाद! ;)
— संताइतोय

जवाबों:

136

html2text एक पायथन प्रोग्राम है जो इस पर बहुत अच्छा काम करता है।

— RexE
स्रोत
5
bit यह
— gpl
138
गजब का! यह लेखक रिप आरोन स्वार्ट्ज है।
— अतुल अरविंद
2
GPL 3.0 की वजह से क्या किसी को html2text का कोई विकल्प मिला?
— जॉन्साई
1
जीपीएल उतना बुरा नहीं है जितना लोग चाहते हैं। हारून को सबसे अच्छा पता था।
— स्टीव के
2
मैंने html2text और nltk दोनों की कोशिश की, लेकिन उन्होंने मेरे लिए काम नहीं किया। मैंने सुंदर सूप 4 के साथ जाना समाप्त कर दिया, जो कि सुंदर तरीके से काम करता है (कोई सज़ा नहीं)।
— रयान
150

मुझे जावास्क्रिप्ट के बिना पाठ निकालने के लिए मिला कोड का सबसे अच्छा टुकड़ा या वांछित चीजें नहीं मिली:

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)

आपको पहले सिर्फ ब्यूटीफुल इंस्टॉल करना होगा:

pip install beautifulsoup4
— PeYoTlL
स्रोत
2
अगर हम कुछ लाइन का चयन करना चाहते हैं, तो बस लाइन # 3 कहा जाए?
— hepidad
3
हत्या की स्क्रिप्ट बिट, उद्धारकर्ता !!
— नंद
2
ढेर सारे ढेर जवाबों से गुजरने के बाद, मुझे लगता है कि यह मेरे लिए सबसे अच्छा विकल्प है। एक समस्या यह है कि कुछ मामलों में लाइनों को एक साथ जोड़ा गया था। मैं get_text फ़ंक्शन में एक विभाजक जोड़कर इसे दूर करने में सक्षम था:text = soup.get_text(separator=' ')
— जोसविन केजे
5
इसके बजाय soup.get_text()मैंने उपयोग किया soup.body.get_text(), ताकि मुझे <head> तत्व जैसे शीर्षक से कोई पाठ न मिले ।
— जोएर्ड
10
पायथन 3 के लिए,from urllib.request import urlopen
— जैकब कलाकल जोसेफ
99

नोट: NTLK अब clean_htmlफ़ंक्शन का समर्थन नहीं करता है

नीचे मूल उत्तर, और टिप्पणी अनुभागों में एक विकल्प।

NLTK का उपयोग करें

मैंने html2text के साथ मुद्दों को ठीक करते हुए अपने 4-5 घंटे बर्बाद कर दिए। सौभाग्य से मैं एनएलटीके से भिड़ सकता था।
यह जादुई तरीके से काम करता है। 

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
स्रोत
8
कभी-कभी यह पर्याप्त होता है :)
— शर्मिला
8
मैं इसे एक हजार बार वोट देना चाहता हूं। मैं रेगेक्स नरक में फंस गया था, लेकिन लो, अब मुझे एनएलटीके का ज्ञान दिखाई देता है।
— बेनडुंडी
26
जाहिरा तौर पर, clean_html अब समर्थित नहीं है: github.com/nltk/nltk/commit/…
— alexanderlukanin13
5
इस तरह के एक सरल कार्य के लिए nltk जैसे भारी पुस्तकालय का आयात बहुत अधिक होगा
— रिची
54
@ अलेक्जेंडरलुकिन 13 स्रोत से:raise NotImplementedError ("To remove HTML markup, use BeautifulSoup's get_text() function")
— क्रिस एरिना
54

अपने आप को आज उसी समस्या का सामना करना पड़ा मैंने सभी मार्कअप की आने वाली सामग्री को छीनने के लिए एक बहुत ही सरल HTML पार्सर लिखा, शेष पाठ को केवल न्यूनतम प्रारूपण के साथ वापस किया।

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
स्रोत
5
यह केवल डिफ़ॉल्ट मॉड्यूल का उपयोग करके पायथन (2.7) में ऐसा करने का सबसे सीधा तरीका लगता है। जो वास्तव में मूर्खतापूर्ण है, क्योंकि यह इस तरह की एक सामान्य रूप से आवश्यक चीज है और कोई अच्छा कारण नहीं है कि डिफ़ॉल्ट HTMLParser मॉड्यूल में इसके लिए कोई पार्सर नहीं है।
— इंगमार ह्प्प
2
मुझे नहीं लगता कि HTML वर्णों को यूनिकोड में परिवर्तित किया जाएगा, है ना? उदाहरण के लिए , सही &amp;में परिवर्तित नहीं किया जाएगा &?
— स्पीड प्लेन
पायथन 3 उपयोग के लिएfrom html.parser import HTMLParser
— sebhaase
14

यहाँ xperroni के उत्तर का एक संस्करण है जो थोड़ा अधिक पूर्ण है। यह स्क्रिप्ट और शैली अनुभागों को छोड़ देता है और अनुवाद करता है charrefs (जैसे, & # 39;) और HTML इकाइयाँ (जैसे, और amp;)।

इसमें एक सामान्य सादा-पाठ-से-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
स्रोत
अजगर 3 संस्करण: gist.github.com/Crazometer/af441bc7dc7353d41390a59f20f07b51
— Crazometer
Get_text में, '' .join होना चाहिए '' .join एक खाली जगह होनी चाहिए, अन्यथा कुछ ग्रंथ एक साथ जुड़ेंगे।
— ओबिन्ना नेनान्या
1
इसके अलावा, यह सभी ग्रंथों को नहीं पकड़ेगा, इसके अलावा आपको एच 1, एच 2 .... स्पैन जैसे अन्य टेक्स्ट कंटेनर टैग शामिल हैं, मुझे इसे बेहतर कवरेज के लिए ट्वीक करना था।
— Obinna Nnenanya
11

मुझे पता है कि पहले से ही बहुत सारे उत्तर हैं, लेकिन मुझे जो सबसे सुरुचिपूर्ण और पाइथोनिक समाधान मिला है वह वर्णित है, भाग में, यहाँ ।

from bs4 import BeautifulSoup

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

अपडेट करें

फ्रेजर की टिप्पणी के आधार पर, यहां और अधिक सुरुचिपूर्ण समाधान है:

from bs4 import BeautifulSoup

clean_text = ''.join(BeautifulSoup(some_html_string, "html.parser").stripped_strings)
— फ्लोयड
स्रोत
2
एक चेतावनी से बचने के लिए, ब्यूटीफुल के लिए एक पार्सर का उपयोग करने के लिए निर्दिष्ट करें:text = ''.join(BeautifulSoup(some_html_string, "lxml").findAll(text=True))
— फ्लोयड
अत्यधिक सफेद-स्थान से बचने के लिए आप स्ट्रिप्ड_स्ट्रिंग्स जनरेटर का उपयोग कर सकते हैं - अर्थातclean_text = ''.join(BeautifulSoup(some_html_string, "html.parser").stripped_strings
— फ्रेजर
8

आप html2text मेथड का उपयोग स्ट्रिपोग्राम लाइब्रेरी में भी कर सकते हैं।

from stripogram import html2text
text = html2text(your_html_string)

स्ट्रिपोग्राम चलाने के लिए sudo easy_install स्ट्रिपोग्राम चलाएं

— GeekTantra
स्रोत
23
यह मॉड्यूल, इसके pypi पृष्ठ के अनुसार , हटा दिया गया है: "जब तक आपके पास इस पैकेज का उपयोग करने के लिए कुछ ऐतिहासिक कारण नहीं है, मैं इसके खिलाफ सलाह दूंगा !"
— intuited
7

डेटा माइनिंग के लिए पैटर्न लाइब्रेरी है।

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

आप यह भी तय कर सकते हैं कि क्या टैग रखें:

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

PyParsing बहुत अच्छा काम करता है। PyParsing wiki को मार दिया गया था इसलिए यहाँ एक और स्थान है जहाँ PyParsing के उपयोग के उदाहरण हैं ( उदाहरण लिंक ) । पाइपरसिंग के साथ थोड़ा समय निवेश करने का एक कारण यह है कि उन्होंने बहुत संक्षिप्त रूप से व्यवस्थित ओ रेली शॉर्ट कट मैनुअल भी लिखा है जो कि सस्ती भी है।

यह कहने के बाद कि, मैं ब्यूटीफुलसुप का उपयोग बहुत करता हूं और यह नहीं है कि संस्थाओं के मुद्दों से निपटना मुश्किल है, आप सुंदरसुप चलाने से पहले उन्हें परिवर्तित कर सकते हैं।

सौभाग्य

— PyNEwbie
स्रोत
1
लिंक मृत या खट्टा है।
— यवेटे
4

यह वास्तव में एक पायथन समाधान नहीं है, लेकिन यह पाठ जावास्क्रिप्ट को पाठ में उत्पन्न करेगा, जो मुझे लगता है कि महत्वपूर्ण है (ईजी google.com)। ब्राउज़र लिंक्स (लिंक्स नहीं) में एक जावास्क्रिप्ट इंजन है, और यह स्रोत को -dump विकल्प के साथ पाठ में बदल देगा।

तो आप कुछ ऐसा कर सकते हैं:

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()
— एंड्रयू
स्रोत
4

HTMLParser मॉड्यूल के बजाय, htmllib देखें। इसका एक समान इंटरफ़ेस है, लेकिन यह आपके लिए अधिक काम करता है। (यह बहुत प्राचीन है, इसलिए यह जावास्क्रिप्ट और सीएसएस से छुटकारा पाने के मामले में बहुत मददगार नहीं है। आप एक व्युत्पन्न वर्ग बना सकते हैं, लेकिन start_script और end_style जैसे नामों के साथ तरीके जोड़ सकते हैं (विवरण के लिए अजगर डॉक्स देखें), लेकिन यह कठिन है विकृत HTML के लिए यह विश्वसनीय रूप से करने के लिए।) वैसे भी, यहाँ कुछ सरल है जो सादे पाठ को कंसोल पर प्रिंट करता है

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)
— निशान
स्रोत
NB: HTMLError और HTMLParserError दोनों को HTMLParseError को पढ़ना चाहिए। यह काम करता है, लेकिन लाइन ब्रेक को बनाए रखने का एक बुरा काम करता है।
— डेव नाइट
4

मैं एक पायथन पैकेज की सलाह देता हूं, जिसे Goose-extractor Goose कहा जाता है, निम्नलिखित जानकारी निकालने की कोशिश करेगा:

लेख का मुख्य पाठ लेख की मुख्य छवि कोई भी YouTube / Vimeo फिल्में लेख में उल्लिखित हैं मेटा विवरण मेटा टैग

और अधिक: https://pypi.python.org/pypi/goose-extractor/

— ली यिंगजुन
स्रोत
4

यदि आपको अधिक गति और कम सटीकता की आवश्यकता है तो आप कच्चे एलएक्सएमएल का उपयोग कर सकते हैं।

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()
— एंटोन शेलिन
स्रोत
4

html2text का उपयोग करके स्थापित करें

पाइप स्थापित करें html2text

फिर,

>>> 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!
— प्रवीथा वी
स्रोत
4

मुझे पता है कि यहां पहले से ही बहुत सारे उत्तर हैं लेकिन मुझे लगता है कि अखबार 3k भी एक उल्लेख के योग्य है। मुझे हाल ही में वेब पर लेखों से पाठ निकालने के एक समान कार्य को पूरा करने की आवश्यकता थी और इस पुस्तकालय ने अपने परीक्षणों में अब तक इसे प्राप्त करने का एक उत्कृष्ट काम किया है। यह मेनू आइटम और साइड बार के साथ-साथ ओपी अनुरोध के रूप में पृष्ठ पर दिखाई देने वाले किसी भी जावास्क्रिप्ट को अनदेखा करता है।

from newspaper import Article

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

यदि आपके पास पहले से ही HTML फाइलें डाउनलोड हैं तो आप कुछ इस तरह से कर सकते हैं:

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

यहां तक ​​कि इसमें लेखों के विषयों को संक्षेप में प्रस्तुत करने के लिए कुछ एनएलपी विशेषताएं हैं:

article.nlp()
article.summary
— spatel4140
स्रोत
3

सुंदर सूप HTML संस्थाओं को परिवर्तित करता है। यह शायद आपका सबसे अच्छा शर्त है कि HTML अक्सर छोटी गाड़ी है और यूनिकोड और HTML एन्कोडिंग मुद्दों से भरा है। यह वह कोड है जिसका उपयोग मैं html को कच्चे पाठ में बदलने के लिए करता हूं:

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
स्रोत
3

एक अन्य विकल्प यह है कि टेक्स्ट आधारित वेब ब्राउज़र के माध्यम से html को चलाना और उसे डंप करना। उदाहरण के लिए (लिंक्स का उपयोग करके):

lynx -dump html_to_convert.html > converted_html.txt

यह एक अजगर लिपि के भीतर किया जा सकता है:

import subprocess

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

यह आपको HTML फ़ाइल से सिर्फ पाठ नहीं देगा, लेकिन आपके उपयोग के मामले के आधार पर यह HTML2text के आउटपुट के लिए बेहतर हो सकता है।

— जॉन लुकास
स्रोत
3

मेरे लिए सर्वश्रेष्ठ काम शिलालेख है।

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)

परिणाम वास्तव में अच्छे हैं

— शक्ति
स्रोत
2

एक और गैर-अजगर समाधान: लिब्रे कार्यालय:

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

इसका कारण यह है कि मैं इसे अन्य विकल्पों पर पसंद करता हूं, यह है कि हर HTML पैराग्राफ एक एकल टेक्स्ट लाइन (कोई लाइन ब्रेक नहीं) में परिवर्तित हो जाता है, जो कि मैं देख रहा था। अन्य तरीकों के बाद प्रसंस्करण की आवश्यकता होती है। लिंक्स अच्छा आउटपुट देता है, लेकिन ठीक वैसा नहीं जैसा मैं देख रहा था। इसके अलावा, लिबर ऑफिस का उपयोग सभी प्रकार के प्रारूपों से परिवर्तित करने के लिए किया जा सकता है ...

— YakovK
स्रोत
2

किसी ने ब्लीच केbleach.clean(html,tags=[],strip=True) साथ कोशिश की है ? यह मेरे लिए काम कर रहा है।

— rox
स्रोत
मेरे लिए भी काम करने लगता है, लेकिन वे इसे इस उद्देश्य के लिए उपयोग करने की अनुशंसा नहीं करते हैं: "यह फ़ंक्शन एक सुरक्षा-केंद्रित फ़ंक्शन है जिसका एकमात्र उद्देश्य एक स्ट्रिंग से दुर्भावनापूर्ण सामग्री को निकालना है ताकि इसे वेब में सामग्री के रूप में प्रदर्शित किया जा सके पृष्ठ।" -> bleach.readthedocs.io/en/latest/clean.html#bleach.clean
— 20top पर Loktopus
2

मेरे पास अपाचे टीका के अच्छे परिणाम हैं । इसका उद्देश्य सामग्री से मेटाडेटा और पाठ का निष्कर्षण है, इसलिए बॉक्स के अनुसार अंतर्निहित पार्सर को ट्यून किया गया है।

टिके को सर्वर के रूप में चलाया जा सकता है , डॉकटर कंटेनर में चलाने / तैनात करने के लिए तुच्छ है, और वहां से पायथन बाइंडिंग के माध्यम से पहुँचा जा सकता है ।

— यू-Phoria
स्रोत
1

सरल तरीके से

import re

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

यह कोड html_text के सभी भागों को '<' से शुरू होता है और '>' के साथ समाप्त होता है और सभी को एक स्ट्रिंग द्वारा पाया जाता है

— डेविड फ्रैगा
स्रोत
1

@ ब्यूटीफुल का उपयोग करते हुए पेइओटिल का जवाब और शैली और स्क्रिप्ट सामग्री को खत्म करना मेरे लिए कारगर नहीं रहा। मैं decomposeइसके बजाय का उपयोग करने की कोशिश की, extractलेकिन यह अभी भी काम नहीं किया। इसलिए मैंने अपना स्वयं का बनाया जो <p>टैग्स का उपयोग करके पाठ को प्रारूपित करता है और <a>href लिंक के साथ टैग को प्रतिस्थापित करता है । पाठ के अंदर लिंक के साथ भी। एक परीक्षण डॉक्टर एम्बेडेड के साथ इस जिस्ट पर उपलब्ध है ।

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
स्रोत
1
धन्यवाद, यह उत्तर रेखांकित है। हम में से जो एक साफ पाठ प्रतिनिधित्व करना चाहते हैं, वे एक ब्राउज़र की तरह अधिक व्यवहार करते हैं (नई-नई कहानियों को अनदेखा करते हैं, और केवल पैराग्राफ और लाइन ब्रेक को ध्यान में रखते हैं), सुंदरसुप्प get_textबस इसे काट नहीं करता है।
— 15
@ जेरियल को खुशी हुई कि आपको यह उपयोगी लगा, कंट्रिब के लिए भी धन्यवाद। किसी और के लिए, जुड़े हुए लिंक को काफी बढ़ाया गया है। ओपी को क्या प्रतीत होता है कि यह एक ऐसा टूल है जो HTML को टेक्स्ट तक ले जाता है, बहुत कुछ टेक्स्ट आधारित ब्राउजर जैसे lynx को। यही समाधान का प्रयास है। ज्यादातर लोग जो योगदान दे रहे हैं वो सिर्फ टेक्स्ट एक्सट्रैक्टर्स हैं।
— २
1

Python 3.x में आप इसे 'इम्पीलिब' और 'ईमेल' पैकेज आयात करके बहुत आसान तरीके से कर सकते हैं। हालांकि यह एक पुरानी पोस्ट है लेकिन शायद मेरा जवाब इस पोस्ट पर नए कामर्स की मदद कर सकता है।

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

अब आप बॉडी वेरिएबल को प्रिंट कर सकते हैं और यह प्लेनटेक्स्ट फॉर्मेट में होगा :) अगर यह आपके लिए काफी अच्छा है तो इसे स्वीकार किए गए उत्तर के रूप में चुनना अच्छा होगा।

— वाहिब उल हक
स्रोत
यह कुछ भी परिवर्तित नहीं करता है ।
— एंटि हापाला
1
यह आपको दिखाता है कि text/plainयदि कोई व्यक्ति किसी अन्य व्यक्ति को वहां रखता है तो उसे ईमेल से एक भाग कैसे निकालना है । यह HTML को प्लेनटेक्स्ट में बदलने के लिए कुछ भी नहीं करता है, और यदि आप HTML को एक वेब साइट से HTML में परिवर्तित करने का प्रयास कर रहे हैं तो यह कुछ भी उपयोगी नहीं है।
— ट्रिपलए
1

आप सुंदर से HTML के साथ केवल पाठ निकाल सकते हैं

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)
— साई गोपी एन
स्रोत
1

हालांकि HTML टैग्स को स्ट्रिप करने के लिए रेगेक्स का उपयोग करने वाले बहुत से लोग डाउनसाइड्स का उपयोग करते हैं।

उदाहरण के लिए:

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

इसे पार्स किया जाना चाहिए:

Hello world
I love you

यहाँ एक स्निपेट है जो मैं लेकर आया था, आप इसे अपनी विशिष्ट आवश्यकताओं के लिए क्यूसोमाइज़ कर सकते हैं, और यह एक आकर्षण की तरह काम करता है

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
— उड़ी गोरें
स्रोत
1

एक और उदाहरण Python 2.7.9+ में BeautifulSoup4 का उपयोग करना

में शामिल हैं:

import urllib2
from bs4 import BeautifulSoup

कोड:

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'))

व्याख्या की:

HTML के रूप में url डेटा में पढ़ें (ब्यूटीफुल का उपयोग करके), सभी स्क्रिप्ट और शैली तत्वों को हटा दें, और .get_text () का उपयोग करके केवल पाठ भी प्राप्त करें। लाइनों में तोड़ो और प्रत्येक पर अग्रणी और अनुगामी स्थान को हटा दें, फिर प्रत्येक पंक्ति में बहु-सुर्खियों को एक पंक्ति में तोड़ें = (वाक्यांश.स्ट्रिप () लाइन में वाक्यांश के लिए लाइन में पंक्ति के लिए। एसपीएलिट (""))। फिर पाठ = '\ n' का उपयोग करके, रिक्त लाइनों को छोड़ दें, अंत में स्वीकृत utf-8 के रूप में वापस लौटें।

टिप्पणियाँ:

  • इस पर चलाया जाने वाला कुछ सिस्टम SSL समस्या के कारण https: // कनेक्शन के साथ विफल हो जाएगा, आप उस समस्या को ठीक करने के लिए सत्यापन को बंद कर सकते हैं। उदाहरण फिक्स: http://blog.pengyifan.com/how-to-fix-python-ssl-certificate_verify_failed/

  • पायथन <2.7.9 में कुछ समस्याएँ हो सकती हैं

  • text.encode ('utf-8') अजीब एन्कोडिंग छोड़ सकता है, इसके बजाय केवल str (पाठ) वापस करना चाह सकता है।

— माइक क्यू
स्रोत
0

यहां मैं एक नियमित आधार पर कोड का उपयोग करता हूं।

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

मुझे आशा है कि वह मदद करेंगे।

— troymyname00
स्रोत
0

LibreOffice लेखक की टिप्पणी में योग्यता है क्योंकि आवेदन अजगर मैक्रोज़ को नियुक्त कर सकता है। इस प्रश्न का उत्तर देने और लिबरऑफिस के मैक्रो बेस को आगे बढ़ाने के लिए यह कई लाभ प्रदान करता है। यदि यह रिज़ॉल्यूशन एक अधिक उत्पादन कार्यक्रम के हिस्से के रूप में उपयोग किए जाने के बजाय एक एकल कार्यान्वयन है, तो लेखक में HTML खोलना और पृष्ठ को पाठ के रूप में सहेजना यहां चर्चा किए गए मुद्दों को हल करना प्रतीत होगा।

— 1of7
स्रोत
0

पर्ल रास्ता (माफ करना माँ, मैं इसे उत्पादन में कभी नहीं करूँगा)।

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
स्रोत
यह बहुत सारे कारणों से बुरा व्यवहार है, उदाहरण के लिए&nbsp;
— उड़ी गोरेन
हाँ! यह सच है! यह किसी भी मत करो!
— ब्रुंकल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.