获取lxml中标签内的所有文本

我想编写一个代码片段<content>，在以下所有三个实例中（包括代码标签），都将在lxml中的标签中捕获所有文本。我已经尝试过了，tostring(getchildren())但是那样会错过标签之间的文本。我没有太多运气在API中搜索相关功能。你能帮我吗？

<!--1-->
<content>
<div>Text inside tag</div>
</content>
#should return "<div>Text inside tag</div>

<!--2-->
<content>
Text with no tag
</content>
#should return "Text with no tag"


<!--3-->
<content>
Text outside tag <div>Text inside tag</div>
</content>
#should return "Text outside tag <div>Text inside tag</div>"

尝试：

def stringify_children(node):
    from lxml.etree import tostring
    from itertools import chain
    parts = ([node.text] +
            list(chain(*([c.text, tostring(c), c.tail] for c in node.getchildren()))) +
            [node.tail])
    # filter removes possible Nones in texts and tails
    return ''.join(filter(None, parts))

例：

from lxml import etree
node = etree.fromstring("""<content>
Text outside tag <div>Text <em>inside</em> tag</div>
</content>""")
stringify_children(node)

产生： '\nText outside tag <div>Text <em>inside</em> tag</div>\n'

text_content（）是否可以满足您的需求？

只需使用该node.itertext()方法即可，如下所示：

 ''.join(node.itertext())

以下使用python生成器的代码片段非常有效并且非常有效。

''.join(node.itertext()).strip()

的的Albertov的一个版本字符串化内容，解决了错误报告hoju：

def stringify_children(node):
    from lxml.etree import tostring
    from itertools import chain
    return ''.join(
        chunk for chunk in chain(
            (node.text,),
            chain(*((tostring(child, with_tail=False), child.tail) for child in node.getchildren())),
            (node.tail,)) if chunk)

定义stringify_children这种方式可能不太复杂：

from lxml import etree

def stringify_children(node):
    s = node.text
    if s is None:
        s = ''
    for child in node:
        s += etree.tostring(child, encoding='unicode')
    return s

或一行

return (node.text if node.text is not None else '') + ''.join((etree.tostring(child, encoding='unicode') for child in node))

基本原理与此答案相同：将子节点的序列化保留为lxml。在这种情况下，该tail部分node并不有趣，因为它位于end标记之后。注意，encoding可以根据需要改变自变量。

另一个可能的解决方案是序列化节点本身，然后剥离开始和结束标签：

def stringify_children(node):
    s = etree.tostring(node, encoding='unicode', with_tail=False)
    return s[s.index(node.tag) + 1 + len(node.tag): s.rindex(node.tag) - 2]

这有点可怕。这段代码只有在node没有属性的情况下才是正确的，而且我认为即使那样，任何人也不想使用它。

import urllib2
from lxml import etree
url = 'some_url'

取得网址

test = urllib2.urlopen(url)
page = test.read()

获取包括表标签在内的所有html代码

tree = etree.HTML(page)

xpath选择器

table = tree.xpath("xpath_here")
res = etree.tostring(table)

res是正在为我工​​作的表格的html代码。

因此您可以使用xpath_text（）提取标签内容，并使用tostring（）提取包含标签内容的标签

div = tree.xpath("//div")
div_res = etree.tostring(div)

text = tree.xpath_text("//content") 

或text = tree.xpath（“ // content / text（）”）

div_3 = tree.xpath("//content")
div_3_res = etree.tostring(div_3).strip('<content>').rstrip('</')

使用strip方法的最后一行不是很好，但它只能工作

实际上最简单的代码段之一（根据http://lxml.de/tutorial.html#using-xpath-to-find-text上的文档为我使用）是

etree.tostring(html, method="text")

其中etree是您尝试读取其全文的节点/标签。请注意，虽然它并没有摆脱脚本和样式标签。

为了回应@Richard的上述评论，如果将stringify_children修补为：

 parts = ([node.text] +
--            list(chain(*([c.text, tostring(c), c.tail] for c in node.getchildren()))) +
++            list(chain(*([tostring(c)] for c in node.getchildren()))) +
           [node.tail])

似乎避免了他所指的重复。

我知道这是一个老问题，但这是一个常见问题，而且我有一个比到目前为止建议的解决方案更简单的解决方案：

def stringify_children(node):
    """Given a LXML tag, return contents as a string

       >>> html = "<p><strong>Sample sentence</strong> with tags.</p>"
       >>> node = lxml.html.fragment_fromstring(html)
       >>> extract_html_content(node)
       "<strong>Sample sentence</strong> with tags."
    """
    if node is None or (len(node) == 0 and not getattr(node, 'text', None)):
        return ""
    node.attrib.clear()
    opening_tag = len(node.tag) + 2
    closing_tag = -(len(node.tag) + 3)
    return lxml.html.tostring(node)[opening_tag:closing_tag]

与该问题的其他一些答案不同，该解决方案保留了其中包含的所有标签，并且从其他工作解决方案的角度出发来解决问题。

给出的答案只是一个快速的增强。如果要清除内部文本：

clean_string = ' '.join([n.strip() for n in node.itertext()]).strip()

这是一个可行的解决方案。我们可以使用父标记获取内容，然后从输出中剪切父标记。

import re
from lxml import etree

def _tostr_with_tags(parent_element, html_entities=False):
    RE_CUT = r'^<([\w-]+)>(.*)</([\w-]+)>$' 
    content_with_parent = etree.tostring(parent_element)    

    def _replace_html_entities(s):
        RE_ENTITY = r'&#(\d+);'

        def repl(m):
            return unichr(int(m.group(1)))

        replaced = re.sub(RE_ENTITY, repl, s, flags=re.MULTILINE|re.UNICODE)

        return replaced

    if not html_entities:
        content_with_parent = _replace_html_entities(content_with_parent)

    content_with_parent = content_with_parent.strip() # remove 'white' characters on margins

    start_tag, content_without_parent, end_tag = re.findall(RE_CUT, content_with_parent, flags=re.UNICODE|re.MULTILINE|re.DOTALL)[0]

    if start_tag != end_tag:
        raise Exception('Start tag does not match to end tag while getting content with tags.')

    return content_without_parent

parent_element必须具有Element类型。

请注意，如果您想要文本内容（而不是文本中的html实体），请将html_entities参数保留为False。

lxml为此提供了一种方法：

node.text_content()

如果这是一个标签，则可以尝试：

node.values()

import re
from lxml import etree

node = etree.fromstring("""
<content>Text before inner tag
    <div>Text
        <em>inside</em>
        tag
    </div>
    Text after inner tag
</content>""")

print re.search("\A<[^<>]*>(.*)</[^<>]*>\Z", etree.tostring(node), re.DOTALL).group(1)