必威-必威-欢迎您

必威,必威官网企业自成立以来,以策略先行,经营致胜,管理为本的商,业推广理念,一步一个脚印发展成为同类企业中经营范围最广,在行业内颇具影响力的企业。

这篇文章是打算来写 XPath必威 的,difflib模块提供

2019-11-22 05:15 来源:未知
    • 导入ElementTree,import xml.etree.ElementTree as ET
    • 深入分析Xml文件找到根节点:
    • 一直解析XML文件并赢得根节点,tree = ET.parse('country_data.xml') root = tree.getroot()
    • 深入分析字符串,root = ET.fromstring(country_data_as_string)
    • 遍历根节点能够收获子节点,然后就足以依靠须要得到需求的字段了,如:<应用程式_KEY channel = 'CSDN'> hello123456789 </APP_KEY>
      • tag,即标签,用于标志该因素表示哪类多少,即应用程式_KEY
      • attrib,即属性,用Dictionary格局保存,即{'channel' = 'CSDN'}
      • text,文本字符串,能够用来积存一些数量,即hello123456789
      • tail,尾字符串,并不是必得的,例子中并未有包括。

假定格式化差别文本需求标题和改变时间消息,通过fromfile, tofile, fromfiledate, 和 tofiledate举办支配,假使不设置,默以为空

lxml.html

Since version 2.0, lxml comes with a dedicated Python package for dealing with HTML: lxml.html. It is based on lxml's HTML parser, but provides a special Element API for HTML elements, as well as a number of utilities for common HTML processing tasks.

The main API is based on the lxml.etree API, and thus, on the ElementTree API.

lxml.html 是一个特地用来管理 HTML 文书档案的,即便她依然是基于 HTML parser 的,但是他提供了过多有针对的 API 。这里只作叁个简便介绍,浓郁精晓,请查阅官方文书档案。

率先在剖析 HTML 文本上加码了几个情势:

  • document_fromstring(string)
  • fragment_fromstring(string, create_parent=False)
  • fragments_fromstring(string)

说不上对于 HTML 成分,除了从前的措施之外又加了部分:

  • .drop_tree()

    删去该因素及其具备子成分,就如 el.getparent().remove(el),可是不会删除该因素的 .tail ,.tail 将会与前三个因素合并。

  • .drop_tag()

    剔除该标签,可是会保留该因素的子元素与公事。

  • .find_class(class_name)

    归来叁个带有 class_name CSS 的要素列表。

  • .find_rel_links(rel)

    回到八个<a rel="{rel}">的成分列表

  • .get_element_by_id(id, default=None)

    透过 id 查找元素,若无回到暗许,假设文书档案违规现身三个同 id 的因素,仅重临第一个。

  • .text_content()

    重回成分的公文内容,包括其后代的文书内容。

  • .cssselect(expr)

    经过 CSS 采取器选拔成分。

  • .set(key, value=None)

    安装成分属性,假若 value 未有给依旧是 None ,那么将创造三个 boolean attribute (属性只要现身即表示真,无论 value 是何许,哪怕是个空白) E.g. <div checked></div>

正如文章最先说的极度, lxml.html.soupparser 能够引进 BeautifulSoup ,以至足以仅使用 BeautifulSoup 的编码检查实验模块 UnicodeDammit 。

最终就是能够使用 lxml.html.open_in_browser(lxml_doc) 直接在浏览器中显示文档,以致能够对文档的表单举办付出操作。

以上都以据本人的精晓而写,如有错误之处,款待调换。

python difflib模块示例批注,pythondifflib

difflib模块提供的类和办法用来拓宽类别的差距化相比,它亦可比对文件并扭转差别结果文本恐怕html格式的差距化相比较页面,若是供给相比较目录的例外,能够选用filecmp模块。

class difflib.SequenceMatcher

此类提供了比较随意可哈希类型连串对艺术。此方法将搜索未有富含‘垃圾'成分的最大一而再相称种类。

经过对算法的复杂度比较,它由于原有的完形相称算法,在最坏景况下有n的平方次运算,在最棒状态下,具无线性的频率。

它有着自动垃圾启迪式,能够将另行业先部分1%要么另行200次的字符作为垃圾来管理。能够通过将autojunk设置为false关闭该意义。

class difflib.Differ

该类相比较的是文本行的差距并且发生相符人类阅读的歧异结果大概增量结果,结果中各部分的意味如下:

必威 1

class difflib.HtmlDiff

 此类能够被用来创制HTML表格 (或然说包涵表格的html文件) ,两侧对应展现或许行对行的来得比对差距结果。

 make_file(fromlines, tolines [, fromdesc][, todesc][, context][, numlines])

make_table(fromlines, tolines [, fromdesc][, todesc][, context][, numlines])

上述四个章程都足以用来生成包罗三个剧情为比对结果的报表的html文件,何况有些剧情会高亮显示。

difflib.context_diff(a, b[, fromfile][, tofile][, fromfiledate][, tofiledate][, n][, lineterm])

相比较a与b(字符串列表),并且重临三个差别文本行的生成器
示例:

>>> s1 = ['baconn', 'eggsn', 'hamn', 'guidon']
>>> s2 = ['pythonn', 'eggyn', 'hamstern', 'guidon']
>>> for line in context_diff(s1, s2, fromfile='before.py', tofile='after.py'):
...   sys.stdout.write(line) 
*** before.py
--- after.py
***************
*** 1,4 ****
! bacon
! eggs
! ham
 guido
--- 1,4 ----
! python
! eggy
! hamster
 guido

difflib.get_close_matches(word, possibilities[, n][, cutoff])

回到最大相配结果的列表

示例:

>>> get_close_matches('appel', ['ape', 'apple', 'peach', 'puppy'])
['apple', 'ape']
>>> import keyword
>>> get_close_matches('wheel', keyword.kwlist)
['while']
>>> get_close_matches('apple', keyword.kwlist)
[]
>>> get_close_matches('accept', keyword.kwlist)
['except']

difflib.ndiff(a, b[, linejunk][, charjunk])

正如a与b(字符串列表),重返一个Differ-style 的差距结果
示例:

>>> diff = ndiff('onentwonthreen'.splitlines(1),
...       'orentreenemun'.splitlines(1))
>>> print ''.join(diff),
- one
? ^
+ ore
? ^
- two
- three
? -
+ tree
+ emu

difflib.restore(sequence, which)

再次回到三个由多个比对体系产生的结果

示例

>>> diff = ndiff('onentwonthreen'.splitlines(1),
...       'orentreenemun'.splitlines(1))
>>> diff = list(diff) # materialize the generated delta into a list
>>> print ''.join(restore(diff, 1)),
one
two
three
>>> print ''.join(restore(diff, 2)),
ore
tree
emu

difflib.unified_diff(a, b[, fromfile][, tofile][, fromfiledate][, tofiledate][, n][, lineterm])

正如a与b(字符串列表),重临三个unified diff格式的差距结果.

示例:

>>> s1 = ['baconn', 'eggsn', 'hamn', 'guidon']
>>> s2 = ['pythonn', 'eggyn', 'hamstern', 'guidon']
>>> for line in unified_diff(s1, s2, fromfile='before.py', tofile='after.py'):
...  sys.stdout.write(line) 
--- before.py
+++ after.py
@@ -1,4 +1,4 @@
-bacon
-eggs
-ham
+python
+eggy
+hamster
 guido

实在使用示范

比对八个文件,然后生成一个展现差距结果的HTML文件

#coding:utf-8
'''
file:difflibeg.py
date:2017/9/9 10:33
author:lockey
email:[email protected]
desc:diffle module learning and practising 
'''
import difflib
hd = difflib.HtmlDiff()
loads = ''
with open('G:/python/note/day09/0907code/hostinfo/cpu.py','r') as load:
 loads = load.readlines()
 load.close()

mems = ''
with open('G:/python/note/day09/0907code/hostinfo/mem.py', 'r') as mem:
 mems = mem.readlines()
 mem.close()

with open('htmlout.html','a+') as fo:
 fo.write(hd.make_file(loads,mems))
 fo.close()

运维结果:

必威 2

转移的html文件比对结果:

必威 3

上述正是本文的全部内容,希望对大家的求学抱有利于,也目的在于大家多多点拨帮客之家。

difflib模块示例批注,pythondifflib difflib模块提供的类和章程用来实行种类的差距化相比较,它可以比对文件并转移差别结果文本也许html格...

3、platform库 -------- 获取当前系统

以此模块提供的类和情势用来拓宽差别化相比较,它能够转移文书只怕html格式的差别化比较结实,如若须求比较目录的不等,尚可filecmp模块。

BeautifulSoup 能够将 lxml 作为拆解解析器,这一个自家是明白的,但是lmxl.html.soupparser 能够调用 BeautifulSoup 小编就不精晓了。刚初阶认为掌握错误,不过真的在源码中找到的证据,soupparser 模块中引进了 BeautifulSoup ,而且也调用了该函数。

      • tabsize表示制表符代表的空格个数,默以为8
      • wrapcolumn,可选参数,用来安装有个别个字符时自动换行,暗中认可None,为None时表示不自动换行(器重:能够让html突显越来越雅观卡塔 尔(英语:State of Qatar)
      • linejunk 和 charjunk,可选参数,在ndiff()中运用,

Tools/scripts/ndiff.py 是举办这一方法的实例:

人生苦短,笔者用Python。

 

difflib.ndiff

开场,那篇小说是希图来写 XPath 的,可是后来风度翩翩想,笔者索要的仅是 XPath 的意气风发部分,作者然则是希图在写爬虫的时候,抓取特定数据的,并且那是急需整合 lxml 的,So ,索性就来写 lxml 来了。(lxml supports XPath 1.0, XSLT 1.0 and the EXSLT extensions through libxml2 and libxslt in a standards compliant way.那是学科上的黄金年代段话,然则XPath现在是有2.0本子的。)

##############################以下是代码部分,附件文件可以拖到本地执行并查看结果##################################################

  1 # coding=utf-8
  2 import re
  3 import xml.etree.ElementTree as ET  #解析xml的库
  4 import difflib   #文件对比库
  5 import datetime  #时间库
  6 import platform  #获取系统的库window、linux...
  7 import os
  8 from robot.api import logger    #不需要的话可以注释掉:robot framework框架脚本运行时会产生日志,可以利用这个库定制log
  9 
 10 # listafter:将解析后的xml,转换成按序排列的list:(tag,attrib,(tag,attrib,text))
 11 # 此方法是被下面一个方法xmltolist()调用的,想知道具体结果,可以使用下面的方法打印解析后的结果
 12 def listafter(listcom1):
 13     listcomarr1 = []
 14     text1 = []
 15     listcomarr1.append(listcom1.tag)
 16     listcomarr1.append(listcom1.attrib)
 17     if len(listcom1) > 0:
 18         for listcom2 in listcom1:
 19             listcomarr2 = []
 20             text2 = []
 21             listcomarr2.append(listcom2.tag)
 22             listcomarr2.append(listcom2.attrib)
 23             if len(listcom2) > 0:
 24                 for listcom3 in listcom2:
 25                     listcomarr3 = []
 26                     text3 = []
 27                     listcomarr3.append(listcom3.tag)
 28                     listcomarr3.append(listcom3.attrib)
 29                     if len(listcom3) > 0:
 30                         for listcom4 in listcom3:
 31                             listcomarr4 = []
 32                             text4 = []
 33                             listcomarr4.append(listcom4.tag)
 34                             listcomarr4.append(listcom4.attrib)
 35                             if len(listcom4) > 0:
 36                                 for listcom5 in listcom4:
 37                                     listcomarr5 = []
 38                                     text5 = []
 39                                     listcomarr5.append(listcom5.tag)
 40                                     listcomarr5.append(listcom5.attrib)
 41                                     if len(listcom5) > 0:
 42                                         for listcom6 in listcom5:
 43                                             listcomarr6 = []
 44                                             text6 = []
 45                                             listcomarr6.append(listcom6.tag)
 46                                             listcomarr6.append(listcom6.attrib)
 47                                             if len(listcom6) > 0:
 48                                                 for listcom7 in listcom6:
 49                                                     listcomarr7 = []
 50                                                     text7 = []
 51                                                     listcomarr7.append(listcom7.tag)
 52                                                     listcomarr7.append(listcom7.attrib)
 53                                                     if len(listcom7) > 0:
 54                                                         for listcom8 in listcom7:
 55                                                             listcomarr8 = []
 56                                                             text8 = []
 57                                                             listcomarr8.append(listcom8.tag)
 58                                                             listcomarr8.append(listcom8.attrib)
 59                                                             if len(listcom8) > 0:
 60                                                                 for listcom9 in listcom8:
 61                                                                     listcomarr9 = []
 62                                                                     text9 = []
 63                                                                     listcomarr9.append(listcom9.tag)
 64                                                                     listcomarr9.append(listcom9.attrib)
 65                                                                     # Start:判断是否需要继续递归
 66                                                                     if len(listcom9) > 0:
 67                                                                         for listcom10 in listcom9:
 68                                                                             listcomarr10 = []
 69                                                                             text10 = []
 70                                                                             listcomarr10.append(listcom10.tag)
 71                                                                             listcomarr10.append(listcom10.attrib)
 72                                                                             listcomarr10.append([listcom10.text])
 73                                                                             text9.append(listcomarr10)
 74                                                                     else:
 75                                                                         text9.append(listcom9.text)
 76                                                                     # End:判断是否需要继续递归
 77                                                                     # list二维数组排序
 78                                                                     text9 = sorted(text9)
 79                                                                     listcomarr9.append(text9)
 80                                                                     text8.append(listcomarr9)
 81                                                             else:
 82                                                                 text8.append(listcom8.text)
 83                                                             text8 = sorted(text8)
 84                                                             listcomarr8.append(text8)
 85                                                             text7.append(listcomarr8)
 86                                                     else:
 87                                                         text7.append(listcom7.text)
 88                                                     text7 = sorted(text7)
 89                                                     listcomarr7.append(text7)
 90                                                     text6.append(listcomarr7)
 91                                             else:
 92                                                 text6.append(listcom6.text)
 93                                             text6 = sorted(text6)
 94                                             listcomarr6.append(text6)
 95                                             text5.append(listcomarr6)
 96                                     else:
 97                                         text5.append(listcom5.text)
 98                                     text5 = sorted(text5)
 99                                     listcomarr5.append(text5)
100                                     text4.append(listcomarr5)
101                             else:
102                                 text4.append(listcom4.text)
103                             text4 = sorted(text4)
104                             listcomarr4.append(text4)
105                             text3.append(listcomarr4)
106                     else:
107                         text3.append(listcom3.text)
108                     text3 = sorted(text3)
109                     listcomarr3.append(text3)
110                     text2.append(listcomarr3)
111             else:
112                 text2.append(listcom2.text)
113             text2 = sorted(text2)
114             listcomarr2.append(text2)
115             text1.append(listcomarr2)
116     else:
117         text1.append(listcom1.text)
118     text1 = sorted(text1)
119     listcomarr1.append(text1)
120     return listcomarr1
121 
122 # 将xml内容转换成按序排列的list,返回值有3个:处理后的spmlxmllist、不需要处理的头部spmlstart、不需要处理的尾部spmlend
123 # spmlstart、spmlend是为了控制不需要处理的头部和尾部,提高处理效率
124 def xmltolist(spml):
125     if spml.find("<spml:") != -1:
126         startnum = re.search(r'<spml:[^>]*>', spml).span()[1]
127         endnum = spml.rfind("</spml:")
128         spmlstart = spml[:startnum].strip()
129         spmlend = spml[endnum:].strip()
130         spmlxml = '''<spml:modifyRequest xmlns:spml='{spml}' xmlns:subscriber="{subscriber}" xmlns:xsi="{xsi}">n%s</spml:modifyRequest>''' % (
131             spml[startnum:endnum].strip())
132     elif spml.find("<PlexViewRequest") != -1:
133         startnum = re.search(r'<PlexViewRequest[^>]*>', spml).span()[1]
134         endnum = spml.rfind("</PlexViewRequest>")
135         spmlstart = spml[:startnum].strip()
136         spmlend = spml[endnum:].strip()
137         spmlxml = '''<PlexViewRequest>n%s</PlexViewRequest>''' % (spml[startnum:endnum].strip())
138     else:
139         spmlstart = ""
140         spmlend = ""
141         spmlxml = spml
142     # print spmlstart
143     # print endspml
144     # print spmlxml
145     tree = ET.fromstring(spmlxml)
146     spmlxmllist = listafter(tree)
147     return spmlxmllist, spmlstart, spmlend
148 
149 # 将xmltolist处理形成的spmlxmllist再回头变成xml(xml中,同节点的内容已被按需排列)
150 def listtoxml(spmllist1):
151     kong = "  "
152     spmltag1 = spmllist1[0]
153     spmlattrib1 = ""
154     bodyxml1 = ""
155     if spmllist1[1] != {}:
156         for key, value in spmllist1[1].items():
157             spmlattrib1 += " %s='%s'" % (key, value)
158     startxml1 = "<%s%s>" % (spmltag1, spmlattrib1)
159     endxml1 = "</%s>" % (spmltag1)
160     spmlxml1 = ""
161     if isinstance(spmllist1[2][0], list):
162         spmlxml2 = ""
163         for spmllist2 in spmllist1[2]:
164             spmltag2 = spmllist2[0]
165             spmlattrib2 = ""
166             bodyxml2 = ""
167             if spmllist2[1] != {}:
168                 for key, value in spmllist2[1].items():
169                     spmlattrib2 += " %s='%s'" % (key, value)
170             startxml2 = "<%s%s>" % (spmltag2, spmlattrib2)
171             endxml2 = "</%s>" % (spmltag2)
172             if isinstance(spmllist2[2][0], list):
173                 spmlxml3 = ""
174                 for spmllist3 in spmllist2[2]:
175                     spmltag3 = spmllist3[0]
176                     spmlattrib3 = ""
177                     bodyxml3 = ""
178                     if spmllist3[1] != {}:
179                         for key, value in spmllist3[1].items():
180                             spmlattrib3 += " %s='%s'" % (key, value)
181                     startxml3 = "<%s%s>" % (spmltag3, spmlattrib3)
182                     endxml3 = "</%s>" % (spmltag3)
183                     if isinstance(spmllist3[2][0], list):
184                         spmlxml4 = ""
185                         for spmllist4 in spmllist3[2]:
186                             spmltag4 = spmllist4[0]
187                             spmlattrib4 = ""
188                             bodyxml4 = ""
189                             if spmllist4[1] != {}:
190                                 for key, value in spmllist4[1].items():
191                                     spmlattrib4 += " %s='%s'" % (key, value)
192                             startxml4 = "<%s%s>" % (spmltag4, spmlattrib4)
193                             endxml4 = "</%s>" % (spmltag4)
194                             if isinstance(spmllist4[2][0], list):
195                                 spmlxml5 = ""
196                                 for spmllist5 in spmllist4[2]:
197                                     spmltag5 = spmllist5[0]
198                                     spmlattrib5 = ""
199                                     bodyxml5 = ""
200                                     if spmllist5[1] != {}:
201                                         for key, value in spmllist5[1].items():
202                                             spmlattrib5 += " %s='%s'" % (key, value)
203                                     startxml5 = "<%s%s>" % (spmltag5, spmlattrib5)
204                                     endxml5 = "</%s>" % (spmltag5)
205                                     if isinstance(spmllist5[2][0], list):
206                                         spmlxml6 = ""
207                                         for spmllist6 in spmllist5[2]:
208                                             spmltag6 = spmllist6[0]
209                                             spmlattrib6 = ""
210                                             bodyxml6 = ""
211                                             if spmllist6[1] != {}:
212                                                 for key, value in spmllist6[1].items():
213                                                     spmlattrib6 += " %s='%s'" % (key, value)
214                                             startxml6 = "<%s%s>" % (spmltag6, spmlattrib6)
215                                             endxml6 = "</%s>" % (spmltag6)
216                                             if isinstance(spmllist6[2][0], list):
217                                                 spmlxml7 = ""
218                                                 for spmllist7 in spmllist6[2]:
219                                                     spmltag7 = spmllist7[0]
220                                                     spmlattrib7 = ""
221                                                     bodyxml7 = ""
222                                                     if spmllist7[1] != {}:
223                                                         for key, value in spmllist7[1].items():
224                                                             spmlattrib7 += " %s='%s'" % (key, value)
225                                                     startxml7 = "<%s%s>" % (spmltag7, spmlattrib7)
226                                                     endxml7 = "</%s>" % (spmltag7)
227                                                     if isinstance(spmllist7[2][0], list):
228                                                         spmlxml8 = ""
229                                                         for spmllist8 in spmllist7[2]:
230                                                             spmltag8 = spmllist8[0]
231                                                             spmlattrib8 = ""
232                                                             bodyxml8 = ""
233                                                             if spmllist8[1] != {}:
234                                                                 for key, value in spmllist8[1].items():
235                                                                     spmlattrib8 += " %s='%s'" % (key, value)
236                                                             startxml8 = "<%s%s>" % (spmltag8, spmlattrib8)
237                                                             endxml8 = "</%s>" % (spmltag8)
238                                                             if isinstance(spmllist8[2][0], list):
239                                                                 spmlxml9 = ""
240                                                                 for spmllist9 in spmllist8[2]:
241                                                                     spmltag9 = spmllist9[0]
242                                                                     spmlattrib9 = ""
243                                                                     bodyxml9 = ""
244                                                                     if spmllist9[1] != {}:
245                                                                         for key, value in spmllist9[1].items():
246                                                                             spmlattrib9 += " %s='%s'" % (key, value)
247                                                                     startxml9 = "<%s%s>" % (spmltag9, spmlattrib9)
248                                                                     endxml9 = "</%s>" % (spmltag9)
249                                                                     if isinstance(spmllist9[2][0], list):
250                                                                         spmlxml10 = ""
251                                                                         for spmllist10 in spmllist9[2]:
252                                                                             spmltag10 = spmllist10[0]
253                                                                             spmlattrib10 = ""
254                                                                             bodyxml10 = ""
255                                                                             if spmllist10[1] != {}:
256                                                                                 for key, value in spmllist10[1].items():
257                                                                                     spmlattrib10 += " %s='%s'" % (
258                                                                                         key, value)
259                                                                             startxml10 = "<%s%s>" % (
260                                                                                 spmltag10, spmlattrib10)
261                                                                             endxml10 = "</%s>" % (spmltag10)
262                                                                             bodyxml10 = spmllist10[2][0]
263                                                                             spmlxml10 += "n%s%s%s%s" % (
264                                                                                 kong * 9, startxml10, bodyxml10,
265                                                                                 endxml10)
266                                                                         spmlxml9 += "n%s%s%sn%s%s" % (
267                                                                             kong * 8, startxml9, spmlxml10, kong * 8,
268                                                                             endxml9)
269                                                                     else:
270                                                                         bodyxml9 = spmllist9[2][0]
271                                                                         spmlxml9 += "n%s%s%s%s" % (
272                                                                             kong * 8, startxml9, bodyxml9, endxml9)
273                                                                 spmlxml8 += "n%s%s%sn%s%s" % (
274                                                                     kong * 7, startxml8, spmlxml9, kong * 7, endxml8)
275                                                             else:
276                                                                 bodyxml8 = spmllist8[2][0]
277                                                                 spmlxml8 += "n%s%s%s%s" % (
278                                                                     kong * 7, startxml8, bodyxml8, endxml8)
279                                                         spmlxml7 += "n%s%s%sn%s%s" % (
280                                                             kong * 6, startxml7, spmlxml8, kong * 6, endxml7)
281                                                     else:
282                                                         bodyxml7 = spmllist7[2][0]
283                                                         spmlxml7 += "n%s%s%s%s" % (
284                                                             kong * 6, startxml7, bodyxml7, endxml7)
285                                                 spmlxml6 += "n%s%s%sn%s%s" % (
286                                                     kong * 5, startxml6, spmlxml7, kong * 5, endxml6)
287                                             else:
288                                                 bodyxml6 = spmllist6[2][0]
289                                                 spmlxml6 += "n%s%s%s%s" % (kong * 5, startxml6, bodyxml6, endxml6)
290                                         spmlxml5 += "n%s%s%sn%s%s" % (
291                                             kong * 4, startxml5, spmlxml6, kong * 4, endxml5)
292                                     else:
293                                         bodyxml5 = spmllist5[2][0]
294                                         spmlxml5 += "n%s%s%s%s" % (kong * 4, startxml5, bodyxml5, endxml5)
295                                 spmlxml4 += "n%s%s%sn%s%s" % (kong * 3, startxml4, spmlxml5, kong * 3, endxml4)
296                             else:
297                                 bodyxml4 = spmllist4[2][0]
298                                 spmlxml4 += "n%s%s%s%s" % (kong * 3, startxml4, bodyxml4, endxml4)
299                         spmlxml3 += "n%s%s%sn%s%s" % (kong * 2, startxml3, spmlxml4, kong * 2, endxml3)
300                     else:
301                         bodyxml3 = spmllist3[2][0]
302                         spmlxml3 += "n%s%s%s%s" % (kong * 2, startxml3, bodyxml3, endxml3)
303                 spmlxml2 += "n%s%s%sn%s%s" % (kong * 1, startxml2, spmlxml3, kong * 1, endxml2)
304             else:
305                 bodyxml2 = spmllist2[2][0]
306                 spmlxml2 += "n%s%s%s%s" % (kong * 1, startxml2, bodyxml2, endxml2)
307         spmlxml1 += "n%s%sn%s" % (startxml1, spmlxml2, endxml1)
308     else:
309         bodyxml1 = spmllist1[2][0]
310         spmlxml1 += "n%s%s%s" % (startxml1, bodyxml1, endxml1)
311     return spmlxml1
312 
313 # 将startspml, xmlspml, endspml组合起来,其中有一部分内容需要根据实际情况处理
314 def regroupspml(startspml, xmlspml, endspml):
315     xmlspml = str(xmlspml).replace("{{", "").replace("}}", ":").strip().splitlines()
316     if endspml != "":
317         startspml = str(startspml.strip()).replace(""", "'")
318         startspml = re.sub(" +>", ">", startspml)
319         startspml = startspml.splitlines()
323         endspml = str(endspml.strip()).splitlines()
324         spmlxmlcom = startspml + xmlspml[1:-1] + endspml
325     else:
326         spmlxmlcom = xmlspml
327     return spmlxmlcom
328 
329 # 对按序排列的xml进行内容比对,生成html文件,可以很直接的看出内容区别
330 def diffspml(spmlxml1, spmlxml2):
331     spmlxmllist1, spmlstart1, spmlend1 = xmltolist(spmlxml1)
332     spmlxmllist2, spmlstart2, spmlend2 = xmltolist(spmlxml2)
333     spmlxmlcom1 = listtoxml(spmlxmllist1)
334     spmlxmlcom2 = listtoxml(spmlxmllist2)
335     spmlxmlcom1 = regroupspml(spmlstart1, spmlxmlcom1, spmlend1)
336     spmlxmlcom2 = regroupspml(spmlstart2, spmlxmlcom2, spmlend2)
337     # print spmlstart1
338     # print spmlend1
339     if spmlxmlcom1 == spmlxmlcom2:
340         return 0
341     else:
342         global diffspmNum
343         global outputhtml_dir
344         try:
345             diffspmNum += 1
346         except:
347             diffspmNum = 1
348             system = platform.system()
349             if ('Windows' in system):
350                 outputhtml_dir = "c:/RobotLog"
351             else:
352                 outputhtml_dir = "/tmp/RobotLog"
353             outputhtml_dir = "%s/%s" % (outputhtml_dir, datetime.datetime.now().strftime('%Y%m%d_%H%M%S'))
354             os.makedirs(outputhtml_dir)
355         Loghtmldir = "%s/%s.html" % (outputhtml_dir, diffspmNum)
356         # logger.write("<a href="%s">%s</a>" % (Loghtmldir, Loghtmldir), "HTML")
357         hd = difflib.HtmlDiff(8,65)
358         with open(Loghtmldir, 'w') as fo:
359             fo.write(hd.make_file(spmlxmlcom1, spmlxmlcom2))
360             fo.close()
361         return Loghtmldir

tabsize代表制表符代表的空格个数,默以为8

本篇小说的介绍顺序是 lxml.etreeXPathlxml.html

  当中有生机勃勃对内容,原先思考使用自循环的主意管理,然而经过中的数据传输逻辑轻松错乱,现在会假造把那大器晚成部分优化一下。

class difflib.Differ

二〇一〇 年,lxml v2.0 公布,lxml.html 加多到库中;在 v2.0.3 版本中 lxml.html.soupparser 才现身。

 

>>> get_close_matches('appel', ['ape', 'apple', 'peach', 'puppy'])
['apple', 'ape']
>>> import keyword
>>> get_close_matches('wheel', keyword.kwlist)
['while']
>>> get_close_matches('apple', keyword.kwlist)
[]
>>> get_close_matches('accept', keyword.kwlist)
['except']

有关课程方面官方网站上付出了四个学科:

1、ElementTree库 ------- xml解析:

a, b[, linejunk][, charjunk]

lxml 模块并不唯有是我们在英特网搜到的 etree ,lxml 下边还或然有不菲的模块,有 etree 、html 、cssselect 等好多模块。其它小编也看出了 BeautifulSoup 。

效率的布置初心:
  管理百端待举的xml相比,屏蔽同节点前后相继顺序的熏陶

linejunkcharjunk,可选参数,在ndiff()中应用,

必威 4

一言九鼎涉嫌知识点:

wrapcolumn,可选参数,用来安装有个别个字符时自动换行,私下认可None,为None时表示不自行换行

lxml 是提供了一个 Pythonic API ,何况她也是大约全盘相称 ElementTree API 的。lxml 的花费公司也是力求收缩开拓者的就学耗费,然则 lxml 的教程以为一点都不团结。

不满与待优化:

linejunk:选择四个字符串的方法,如若这几个字符串被确以为垃圾,则赶回true,不然为false,私下认可为None,他调用了IS_LINE_JUNK()其风度翩翩法子,那一个办法存在bug,他不能够过滤掉’#’周围的不可以预知字符,2.3之后,对这么些办法进行了动态深入分析,表现会比从前好些

在看官方教程的时候,开采了风流倜傥部分小郁结:

2、difflib库 ------- 提供的类和格局用来举行连串的差别化比较,它亦可比对文件并转移差距结果文本或然html格式的差距化相比页面

Code

Meaning

'- '

仅在片段1中存在

'+ '

仅在片段2中存在

' '

片段1和2中都存在

'? '

存在疑问的

哈尔lstatt 哈尔施塔特

make_file(fromlines, tolines [, fromdesc][, todesc][, context][, numlines])

运用形式和difflib.context_diff相同,只是重临的剧情展现格式不千篇一律

lxml.etree

用作叁个有力的 xml 管理模块,该有的效果她都是部分。

若操作三个 XML ,率先要能读写,能将字符串或流读进来拆解深入分析成 ElementTree ,又能将 ElementTree 转变为字符串或流。在这里地方 lxml 提供了几个可用的函数:

  • etree.fromstring( string )

    将 string 解析为 Element 或者 ElementTree 。

  • etree.parse( file )

    将文件恐怕是 file_like 对象深入分析为 ElementTree (not an Element object),因为 parse() 日常深入分析整篇文书档案,字符串拆解深入分析函数日常只解析片段。在那之中 file 还足以是 HTTP/FTP UPRADOL ,约等于说,file 应该是叁个 Bytes 流。然则 libxml2 中的 HTTP/FTP client 比较容易,所以可以思虑动用第三方库。

  • XML( text ) / HTML( text )

    表现比较像 fromstring() ,比较平昔的对 XML 和 HTML 文书档案实行一定剖判,能够改进分析器 parser 参数,差别的分析器设置区别照旧蛮大的。个中 parser 能够由相应的 XMLParser() / HTMLParser() 函数生成,可安装项有不少不仅只限于 encoding 、recover 、remove_blank_text 、remove_comments ,可是私下认可值是存在不一致的。例如 recover 在 XML 中是 False ,而在 HTML 中是 True 。在 HTML 中会使用 libxml2 的 recover 算法对不盒装饭菜的标签实行修复。

  • etree.tostring( elt )

    将二个 Element 恐怕 ElementTree 转变为 string 情势。这里面有多少个可选参数:pretty_print=False 代表是或不是格式化升高可读性;method="xml" 选用输出后的文书档案格式,分歧的拈轻怕重,做的改造也不相同等,可选参数有 xml 、html 、text (文本内容不满含标签,正是纯文本内容,tail也是) 、c14n (规范化 xml );encoding=None 表示以什么编码的字符串输出,在无 xml 文书档案注明景况下私下认可是 ASCⅡ ,可透过 encoding=None 举行改革,可是只要所整编码不是 utf-8 宽容,那么将会启用暗中认可注明。

  • ElementTree.write( file )

    本条是 ElementTree 特有的方法,是将 ElementTree 写到 a file, a file-like object, or a UOdysseyL (via FTP PUT or HTTP POST) 。可选参数和 tostring() 大概,也是有两样。

余下正是操作了,增加和删除查改相通也不菲,而搜索是剩下几个的基础。

etree 对于每个成分都有叁个制造函数,举个例子 Element() 、ElementTree() 、SubElement() 以至 Comment() 。基本全部的函数都是依照那一个实例对象的,lxml 的 API 是比较 Pythonic 的,Element 的行为和 list 比较像能够应用 len() 函数切成条等,Element 的 attrib 正是叁个 dist ;个中 Element 实例具备 45个属性和方法,饱含了全体:

append() insert()

clear() remove()

find*() get*() iter*() xpath()

set() 以及属性 .tag .attrib .text .tail等的操作

ElementTree 实例具备的措施少之又少,常用的光景有 7 种,主倘使查究find*() get*() xpath()

Element 的品质介绍:

  • .tag

    要素的名目

  • .attrib

    多少个分包成分属性的字典,key 是属性名,value 是对应的值。

  • .text

    Element 的文书均为直接子文本,不分包子成分中的文本,那一个中又包涵两片段 .text 和 .tail 。.text 是首先个子成分标签早先的,若无则为 None 。

  • .tail

    .tail 为 Element 的关门标签之后的公文,并且是在下叁个兄弟子标签在此以前的某些。未有则为 None 。

Element 的方式介绍:

  • append( child )

    加多四个新的子节点(能够是 Element 、Comment)到当前 Element 中。

  • insert( index, elt)

    将子成分 elt 插入到钦赐地点,这些 index 的随便性十分的大,假设是正数然则当先了最大值,那么 lxml 会直接将那些因素插到最终,借使是负数,不过那些负数所指地点不设有,那么就插到结尾,那些负数之处计算法规和列表的老大不太风度翩翩致,不明了精确的原理是如何,可是通过测量试验,-n所插的义务,前边有 n (以浮动前总括)个因素。即使对 Element 中的子元素实施 insert() 操作,那么子成分地方会按 index 钦点的转换。

  • clear()

    调用该函数,将移除全体内容 .attrib 将被移除 .text 和 .tail 将被安装为 None 全数的子节点将被删去。

  • remove( child )

    将子节点 child 从Element 中移除 ,假诺child 不是 Element 的子节点,将会掀起 ValueError 非常。

  • find( path )

    从 Element 的子成分及子孙成分中搜索第两个切合 path 的 subelement 。如果未有回到 None 。

    ElementPath 是 ElementTree 自带的三个 XPath-like 的门路语言,和 XPath 差不太多,首要分歧是 ElementPath 能用 {namespace}tag,不过Element帕特h 无法使用值相比和函数。

  • findall( path )

    回去叁个相配的 Element 的列表。

  • findtext( path, default=None )

    归来第三个相配成分的 .text 内容,如若存在极其,可是并未有 .text 内容,那么将重临三个空字符串,如果没有贰个协作的要素,那么将会回去二个None ,可是有 default 参数,重回 default 所钦命的。

  • get( key, default=None )

    归来字符串情势的 属性 key 的值,未有回到 None 或然 default 钦定的。

  • getchildren()

    回来四个暗含 Element 子成分的列表。

  • getiterator( tag=None, *tags )

    回来成分的三个生成器,重回元素种类决议于参数 tag ,生成顺序是in document order (depth first pre-order) 深度优先的先根遍历。若无参数的话,则第叁个就是因素本身。假如想利用一个连忙的生成器,能够利用 .iter() 。

  • getroottree()

    重回该因素的 ElementTree 。

  • iter( tag=None, *tags )

    过滤特定标签,生成迭代器。私下认可情状下,iter() 迭代颇负的节点,包含PI(管理指令) 、Comment(注释) 等,假若只想迭代标签成分,可以选取 Element factory 做参数e.iter(tag = etree.Element)

  • iterfind( path )

    迭代有所相称 ElementPath 的 Element 。

  • itertext( tag=None, *tags, with_tail=True )

    迭代 Element 成分的文件内容,with_tail 参数决定是或不是迭代子成分的 tail 。Element 的tail 不展会开迭代。

  • iterancestors( tag=None )

    要是马虎参数,那么将会迭代全体先辈,加标具名方可只迭代该标签先辈。

  • iterchildren( reversed=False, tag=None )

    因而设置 reversed=True 能够以反向的依次迭代子元素。

  • itersiblings( preceding=False )

    迭代 Element 之后的弟兄成分,可以透过安装 preceding=True 仅迭代 Element 从前的汉子成分。

  • iterdescendants( tag=None )

    同 iterancestors()

  • items()

    回去由成分属性的键值所构成的( name, value)元组的列表。

  • keys()

    重回二个未有特定顺序的要素属性名的列表。

  • set(A, V)

    创制大概改动属性 A 的值为 V。

  • xpath()

ElementTree 方法介绍:

平素不介绍的不二等秘书诀,是日前的切近,大概已经介绍过。

  • find( path )

  • findall( path )

  • findtext( path )

  • getiterator( tag=None, *tags )

  • getroot()

    赢得 ElementTree 的 root 成分,通常情状下是树的根节点的 Element 的实例,但是 ElementTree 是经未有其它事物创设出来的,将重临 None 。

  • xpath()

  • write()

robot framework的心得尚可,大致是因为其测量试验报告已经得以满足不奇怪要求,很稀少人会想去校勘可能增添自个儿想要展示的内容,比如扩充二个超链接,显示越多的原委,所以那生机勃勃部分花了不长日子均未有在英特网找到相关材质,最终只可以阅读源码。

make_file(fromlines, tolines [, fromdesc][, todesc][, context][, numlines])

XPath

XPath 是一门在 XML 文书档案中查找消息的门路语言,W3C 文书档案:XML Path Language (XPath), Version 1.0

具有的检索都以基于参照他事他说加以侦察定位的,依赖两个之间存在的某种关系,或骨干,或同级,那样一步一步的查到。

在 XPath 中,有七种类型的节点:成分、属性、文本、命名空间、管理指令、注释甚至文书档案节点(或称为根节点卡塔 尔(英语:State of Qatar)。

XPath 使用路径表达式在 XML 文书档案中甄选节点。节点是经过沿路线或许 step 来抉择的。

上边列出了最可行的路线表明式:

表达式 描述
nodename 选取此节点的所有子节点。
/ 从根节点选取。
// 从匹配选择的当前节点选择文档中的节点,而不考虑它们的位置。
. 选取当前节点。
.. 选取当前节点的父节点。
@ 选取属性。

XPath 通配符可用来采摘未知的 XML 成分。

通配符 描述
* 匹配任何元素节点。
@* 匹配任何属性节点。
node() 匹配任何类型的节点。

因此在门路表明式中选用“|”运算符,能够筛选若干个门路,“|”两侧的表明式是相互独立的,并不是是四个表明式下。

除了上边介绍的还可能有多个概念须求理解:轴(Axes)谓语

透过以上介绍大家着力得以拓宽分选节点了,可是有极大希望选的节点有一点点多,那么那时候就要求用谓语了。谓语正是用来做过滤的,过滤条件均写在[]中。

以此过滤条件可写内容有成都百货上千:运算符表明式、数字、函数以致文字( Literal ,W3C 的韩文介绍没留神看,没太懂 Literal 说的是如何)。

w3school 给的贰个事例,相比有代表性呢。

路径表达式 结果
/bookstore/book[1] 选取属于 bookstore 子元素的第一个 book 元素。
/bookstore/book[last()] 选取属于 bookstore 子元素的最后一个 book 元素。
/bookstore/book[last()-1] 选取属于 bookstore 子元素的倒数第二个 book 元素。
/bookstore/book[position()<3] 选取最前面的两个属于 bookstore 元素的子元素的 book 元素。
//title[@lang] 选取所有拥有名为 lang 的属性的 title 元素。
//title[@lang='eng'] 选取所有 title 元素,且这些元素拥有值为 eng 的 lang 属性。
/bookstore/book[price>35.00] 选取 bookstore 元素的所有 book 元素,且其中的 price 元素的值须大于 35.00。
/bookstore/book[price>35.00]/title 选取 bookstore 元素中的 book 元素的所有 title 元素,且其中的 price 元素的值须大于 35.00。

Xpath 的轴定于的是相对于近来节点有所某种肖似特征的节点集。

轴名称 结果
ancestor 选取当前节点的所有先辈(父、祖父等)。
ancestor-or-self 选取当前节点的所有先辈(父、祖父等)以及当前节点本身。
attribute 选取当前节点的所有属性。
child 选取当前节点的所有子元素。
descendant 选取当前节点的所有后代元素(子、孙等)。
descendant-or-self 选取当前节点的所有后代元素(子、孙等)以及当前节点本身。
following 选取文档中当前节点的结束标签之后的所有节点。
namespace 选取当前节点的所有命名空间节点。
parent 选取当前节点的父节点。
preceding 选取文档中当前节点的开始标签之前的所有节点。
preceding-sibling 选取当前节点之前的所有同级节点。
self 选取当前节点。

每一个step都是由轴名称::NodeTest[谓语]构成。比如:child::*/child::pricechild::*child::price都以二个step

      • fromlines 和tolines,用于相比较的剧情,格式为字符串组成的列表
      • fromdesc 和 todesc,可选参数,对应的fromlines,tolines的差距化文件的标题,默以为空字符串
      • context 和 numlines,可选参数,context 为True时,只体现差异的上下文,为false,展现全文,numlines默感到5,当context为True时,调控体现上下文的行数,当context为false时,调整差别差别的高亮之间活动时“next”的此前地方(若是设置为0,当移动懂最上部时,超链接会遗失援引地址卡塔 尔(英语:State of Qatar)

difflib.``unified_diff(a, b[, fromfile][, tofile][, fromfiledate][, tofiledate][, n][, lineterm])

BeautifulSoup 是在 2002 年宣布的。lxml 差十分的少是在 二〇〇五 年透露。

公家措施(生成贰个含有表格的html文件,其剧情是用来展现差距卡塔 尔(阿拉伯语:قطر‎:

相比较a和b,重回差距

两个之间能够相互调用,并且两个之间的函数也是很相仿的,就连 css 选取器三个也都有。风趣了。难道 BeautifulSoup 是 lxml 的豆蔻梢头局地?

其构造函数如下:

那是足以用来比较任何类型片段的类,只要相比的风姿罗曼蒂克部分是可hash的,都能够用来相比较,使用特别灵活。他来自一九八〇,s的“完形相配算法”,並且打开了一文山会海的优化和改过。

lxml is the most feature-rich and easy-to-use library for processing XML and HTML in the Python language.

TAG标签:
版权声明:本文由必威发布于必威-编程,转载请注明出处:这篇文章是打算来写 XPath必威 的,difflib模块提供