1 <?xml version="1.0"?>
 2 <data>
 3     <country name="Liechtenstein">
 4         <rank updated="yes">2</rank>
 5         <year>2008</year>
 6         <gdppc>141100</gdppc>
 7         <neighbor name="Austria" direction="E"/>
 8         <neighbor name="Switzerland" direction="W"/>
 9     </country>
10     <country name="Singapore">
11         <rank updated="yes">5</rank>
12         <year>2011</year>
13         <gdppc>59900</gdppc>
14         <neighbor name="Malaysia" direction="N"/>
15     </country>
16     <country name="Panama">
17         <rank updated="yes">69</rank>
18         <year>2011</year>
19         <gdppc>13600</gdppc>
20         <neighbor name="Costa Rica" direction="W"/>
21         <neighbor name="Colombia" direction="E">test</neighbor>>
22     </country>
23 </data>

 1 import xml.etree.ElementTree as ET
 2 
 3 tree = ET.parse("xmltest.xml")
 4 root = tree.getroot()
 5 print(root.tag)
 6 
 7 print(‘-‘*50)
 8 # 遍历xml文档
 9 for child in root:
10     print(child.tag, child.attrib)
11     for i in child:
12         print(i.tag, i.text,i.attrib)
13 
14 print(‘-‘ * 50)
15 # 只遍历year 节点
16 for node in root.iter(‘year‘):
17     print(node.tag, node.text)

 1 data
 2 --------------------------------------------------
 3 country {‘name‘: ‘Liechtenstein‘}
 4 rank 2 {‘updated‘: ‘yes‘}
 5 year 2008 {}
 6 gdppc 141100 {}
 7 neighbor None {‘direction‘: ‘E‘, ‘name‘: ‘Austria‘}
 8 neighbor None {‘direction‘: ‘W‘, ‘name‘: ‘Switzerland‘}
 9 country {‘name‘: ‘Singapore‘}
10 rank 5 {‘updated‘: ‘yes‘}
11 year 2011 {}
12 gdppc 59900 {}
13 neighbor None {‘direction‘: ‘N‘, ‘name‘: ‘Malaysia‘}
14 country {‘name‘: ‘Panama‘}
15 rank 69 {‘updated‘: ‘yes‘}
16 year 2011 {}
17 gdppc 13600 {}
18 neighbor None {‘direction‘: ‘W‘, ‘name‘: ‘Costa Rica‘}
19 neighbor test {‘direction‘: ‘E‘, ‘name‘: ‘Colombia‘}
20 --------------------------------------------------
21 year 2008
22 year 2011
23 year 2011

 1 import xml.etree.ElementTree as ET
 2 
 3 tree = ET.parse("xmltest.xml")
 4 root = tree.getroot()
 5 
 6 # 修改
 7 for node in root.iter(‘year‘):
 8     new_year = int(node.text) + 1
 9     node.text = str(new_year)
10     node.set("updated", "yes")
11 
12 tree.write("xmltest.xml")
13 
14 # 删除node
15 for country in root.findall(‘country‘):
16     rank = int(country.find(‘rank‘).text)
17     if rank > 50:
18         root.remove(country)
19 
20 tree.write(‘output.xml‘)

 1 import xml.etree.ElementTree as ET
 2  
 3  
 4 new_xml = ET.Element("namelist")
 5 name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
 6 age = ET.SubElement(name,"age",attrib={"checked":"no"})
 7 sex = ET.SubElement(name,"sex")
 8 sex.text = ‘33‘
 9 name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
10 age = ET.SubElement(name2,"age")
11 age.text = ‘19‘
12  
13 et = ET.ElementTree(new_xml) #生成文档对象
14 et.write("test.xml", encoding="utf-8",xml_declaration=True)
15  
16 ET.dump(new_xml) #打印生成的格式

 1 import hashlib
 2 
 3 m = hashlib.md5()
 4 m.update(b"Hello")
 5 m.update(b"It‘s me")
 6 print(m.digest())
 7 m.update(b"It‘s been a long time since last time we ...")
 8 
 9 print(m.digest())  # 2进制格式hash
10 print(m.hexdigest())  # 16进制格式hash
11 print(len(m.hexdigest()))  # 16进制格式hash
12 
13 输出：
14 b‘]\xde\xb4{/\x92Z\xd0\xbf$\x9cR\xe3Br\x8a‘
15 b‘\xa0\xe9\x89E\x03\xcb\x9f\x1a\x14\xaa\x07?<\xae\xfa\xa5‘
16 a0e9894503cb9f1a14aa073f3caefaa5
17 32

import hashlib
 
# ######## md5 ########
 
hash = hashlib.md5()
hash.update(‘admin‘)
print(hash.hexdigest())
 
# ######## sha1 ########
 
hash = hashlib.sha1()
hash.update(‘admin‘)
print(hash.hexdigest())
 
# ######## sha256 ########
 
hash = hashlib.sha256()
hash.update(‘admin‘)
print(hash.hexdigest())
 
 
# ######## sha384 ########
 
hash = hashlib.sha384()
hash.update(‘admin‘)
print(hash.hexdigest())
 
# ######## sha512 ########
 
hash = hashlib.sha512()
hash.update(‘admin‘)
print(hash.hexdigest())

os.system
os.spawn*

The recommended approach to invoking subprocesses is to use the run() function for all use cases it can handle. For more advanced use cases, the underlying Popen interface can be used directly.

The run() function was added in Python 3.5; if you need to retain compatibility with older versions, see the Older high-level API section.

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False)

Run the command described by args. Wait for command to complete, then return a CompletedProcess instance.

The arguments shown above are merely the most common ones, described below in Frequently Used Arguments (hence the use of keyword-only notation in the abbreviated signature). The full function signature is largely the same as that of the Popen constructor - apart from timeout, input and check, all the arguments to this function are passed through to that interface.

This does not capture stdout or stderr by default. To do so, pass PIPE for the stdout and/or stderr arguments.

The timeout argument is passed to Popen.communicate(). If the timeout expires, the child process will be killed and waited for. The TimeoutExpired exception will be re-raised after the child process has terminated.

The input argument is passed to Popen.communicate() and thus to the subprocess’s stdin. If used it must be a byte sequence, or a string if universal_newlines=True. When used, the internal Popen object is automatically created withstdin=PIPE, and the stdin argument may not be used as well.

If check is True, and the process exits with a non-zero exit code, a CalledProcessError exception will be raised. Attributes of that exception hold the arguments, the exit code, and stdout and stderr if they were captured.

常用subprocess方法示例