威尼斯人线上娱乐

上学笔记,复杂的xml文件相比较

27 3月 , 2019  

功效的设计初衷:
  处理复杂的xml比较,屏蔽同节点先后顺序的震慑

(python功用定制)复杂的xml文件相比,产生HTML呈现分裂,pythonxml

功效的布置性初衷:
  处理复杂的xml比较,屏蔽同节点先后顺序的震慑

重视涉嫌知识点:

1、ElementTree库 ——- xml解析:

    • 导入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)
    • 遍历根节点能够博得子节点,然后就足以根据须求拿到要求的字段了,如:<APP_KEY
      channel = ‘CSDN’> hello123456789 </APP_KEY>

      • tag,即标签,用于标识该因素表示哪个种类多少,即APP_KEY
      • attrib,即属性,用Dictionary方式保存,即{‘channel’ = ‘CSDN’}
      • text,文本字符串,能够用来囤积一些数目,即hello123456789
      • tail,尾字符串,并不是必须的,例子中尚无蕴涵。

二 、difflib库 ——- 提供的类和章程用来举办体系的差别化相比,它亦可比对文件并扭转差距结果文本可能html格式的差别化比较页面

那里运用了类difflib.HtmlDiff,用来创制贰个html表格展现文件差距,他既能够拓展全文本呈现,也得以只呈现上下文区别。

其构造函数如下:

__init__(tabsize=8, wrapcolumn=None, linejunk=None, charjunk=IS_CHARACTER_JUNK)

      • tabsize表示制表符代表的空格个数,暗许为8
      • wrapcolumn,可选参数,用来安装某个个字符时自动换行,暗许None,为None时表示不自行换行(重点:能够让html呈现更雅观)
      • linejunk 和 charjunk,可选参数,在ndiff()中利用,

上学笔记,复杂的xml文件相比较。国有措施(生成1个含有表格的html文件,其剧情是用来显示差距):

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

      • fromlines 和tolines,用于相比较的内容,格式为字符串组成的列表
      • fromdesc 和 todesc,可选参数,对应的fromlines,tolines的差距化文件的题目,默许为空字符串
      • context 和 numlines,可选参数,context 为True时,只体现差距的上下文,为false,突显全文,numlines默许为5,当context为True时,控制呈现上下文的行数,当context为false时,控制差异距离的高亮之间活动时“next”的发端地方(假使设置为0,当移动懂顶端时,超链接会丢失引用地址)

叁 、platform库 ——– 获取当前系统

肆 、logger库 ——– 假诺运用robot
framework,能够看出分明有别于,能够定制日志log呈现

robot
framework的体验尚可,大约是因为其测试报告已经足以满足平常须求,很少有人会想去修改也许增添和谐想要展示的剧情,比如扩大1个超链接,展示更多的始末,所以那部分花了非常长日子均没有在网上找到有关材料,最终只可以阅读源码。

遗憾与待优化:

  在那之中有一对内容,原先准备利用自循环的点子处理,然而经过中的数据传输逻辑简单错乱,未来会设想把那有的优化一下。

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

  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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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

 

 

#############################################以上是代码部分#################################################################

 1 spmlxml1='''
 2 <PlexViewRequest SessionId="${sessionid}" ProvisioningGroup="volte" Command="ed-ngfs-subscriber-v2"><SubParty><PrimaryPUID>+86${ISDN}@${domain}</PrimaryPUID><PartyId>+86${ISDN}</PartyId></SubParty><SeqRinging><RingingList>null^null^true^true^10^false`+86${msisdn1}^STANDARD^true^true^10^false</RingingList><DefaultAnswerTimeout>10</DefaultAnswerTimeout><Send181Mode>TAS_181_NONE</Send181Mode><Activated>true</Activated><PublicUID>+86${ISDN}@${domain}</PublicUID><Assigned>true</Assigned></SeqRinging></PlexViewRequest>
 3 '''
 4 spmlxml2='''
 5 <PlexViewRequest SessionId="${sessionid}" ProvisioningGroup="volte" Command="ed-ngfs-subscriber-v2">
 6    <SubParty>
 7       <PrimaryPUID>+86${ISDN}@${domain}</PrimaryPUID>
 8       <PartyId>+86${ISDN}</PartyId>
 9    </SubParty>
10    <SeqRinging>
11       <RingingList>null^null^true^true^10^false`+86${msisdn1}^STANDARD^true^true^10^false</RingingList>
12       <DefaultAnswerTimeout>10</DefaultAnswerTimeout>
13       <Send181Mode>TAS_180_NONE</Send181Mode>
14       <Activated>true</Activated>
15       <PublicUID>+86${ISDN}@${domain}</PublicUID>
16    </SeqRinging>
17 </PlexViewRequest>
18 '''
19 print diffspml(spmlxml1, spmlxml2)

#####################################以上列出来了本公司使用的xml格式(还可以更复杂),方法中有部分内容是根据本身需要,特别处理的####################################

 

 

作用的宏图初衷: 处理复杂的xml相比较,屏蔽同节点先后顺序的震慑
首要涉…

difflib -援救拓展差距化比较

威尼斯人线上娱乐 1

第壹涉嫌知识点:

以此模块提供的类和办法用来展开差别化比较,它亦可生成文书大概html格式的差别化比较结实,假设必要相比目录的差异,能够应用filecmp模块。

哈尔lstatt 哈尔施塔特

1、ElementTree库
——- xml解析:

class difflib.SequenceMatcher

人生苦短,作者用Python。

    • 导入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)
    • 遍历根节点能够获取子节点,然后就能够依据必要获得需求的字段了,如:<APP_KEY
      channel = ‘CSDN’> hello123456789 </APP_KEY>
      • tag,即标签,用于标识该因素表示哪一类多少,即APP_KEY
      • attrib,即属性,用Dictionary情势保存,即{‘channel’
        = ‘CSDN’}
      • text,文本字符串,能够用来囤积一些数码,即hello123456789
      • tail,尾字符串,并不是必须的,例子中没有包罗。

那是足以用来比较任何类型片段的类,只要相比的部分是可hash的,都足以用来相比较,使用十二分灵活。他来自1977,s的“完形匹配算法”,并且开始展览了一多元的优化和改良。

初阶,那篇小说是打算来写 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本子的。)

二 、difflib库 ——- 提供的类和方法用来进展类别的差距化相比,它亦可比对文件并转移差异结果文本大概html格式的差别化相比较页面

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

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

那里运用了类difflib.HtmlDiff,用来创建1个html表格显示文件差别,他既能够拓展全文本体现,也得以只显示上下文差异。

它拥有活动垃圾启发式,能够将再度超过部分1%大概再一次200次的字符作为垃圾来拍卖。能够透过将autojunk设置为false关闭该意义。

  • the lxml.etree tutorial for XML
    processing
    那几个是法定的科目。
  • John Shipman’s tutorial on Python XML processing with
    lxml
    那一个是 New Mexico Tech 高校的二个课程。嗯 ,有点久了,最终更新时间是
    二〇一一-08-24 ,当时理应是 3.2 版本的。但是易读性仍然比官方的强。
  • Fredrik Lundh’s tutorial for
    ElementTree
    这么些是 Fredrik Lundh 维护的1个第③方库,后来也被整合到 Python
    标准库 xml 中了。这些没时间能够不看,小编备感用不到相应。

其构造函数如下:

autojunk 参数新增于2.7.1本子。

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

__init__(tabsize=8, wrapcolumn=None, linejunk=None, charjunk=IS_CHARACTER_JUNK)

class difflib.Differ

lxml 是提供了一个 Pythonic API ,并且他也是差不多全盘匹配 ElementTree API
的。lxml 的开支团队也是力求减弱开发者的就学开支,可是 lxml
的学科感觉一点都不友善。

      • tabsize代表制表符代表的空格个数,默许为8
      • wrapcolumn,可选参数,用来设置有个别个字符时自动换行,私下认可None,为None时表示不自行换行(重点:能够让html凸显更雅观)
      • linejunk 和 charjunk,可选参数,在ndiff()中使用,

以此类用来相比文本里的行,并且发生可阅览标差距化结果。

在看官方教程的时候,发现了有的小嫌疑:

公共艺术(生成二个蕴涵表格的html文件,其内容是用来展现差距):

它用于下符号来代表分歧

lxml 模块并不只是我们在网上搜到的 etree ,lxml 下边还有为数不少的模块,有
etree 、html 、cssselect 等许多模块。别的笔者也见到了 BeautifulSoup 。

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

Code

Meaning

‘- ‘

仅在片段1中存在

‘+ ‘

仅在片段2中存在

‘ ‘

片段1和2中都存在

‘? ‘

存在疑问的

lxml can make use of BeautifulSoup as a parser backend, just like
BeautifulSoup can employ lxml as a parser.

lxml interfaces with BeautifulSoup through the lxml.html.soupparser
module.

      • fromlines 和tolines,用于相比较的剧情,格式为字符串组成的列表
      • fromdesc 和 todesc,可选参数,对应的fromlines,tolines的差别化文件的标题,暗中认可为空字符串
      • context 和 numlines,可选参数,context 为True时,只显示差距的上下文,为false,展现全文,numlines默许为5,当context为True时,控制体现上下文的行数,当context为false时,控制不相同差别的高亮之间活动时“next”的初步地方(假设设置为0,当移动懂顶端时,超链接会丢失引用地址)

标识为?须要你通过人为的章程仔细相比较他们的不及,他们发生的来由是根源混乱的制表符

BeautifulSoup 能够将 lxml 作为解析器,那几个小编是清楚的,但是lmxl.html.soupparser 能够调用 BeautifulSoup
小编就不驾驭了。刚开始以为通晓错误,可是真正在源码中找到的凭据,soupparser
模块中引入了 BeautifulSoup ,并且也调用了该函数。

③ 、platform库 ——– 获取当前系统

class difflib.HtmlDiff

两者之间能够相互调用,并且两者之间的函数也是很相像的,就连 css
选择器四个也都有。有意思了。难道 BeautifulSoup 是 lxml 的一部分?

肆 、logger库 ——–
假使利用robot framework,能够观望明明分歧,能够定制日志log突显

以此类用来创制二个html表格(恐怕隐含html表格的公文)用来显示文件差异。他既能够开始展览全文本展现,也能够只展现上下文不相同。

BeautifulSoup 是在 二〇〇〇 年揭露的。lxml 大概是在 二零零六 年表露。

robot
framework的感受还能够,大概是因为其测试报告已经得以满意正常要求,很少有人会想去修改也许扩张自个儿想要体现的内容,比如扩张三个超链接,浮现更多的剧情,所以那有的花了相当短日子均没有在网上找到有关资料,最后只得阅读源码。

本条类的构造函数如下:

二〇〇八 年,lxml v2.0 发布,lxml.html 添加到库中;在 v2.0.3 版本中
lxml.html.soupparser 才出现。

遗憾与待优化:

__init__(tabsize=8, wrapcolumn=None, linejunk=None,
charjunk=IS_CHARACTER_JUNK)

直到 二零一二 年 bs4 宣布,BeautifulSoup 才得以选取从停放解析器、html5lib
、lxml 那多少个当选一个作为解析器,而从前版本采取的是却是另一个。

  在那之中有一对剧情,原先准备利用自循环的办法处理,可是经过中的数据传输逻辑不难错乱,今后会考虑把那有个别优化一下。

tabsize表示制表符代表的空格个数,私下认可为8

鲜明,那三个是一回事。不过两者之间的分别以及联系是怎么样(因为相似度有点高),特定的气象下又该做出何种选取?这几个难题先立在此地,容作者从此回答。笔者所掌握的是
BeautifulSoup 强大检查和测试编码能力,并且能够以 utf-8 格局出口;lxml
具有速度飞起的公文解析力。

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

  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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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%s\n%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

wrapcolumn,可选参数,用来设置有个别个字符时自动换行,默许None,为None时表示不自行换行

本篇文章的牵线顺序是 lxml.etreeXPathlxml.html

 

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

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 U揽胜极光L ,也正是说,file 应该是3个 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 UCRUISERL (via FTP PUT or HTTP POST) 。可选参数和
    tostring() 差不离,也有例外。

剩余正是操作了,增加和删除查改一样也不少,而寻找是多余多个的底蕴。

etree 对于每一种成分都有二个创制函数,比如 Element() 、ElementTree()
、SubElement() 以及 Comment()
。基本具有的函数都以基于这一个实例对象的,lxml 的 API 是比较 Pythonic
的,Element 的行为和 list 比较像能够接纳 len() 函数切开等,Element 的
attrib 正是2个 dist ;当中 Element 实例拥有 42个属性和措施,包蕴了拥有:

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 的门道语言,和
    X帕特h 差不太多,首要区别是 ElementPath 能用 {namespace}tag,但是ElementPath 无法使用值比较和函数。

  • findall( path )

    回来二个合营的 Element 的列表。

  • findtext( path, default=None )

    归来第三个匹配成分的 .text 内容,借使存在13分,但是尚未 .text
    内容,那么将回到一个空字符串,假若没有一个匹配的因素,那么将会重临2个None ,可是有 default 参数,再次来到 default 所钦赐的。

  • get( key, default=None )

    回去字符串情势的 属性 key 的值,没有回来 None 只怕 default 钦定的。

  • getchildren()

    归来三个带有 Element 子成分的列表。

  • getiterator( tag=None, *tags )

    回去成分的3个生成器,重回成分体系取决于参数 tag
    ,生成顺序是in document order (depth first pre-order)
    深度优先的先根遍历。假若没有参数的话,则第1个正是因素自个儿。假使想使用一个便捷的生成器,能够应用
    .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()

 

#############################################以上是代码部分#################################################################

 1 spmlxml1='''
 2 <PlexViewRequest SessionId="${sessionid}" ProvisioningGroup="volte" Command="ed-ngfs-subscriber-v2"><SubParty><PrimaryPUID>+86${ISDN}@${domain}</PrimaryPUID><PartyId>+86${ISDN}</PartyId></SubParty><SeqRinging><RingingList>null^null^true^true^10^false`+86${msisdn1}^STANDARD^true^true^10^false</RingingList><DefaultAnswerTimeout>10</DefaultAnswerTimeout><Send181Mode>TAS_181_NONE</Send181Mode><Activated>true</Activated><PublicUID>+86${ISDN}@${domain}</PublicUID><Assigned>true</Assigned></SeqRinging></PlexViewRequest>
 3 '''
 4 spmlxml2='''
 5 <PlexViewRequest SessionId="${sessionid}" ProvisioningGroup="volte" Command="ed-ngfs-subscriber-v2">
 6    <SubParty>
 7       <PrimaryPUID>+86${ISDN}@${domain}</PrimaryPUID>
 8       <PartyId>+86${ISDN}</PartyId>
 9    </SubParty>
10    <SeqRinging>
11       <RingingList>null^null^true^true^10^false`+86${msisdn1}^STANDARD^true^true^10^false</RingingList>
12       <DefaultAnswerTimeout>10</DefaultAnswerTimeout>
13       <Send181Mode>TAS_180_NONE</Send181Mode>
14       <Activated>true</Activated>
15       <PublicUID>+86${ISDN}@${domain}</PublicUID>
16    </SeqRinging>
17 </PlexViewRequest>
18 '''
19 print diffspml(spmlxml1, spmlxml2)

#####################################以上列出来了本公司使用的xml格式(还可以更复杂),方法中有部分内容是根据本身需要,特别处理的####################################

其一类的公共措施:

XPath

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

抱有的搜寻都以依照参考定位的,依靠两者之间存在的某种关联,或基本,或同级,那样一步一步的查到。

在 XPath
中,有七类别型的节点:成分、属性、文本、命名空间、处理指令、注释以及文书档案节点(或称为根节点)。

XPath 使用路径说明式在 XML 文书档案中选取节点。节点是通过沿着路径大概 step
来选拔的。

下边列出了最实惠的不二法门说明式:

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

XPath 通配符可用来抉择未知的 XML 成分。

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

经过在路径表明式中央银行使“|”运算符,能够采纳若干个途径,“|”两边的表明式是并行独立的,并非是1个表明式下。

除开下面介绍的还有三个概念必要知道:轴(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都以2个step

 

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

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
    的要素,仅返回第3个。

  • .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)
直接在浏览器中展现文书档案,甚至足以对文书档案的表单举行付出操作。

以上都是据自身的通晓而写,如有错误之处,欢迎交换。

 

用来生成贰个暗含表格的html文件,其情节是用来呈现差距。

fromlinestolines,用于相比较的始末,格式为字符串组成的列表

fromdesc
todesc,可选参数,对应的fromlines,tolines的差距化文件的题目,私下认可为空字符串

contextnumlines,可选参数,context
为True时,只显示差别的上下文,为false,显示全文,numlines私下认可为5,当context为True时,控制呈现上下文的行数,当context为false时,控制不一样距离的高亮之间活动时“next”的开端地方(假设设置为0,当移动懂顶端时,超链接会丢失引用地址)

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

其一措施和make_file用法一样,唯一的区分在于它只生成了一个html表格字符串

python安装包的Tools/scripts/diff.py是有关他们利用的二个很好的例证,它可以用命令行来运转。

新增于python2.4

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

用来比较a,b,a,b都以字符串列表。重临2个格式化文本的异样。

她是多个用来展现少量距离的好格局,那种变化,用前/后的体制进行浮现,n暗中同意为3,用来支配显示发现的差距数

暗中同意情况下,差别控制行(*** or
—)用来把a,b的差距区隔开分离来,便于程序读写处理,即便不供给如此做的话,能够设置lineterm为””,那样,就会卸载一行里

只要格式化差距文本需求标题和修改时间音讯,通过fromfile, tofile,
fromfiledate, 和 tofiledate举办控制,假设不设置,私下认可为空

>>> s1 = ['bacon\n', 'eggs\n', 'ham\n', 'guido\n']
>>> s2 = ['python\n', 'eggy\n', 'hamster\n', 'guido\n']
>>> 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]

)

 返回一个最相似匹配的列表word,用来进行匹配的片段(典型的应用是字符串)

possibilities,用来匹配word的片段

n,默认为3,返回的最多结果数,必须大于0

cutoff,默认为0.6,匹配的相似因数,他是一个介于0,1的浮点数
>>> 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,重返差距

linejunk和charjunk都以用来协作的方法

linejunk:接收二个字符串的点子,倘使这一个字符串被承认为垃圾,则赶回true,不然为false,暗中认可为None,他调用了IS_LINE_JUNK()其一法子,这些法子存在bug,他不能够过滤掉’#’周围的不可知字符,2.3事后,对这么些艺术进行了动态解析,表现会比原先好些

charjunk:接受1个字符的法门,倘若那个字符被认同为垃圾,则赶回true,不然为false,它调用了IS_CHARACTER_JUNK(),
他会活动过滤掉空白字符(所以,不要用空白字符只怕制表符作为分隔符)

Tools/scripts/ndiff.py 是推行这一办法的实例:

>>> diff = ndiff('one\ntwo\nthree\n'.splitlines(1),
...              'ore\ntree\nemu\n'.splitlines(1))
>>> print ''.join(diff),
- one
?  ^
+ ore
?  ^
- two
- three
?  -
+ tree
+ emu
difflib.restore

(

sequence, which

)

归来1或2的区别对Differ.compare() 或者
ndiff()的结果实行拍卖,依据参数which,重返片段1依然有些2的差别化结果实例:

>>> diff = ndiff('one\ntwo\nthree\n'.splitlines(1),
...              'ore\ntree\nemu\n'.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,a,b都是字符串列表。再次回到一个联结的格式化文本的差异。

动用格局和difflib.context_diff一样,只是重临的剧情突显格式有异样

>>> s1 = ['bacon\n', 'eggs\n', 'ham\n', 'guido\n']
>>> s2 = ['python\n', 'eggy\n', 'hamster\n', 'guido\n']
>>> 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

 

 

difflib.``IS_LINE_JUNK(line)如果是需要忽略的行,则返回为true,如果这个行内全为空格或者只有’#’,则将这行忽略掉

`difflib.IS_CHARACTER_JUNK(*ch*)一经是亟需忽略的字符,则赶回为true,倘诺这一个字符为空格,则将那行忽略掉`

-扶助举行差距化比较这么些模块提供的类和办法用来展开差别化相比较,它亦可生成文书可能html格式的差距化相比结实,借使须求比较…


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图