Pythonで文字列からHTMLを取り除く

from mechanize import Browser
br = Browser()
br.open('http://somewebpage')
html = br.response().readlines()
for line in html:
  print line

HTMLファイルの行を印刷するときに、各HTML要素のコンテンツのみを表示し、書式設定自体は表示しない方法を見つけようとしています。が見つかると'<a href="whatever.com">some text</a>'、「一部のテキスト」や'<b>hello</b>'「こんにちは」などの出力のみを行います。これを行うにはどうすればよいでしょうか。

Python stdlibのみが必要であるため、私は常にこの関数を使用してHTMLタグを削除しました。

Python 3の場合：

from io import StringIO
from html.parser import HTMLParser

class MLStripper(HTMLParser):
    def __init__(self):
        super().__init__()
        self.reset()
        self.strict = False
        self.convert_charrefs= True
        self.text = StringIO()
    def handle_data(self, d):
        self.text.write(d)
    def get_data(self):
        return self.text.getvalue()

def strip_tags(html):
    s = MLStripper()
    s.feed(html)
    return s.get_data()

Python 2の場合：

from HTMLParser import HTMLParser
from StringIO import StringIO

class MLStripper(HTMLParser):
    def __init__(self):
        self.reset()
        self.text = StringIO()
    def handle_data(self, d):
        self.text.write(d)
    def get_data(self):
        return self.text.getvalue()

def strip_tags(html):
    s = MLStripper()
    s.feed(html)
    return s.get_data()

私はそれが見逃すケースについてはあまり考えていませんが、簡単な正規表現を行うことができます：

re.sub('<[^<]+?>', '', text)

正規表現を理解しない人のために、これは文字列を検索します<...>。内部コンテンツは、1つ以上の（+）以外の（）文字で構成されています<。?それは見つけることができる最小の文字列と一致することを意味します。たとえば、指定された<p>Hello</p>場合は<'p>、と</p>個別に一致し?ます。それがなければ、それは文字列全体と一致します<..Hello..>。

非タグ<がhtmlに表示される場合（例：）2 < 3、それは&...とにかくエスケープシーケンスとして記述する必要が^<あります。

BeautifulSoup get_text()機能を使用できます。

from bs4 import BeautifulSoup

html_str = '''
<td><a href="http://www.fakewebsite.com">Please can you strip me?</a>
<br/><a href="http://www.fakewebsite.com">I am waiting....</a>
</td>
'''
soup = BeautifulSoup(html_str)

print(soup.get_text()) 
#or via attribute of Soup Object: print(soup.text)

出力を再現できるようにするには、パーサーを明示的に（たとえば）に指定することをお勧めしますBeautifulSoup(html_str, features="html.parser")。

短縮版！

import re, cgi
tag_re = re.compile(r'(<!--.*?-->|<[^>]*>)')

# Remove well-formed tags, fixing mistakes by legitimate users
no_tags = tag_re.sub('', user_input)

# Clean up anything else by escaping
ready_for_web = cgi.escape(no_tags)

正規表現のソース：MarkupSafe。これらのバージョンはHTMLエンティティも処理しますが、この簡単なバージョンは処理しません。

タグを削除してそのままにできないのはなぜですか？

人を浮かば<i>italicizing</i>せずに、人を物事から遠ざけることは、1つのことiです。しかし、任意の入力を取り、それを完全に無害にすることは別の方法です。このページのほとんどのテクニックでは、閉じられていないコメント（<!--）やタグの一部ではない山括弧（blah <<<><blah）などをそのまま残します。HTMLParserバージョンでは、タグが閉じられていないコメント内にある場合でも、完全なタグを残すことができます。

あなたのテンプレートがどうなったら{{ firstname }} {{ lastname }}？ firstname = '<a'またlastname = 'href="http://evil.com/">'、このページのすべてのタグストリッパー（@Medeiros！を除く）によって許可されます。これらはそれ自体では完全なタグではないためです。通常のHTMLタグを取り除くだけでは不十分です。

Django strip_tagsは、この質問に対するトップアンサーの改良（次の見出しを参照）バージョンであり、次の警告を出します。

結果の文字列がHTMLセーフであるという保証は一切ありません。したがってstrip_tags、たとえばを使用して、最初にエスケープせずに呼び出しの結果を安全とマークしないでくださいescape()。

彼らのアドバイスに従ってください！

HTMLParserでタグを取り除くには、タグを複数回実行する必要があります。

この質問に対するトップ回答を簡単に回避することは簡単です。

この文字列を見てください（ソースとディスカッション）：

<img<!-- --> src=x onerror=alert(1);//><!-- -->

HTMLParserがそれを初めて見たとき、それが<img...>タグであることを認識できません。壊れているように見えるので、HTMLParserはそれを取り除きません。それだけ<!-- comments -->で、あなたを残して

<img src=x onerror=alert(1);//>

この問題は、2014年3月にDjangoプロジェクトに公開されました。彼らの古い問題はstrip_tags、この質問のトップアンサーと基本的に同じでした。 彼らの新しいバージョンは基本的にループで実行され、再度実行しても文字列は変更されません。

# _strip_once runs HTMLParser once, pulling out just the text of all the nodes.

def strip_tags(value):
    """Returns the given HTML with all tags stripped."""
    # Note: in typical case this loop executes _strip_once once. Loop condition
    # is redundant, but helps to reduce number of executions of _strip_once.
    while '<' in value and '>' in value:
        new_value = _strip_once(value)
        if len(new_value) >= len(value):
            # _strip_once was not able to detect more tags
            break
        value = new_value
    return value

もちろん、の結果を常にエスケープする場合、これは問題になりませんstrip_tags()。

2015年3月19日更新：1.4.20、1.6.11、1.7.7、および1.8c1より前のDjangoバージョンにはバグがありました。これらのバージョンは、strip_tags（）関数で無限ループに入る可能性があります。修正バージョンは上記で再現されています。 詳細はこちら。

コピーまたは使用する良いもの

私のサンプルコードはHTMLエンティティを処理しません-DjangoとMarkupSafeのパッケージバージョンは処理します。

私のサンプルコードは、クロスサイトスクリプティング防止のための優れたMarkupSafeライブラリから抜粋したものです。便利で高速です（CはネイティブのPythonバージョンに高速化されています）。Google App Engineに含まれており、Jinja2（2.7以降）で使用されています、Mako、Pylonsています。Django 1.7のDjangoテンプレートで簡単に動作します。

Djangoのstrip_tagsやその他の最新バージョンのhtmlユーティリティは優れていますが、MarkupSafeほど便利ではありません。それらはかなり自己完結型であり、必要なものをこのファイルからコピーできます。

ほとんどすべてのタグを取り除く必要がある場合は、Bleachライブラリが最適です。「ユーザーはイタリックにすることはできますが、iframeを作成することはできません」などのルールを適用することができます。

タグストリッパーの特性を理解しましょう！ファズテストを実行してください！ これが、この回答の調査に使用したコードです。

sheepish note-質問自体はコンソールへの印刷に関するものですが、これは「文字列からのpythonストリップHTML」のGoogleの上位の結果です。そのため、この答えはWebに関する99％です。

タグを取り除き、HTMLエンティティをプレーンテキストにデコードする方法が必要でした。次のソリューションは、Eloffの回答に基づいています（エンティティを削除するため使用できませんでした）。

from HTMLParser import HTMLParser
import htmlentitydefs

class HTMLTextExtractor(HTMLParser):
    def __init__(self):
        HTMLParser.__init__(self)
        self.result = [ ]

    def handle_data(self, d):
        self.result.append(d)

    def handle_charref(self, number):
        codepoint = int(number[1:], 16) if number[0] in (u'x', u'X') else int(number)
        self.result.append(unichr(codepoint))

    def handle_entityref(self, name):
        codepoint = htmlentitydefs.name2codepoint[name]
        self.result.append(unichr(codepoint))

    def get_text(self):
        return u''.join(self.result)

def html_to_text(html):
    s = HTMLTextExtractor()
    s.feed(html)
    return s.get_text()

簡単なテスト：

html = u'<a href="#">Demo <em>(&not; \u0394&#x03b7;&#956;&#x03CE;)</em></a>'
print repr(html_to_text(html))

結果：

u'Demo (\xac \u0394\u03b7\u03bc\u03ce)'

エラー処理：

• 無効なHTML構造は、HTMLParseErrorを引き起こす可能性があります。
• 無効な名前付きHTMLエンティティ（&#apos;XMLやXHTMLでは有効ですが、プレーンHTMLではありません）はValueError例外を引き起こします。
• Pythonが受け入れることができるUnicode範囲外のコードポイントを指定する数値HTMLエンティティ（一部のシステムでは、Basic Multilingual Planeの外の文字など）は、ValueError例外の原因になります。

セキュリティ上の注意： HTMLストリッピング（HTMLをプレーンテキストに変換）とHTMLサニタイズ（プレーンテキストをHTMLに変換）を混同しないでください。この回答は、HTMLを削除し、エンティティをプレーンテキストにデコードします。これにより、HTMLコンテキストで結果を安全に使用できなくなります。

例：<script>alert("Hello");</script>はに変換されます<script>alert("Hello");</script>。これは100％正しい動作ですが、結果のプレーンテキストをそのままHTMLページに挿入する場合は明らかに不十分です。

ルールは難しいことではありません。いつでもあなたは、HTML出力にプレーンテキストの文字列を挿入し、あなたがすべき常に HTML（使用して、それを逃れるcgi.escape(s, True)ことはHTMLが含まれていないことをあなたが「知っている」場合でも、）（例えば、あなたがHTMLコンテンツを取り除いているため） 。

（ただし、OPは結果をコンソールに出力することを尋ねました。この場合、HTMLエスケープは必要ありません。）

Python 3.4以降のバージョン：（doctest付き！）

import html.parser

class HTMLTextExtractor(html.parser.HTMLParser):
    def __init__(self):
        super(HTMLTextExtractor, self).__init__()
        self.result = [ ]

    def handle_data(self, d):
        self.result.append(d)

    def get_text(self):
        return ''.join(self.result)

def html_to_text(html):
    """Converts HTML to plain text (stripping tags and converting entities).
    >>> html_to_text('<a href="#">Demo<!--...--> <em>(&not; \u0394&#x03b7;&#956;&#x03CE;)</em></a>')
    'Demo (\xac \u0394\u03b7\u03bc\u03ce)'

    "Plain text" doesn't mean result can safely be used as-is in HTML.
    >>> html_to_text('&lt;script&gt;alert("Hello");&lt;/script&gt;')
    '<script>alert("Hello");</script>'

    Always use html.escape to sanitize text before using in an HTML context!

    HTMLParser will do its best to make sense of invalid HTML.
    >>> html_to_text('x < y &lt z <!--b')
    'x < y < z '

    Unrecognized named entities are included as-is. '&apos;' is recognized,
    despite being XML only.
    >>> html_to_text('&nosuchentity; &apos; ')
    "&nosuchentity; ' "
    """
    s = HTMLTextExtractor()
    s.feed(html)
    return s.get_text()

HTMLParserはPython 3で改善されていることに注意してください（つまり、コードが少なくなり、エラー処理が改善されます）。

これには簡単な方法があります：

def remove_html_markup(s):
    tag = False
    quote = False
    out = ""

    for c in s:
            if c == '<' and not quote:
                tag = True
            elif c == '>' and not quote:
                tag = False
            elif (c == '"' or c == "'") and tag:
                quote = not quote
            elif not tag:
                out = out + c

    return out

アイデアはここで説明されています：http : //youtu.be/2tu9LTDujbw

あなたはそれがここで機能しているのを見ることができます：http：//youtu.be/HPkNPcYed9M？t = 35s

PS-クラスに興味がある場合（Pythonによるスマートデバッグについて）、リンクを提供します：http : //www.udacity.com/overview/Course/cs259/CourseRev/1。それは無料です！

どういたしまして！:)

HTMLエンティティ（つまり&）を保持する必要がある場合は、Eloffの回答に「handle_entityref」メソッドを追加しました。

from HTMLParser import HTMLParser

class MLStripper(HTMLParser):
    def __init__(self):
        self.reset()
        self.fed = []
    def handle_data(self, d):
        self.fed.append(d)
    def handle_entityref(self, name):
        self.fed.append('&%s;' % name)
    def get_data(self):
        return ''.join(self.fed)

def html_to_text(html):
    s = MLStripper()
    s.feed(html)
    return s.get_data()

すべてのHTMLタグを削除したい場合、私が見つけた最も簡単な方法はBeautifulSoupを使用することです。

from bs4 import BeautifulSoup  # Or from BeautifulSoup import BeautifulSoup

def stripHtmlTags(htmlTxt):
    if htmlTxt is None:
            return None
        else:
            return ''.join(BeautifulSoup(htmlTxt).findAll(text=True)) 

受け入れられた回答のコードを試してみましたが、上記のコードブロックでは発生しなかった「RuntimeError：最大再帰深度を超えました」が発生しました。

HTMLタグを取り除き、驚くほど高速なlxmlライブラリに基づいてHTMLエンティティをデコードする簡単なソリューションを次に示します。

from lxml import html

def strip_html(s):
    return str(html.fromstring(s).text_content())

strip_html('Ein <a href="">sch&ouml;ner</a> Text.')  # Output: Ein schöner Text.

lxml.htmlベースのソリューション（lxmlのは、ネイティブライブラリ、したがって、はるかに高速任意の純粋なPythonのソリューションよりもあります）。

from lxml import html
from lxml.html.clean import clean_html

tree = html.fromstring("""<span class="item-summary">
                            Detailed answers to any questions you might have
                        </span>""")

print(clean_html(tree).strip())

# >>> Detailed answers to any questions you might have

lxml.cleanerが正確に行うことについては、http： //lxml.de/lxmlhtml.html#cleaning-up-html も参照してください。

テキストに変換する前に、何をサニタイズするかをより細かく制御する必要がある場合は、コンストラクターで必要なオプションを渡してlxml Cleanerを明示的に使用することができます。例：

cleaner = Cleaner(page_structure=True,
                  meta=True,
                  embedded=True,
                  links=True,
                  style=True,
                  processing_instructions=True,
                  inline_style=True,
                  scripts=True,
                  javascript=True,
                  comments=True,
                  frames=True,
                  forms=True,
                  annoying_tags=True,
                  remove_unknown_tags=True,
                  safe_attrs_only=True,
                  safe_attrs=frozenset(['src','color', 'href', 'title', 'class', 'name', 'id']),
                  remove_tags=('span', 'font', 'div')
                  )
sanitized_html = cleaner.clean_html(unsafe_html)

Beautiful Soupパッケージはこれをすぐに行います。

from bs4 import BeautifulSoup

soup = BeautifulSoup(html)
text = soup.get_text()
print(text)

これがPython 3の私の解決策です。

import html
import re

def html_to_txt(html_text):
    ## unescape html
    txt = html.unescape(html_text)
    tags = re.findall("<[^>]+>",txt)
    print("found tags: ")
    print(tags)
    for tag in tags:
        txt=txt.replace(tag,'')
    return txt

それが完璧かどうかはわかりませんが、私のユースケースを解決し、簡単に思えます。

別のHTMLパーサー（lxmlやBeautiful Soupなど）を使用できます。これは、テキストのみを抽出する機能を提供するものです。または、タグを取り除くラインストリングで正規表現を実行できます。詳細については、Pythonのドキュメントをご覧ください。

Eloffの答えをPython 3.1でうまく利用しました[どうもありがとう！]

Python 3.2.3にアップグレードしたところ、エラーが発生しました。

レスポンダThomas Kのおかげでここに提供された解決策はsuper().__init__()、次のコードに挿入することです：

def __init__(self):
    self.reset()
    self.fed = []

...次のようにするために：

def __init__(self):
    super().__init__()
    self.reset()
    self.fed = []

...そしてそれはPython 3.2.3で動作します。

繰り返しになりますが、修正とEloffの元のコードを提供してくれたThomas Kに感謝します！

独自の関数を書くことができます：

def StripTags(text):
     finished = 0
     while not finished:
         finished = 1
         start = text.find("<")
         if start >= 0:
             stop = text[start:].find(">")
             if stop >= 0:
                 text = text[:start] + text[start+stop+1:]
                 finished = 0
     return text

HTML-Parserを使用したソリューションは、一度しか実行されない場合、すべて破壊可能です。

html_to_text('<<b>script>alert("hacked")<</b>/script>

結果は：

<script>alert("hacked")</script>

あなたが防ぐつもりのもの。HTMLパーサーを使用する場合は、ゼロが置き換えられるまでタグを数えます。

from HTMLParser import HTMLParser

class MLStripper(HTMLParser):
    def __init__(self):
        self.reset()
        self.fed = []
        self.containstags = False

    def handle_starttag(self, tag, attrs):
       self.containstags = True

    def handle_data(self, d):
        self.fed.append(d)

    def has_tags(self):
        return self.containstags

    def get_data(self):
        return ''.join(self.fed)

def strip_tags(html):
    must_filtered = True
    while ( must_filtered ):
        s = MLStripper()
        s.feed(html)
        html = s.get_data()
        must_filtered = s.has_tags()
    return html

これは簡単な修正であり、さらに最適化できますが、正常に動作します。このコードは、空でないすべてのタグを ""で置き換え、指定された入力テキストからすべてのhtmlタグを取り除きます。./file.pyinput outputを使用して実行できます。

    #!/usr/bin/python
import sys

def replace(strng,replaceText):
    rpl = 0
    while rpl > -1:
        rpl = strng.find(replaceText)
        if rpl != -1:
            strng = strng[0:rpl] + strng[rpl + len(replaceText):]
    return strng


lessThanPos = -1
count = 0
listOf = []

try:
    #write File
    writeto = open(sys.argv[2],'w')

    #read file and store it in list
    f = open(sys.argv[1],'r')
    for readLine in f.readlines():
        listOf.append(readLine)         
    f.close()

    #remove all tags  
    for line in listOf:
        count = 0;  
        lessThanPos = -1  
        lineTemp =  line

            for char in lineTemp:

            if char == "<":
                lessThanPos = count
            if char == ">":
                if lessThanPos > -1:
                    if line[lessThanPos:count + 1] != '<>':
                        lineTemp = replace(lineTemp,line[lessThanPos:count + 1])
                        lessThanPos = -1
            count = count + 1
        lineTemp = lineTemp.replace("&lt","<")
        lineTemp = lineTemp.replace("&gt",">")                  
        writeto.write(lineTemp)  
    writeto.close() 
    print "Write To --- >" , sys.argv[2]
except:
    print "Help: invalid arguments or exception"
    print "Usage : ",sys.argv[0]," inputfile outputfile"

søren-løvborgの答えのpython 3への適合

from html.parser import HTMLParser
from html.entities import html5

class HTMLTextExtractor(HTMLParser):
    """ Adaption of http://stackoverflow.com/a/7778368/196732 """
    def __init__(self):
        super().__init__()
        self.result = []

    def handle_data(self, d):
        self.result.append(d)

    def handle_charref(self, number):
        codepoint = int(number[1:], 16) if number[0] in (u'x', u'X') else int(number)
        self.result.append(unichr(codepoint))

    def handle_entityref(self, name):
        if name in html5:
            self.result.append(unichr(html5[name]))

    def get_text(self):
        return u''.join(self.result)

def html_to_text(html):
    s = HTMLTextExtractor()
    s.feed(html)
    return s.get_text()

1つのプロジェクトでは、HTMLだけでなくcssおよびjsも必要でした。したがって、私はEloffsの回答のバリエーションを作りました：

class MLStripper(HTMLParser):
    def __init__(self):
        self.reset()
        self.strict = False
        self.convert_charrefs= True
        self.fed = []
        self.css = False
    def handle_starttag(self, tag, attrs):
        if tag == "style" or tag=="script":
            self.css = True
    def handle_endtag(self, tag):
        if tag=="style" or tag=="script":
            self.css=False
    def handle_data(self, d):
        if not self.css:
            self.fed.append(d)
    def get_data(self):
        return ''.join(self.fed)

def strip_tags(html):
    s = MLStripper()
    s.feed(html)
    return s.get_data()

これは、現在受け入れられている回答（https://stackoverflow.com/a/925630/95989）に似たソリューションですが、内部のHTMLParserクラスを直接する（つまり、サブクラス化しない）ため、非常に簡潔になります。

def strip_html（text）：
    パーツ= []                                                                      
    パーサー= HTMLParser（）                                                           
    parser.handle_data = parts.append                                               
    parser.feed（text）                                                               
    戻り値 '' .join（parts）

私はGithubのreadmeを解析していますが、以下が本当にうまくいくことがわかりました。

import re
import lxml.html

def strip_markdown(x):
    links_sub = re.sub(r'\[(.+)\]\([^\)]+\)', r'\1', x)
    bold_sub = re.sub(r'\*\*([^*]+)\*\*', r'\1', links_sub)
    emph_sub = re.sub(r'\*([^*]+)\*', r'\1', bold_sub)
    return emph_sub

def strip_html(x):
    return lxml.html.fromstring(x).text_content() if x else ''

その後

readme = """<img src="https://raw.githubusercontent.com/kootenpv/sky/master/resources/skylogo.png" />

            sky is a web scraping framework, implemented with the latest python versions in mind (3.4+). 
            It uses the asynchronous `asyncio` framework, as well as many popular modules 
            and extensions.

            Most importantly, it aims for **next generation** web crawling where machine intelligence 
            is used to speed up the development/maintainance/reliability of crawling.

            It mainly does this by considering the user to be interested in content 
            from *domains*, not just a collection of *single pages*
            ([templating approach](#templating-approach))."""

strip_markdown(strip_html(readme))

すべてのマークダウンとHTMLを正しく削除します。

BeautifulSoup、html2text、または@Eloffのコードを使用すると、ほとんどの場合、いくつかのHTML要素、JavaScriptコードが残ります...

したがって、これらのライブラリの組み合わせを使用して、マークダウンフォーマットを削除できます（Python 3）。

import re
import html2text
from bs4 import BeautifulSoup
def html2Text(html):
    def removeMarkdown(text):
        for current in ["^[ #*]{2,30}", "^[ ]{0,30}\d\\\.", "^[ ]{0,30}\d\."]:
            markdown = re.compile(current, flags=re.MULTILINE)
            text = markdown.sub(" ", text)
        return text
    def removeAngular(text):
        angular = re.compile("[{][|].{2,40}[|][}]|[{][*].{2,40}[*][}]|[{][{].{2,40}[}][}]|\[\[.{2,40}\]\]")
        text = angular.sub(" ", text)
        return text
    h = html2text.HTML2Text()
    h.images_to_alt = True
    h.ignore_links = True
    h.ignore_emphasis = False
    h.skip_internal_links = True
    text = h.handle(html)
    soup = BeautifulSoup(text, "html.parser")
    text = soup.text
    text = removeAngular(text)
    text = removeMarkdown(text)
    return text

それは私にとってはうまくいきますが、もちろん強化することができます...

シンプルなコード！。これにより、すべての種類のタグとその中のコンテンツが削除されます。

def rm(s):
    start=False
    end=False
    s=' '+s
    for i in range(len(s)-1):
        if i<len(s):
            if start!=False:
                if s[i]=='>':
                    end=i
                    s=s[:start]+s[end+1:]
                    start=end=False
            else:
                if s[i]=='<':
                    start=i
    if s.count('<')>0:
        self.rm(s)
    else:
        s=s.replace('&nbsp;', ' ')
        return s

ただし、テキスト内に<>記号が含まれている場合、完全な結果は得られません。

# This is a regex solution.
import re
def removeHtml(html):
  if not html: return html
  # Remove comments first
  innerText = re.compile('<!--[\s\S]*?-->').sub('',html)
  while innerText.find('>')>=0: # Loop through nested Tags
    text = re.compile('<[^<>]+?>').sub('',innerText)
    if text == innerText:
      break
    innerText = text

  return innerText.strip()

この方法は私にとって問題なく機能し、追加のインストールは必要ありません。

import re
import htmlentitydefs

def convertentity(m):
    if m.group(1)=='#':
        try:
            return unichr(int(m.group(2)))
        except ValueError:
            return '&#%s;' % m.group(2)
        try:
            return htmlentitydefs.entitydefs[m.group(2)]
        except KeyError:
            return '&%s;' % m.group(2)

def converthtml(s):
    return re.sub(r'&(#?)(.+?);',convertentity,s)

html =  converthtml(html)
html.replace(" ", " ") ## Get rid of the remnants of certain formatting(subscript,superscript,etc).