xml模块、hashlib模块、subprocess模块、os与sys模块、configparser模块

• xml模块

  xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，

  在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下，就是通过<>节点来区别数据结构的:

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml数据

xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml：

# print(root.iter('year'))  # 全文搜索
# print(root.find('country'))  # 在root的子节点找，只找一个
# print(root.findall('country'))  # 在root的子节点找，找所有
import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
#遍历xml文档
for child in root:
    print('========>',child.tag,child.attrib,child.attrib['name'])
    for i in child:
        print(i.tag,i.attrib,i.text)
 
#只遍历year 节点
for node in root.iter('year'):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter('year'):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set('updated','yes')
    node.set('version','1.0')
tree.write('test.xml')
 
 
#删除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)
 
tree.write('output.xml')
#在country内添加（append）节点year2
import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()
for country in root.findall('country'):
    for year in country.findall('year'):
        if int(year.text) > 2000:
            year2=ET.Element('year2')
            year2.text='新年'
            year2.attrib={'update':'yes'}
            country.append(year2) #往country节点下添加子节点

tree.write('a.xml.swap')

自己创建xml文档：

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
 
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml) #打印生成的格式

---

• hashlib模块

  hash算法：传入一段内容会得到一串hash值

  hash值有三大特点:

  1.如果传入的内容与采用的算法一样，那么得到的hash值一定一样

  2.只要采用的算法是固定的，hash值的长度就是固定的，不会随着内容的增多而变长

  3.hash值不可逆，即不能通过hash值反解出内容是什么

  1 + 2 = 》效验文件的完整性

  1 + 3 = 》加密

# 传入的内容与采用的算法一样，得到的hash值一定一样
import hashlib

m = hashlib.md5()
m.update("你好".encode('utf-8'))
m.update("hello".encode('utf-8'))
m.update("哈哈".encode('utf-8'))

# "你好hello哈哈"   # hash工厂计算的是它的值
print(m.hexdigest())  # 43b2fa0da902a2d9175fb4d4b858e5d5

m1 = hashlib.md5()
m1.update("你".encode('utf-8'))
m1.update("好hello".encode('utf-8'))
m1.update("哈".encode('utf-8'))

# "你好hello哈哈"
print(m1.hexdigest())  # 43b2fa0da902a2d9175fb4d4b858e5d5




# 效验文件完整性
import hashlib
m = hashlib.md5()

with open(r'D:\python17\day16\代码.zip',mode='rb') as f:
    for line in f:
        m.update(line)
    res = m.hexdigest()
    print(res)

    
    
import hashlib
m = hashlib.md5()

m.update("天王".encode('utf-8'))   # 密码加盐
m.update("123egon".encode('utf-8'))
m.update("盖地虎".encode('utf-8'))
print(m.hexdigest())

---

• subprocess模块

  即允许你去创建一个新的进程让其执行另外的程序，并与它进行通信，

  获取标准的输入、标准输出、标准错误以及返回码等。

  注意：使用这个模块之前要先引入该模块。

  Popen类

  subprocess模块中定义了一个Popen类，通过它可以来创建进程，并与其进行复杂的交互。

import subprocess
import time
# “Tasklist”命令是一个用来查看运行在本地或远程计算机上的所有进程的命令行工具，带有多个执行参数。
# Popen 等同于cmd.exe命令解释器
obj = subprocess.Popen("tasklist",
                       # shell=True等同于调用命令解释器
                       shell=True,
                       # 管道内存正确输出结果
                       stdout=subprocess.PIPE,
                       # 管道内存错误输出结果
                       stderr=subprocess.PIPE
                       )

print("=============>", obj) # 拿到的是subprocess的对象
# =============> <subprocess.Popen object at 0x00000193E7E04BB0>

# 主进程从管道拿到子进程结果
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()

# subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码
print(stdout_res.decode('gbk'))
print(stderr_res.decode('gbk'))


# 主进程想拿到子进程运行命令的结果做进一步的处理
# 每启动一个进程在内存里占用一个内存空间，进程与进程之间的内存空间是相互隔离的
# 在子进程运行Tasklist这条命令，运行完之后这条命令的结果一定是产生在子进程的内存空间里
# 不可能在主进程拿到这个结果，这个就要用到共享内存了，即“管道”

• os与sys模块

• os模块

  这个模块提供了一种方便的bai使用操作系统函du数的方法。

  os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.environ  获取系统环境变量
os.path.abspath(path)  返回path规范化的绝对路径
os.path.split(path)  将path分割成目录和文件名二元组返回
os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

os的用法演示

import os

print(os.getcwd()) # 获取当前工作所在文件夹
os.makedirs("a/b/c") # 递归创建文件夹
os.removedirs("a/b/c") # 递归删除文件夹

res = os.listdir('.') # 浏览当前文件夹列表显示
print(res)

print(os.stat("今日内容.txt")) # 查看文件信息

print(os.path.getsize("今日内容.txt")) # 获取文件的大小以字节显示

print(os.environ)  # 环境变量
os.environ["name"] = "egon"
print(os.environ)
print(os.environ['name'])

 
print(os.path.abspath("a/b/c"))   # 返回path规范化的绝对路径
print(os.path.split(r"D:\a\b\c\d.txt")) # 
print(os.path.dirname(r"D:\a\b\c\d.txt"))
print(os.path.basename(r"D:\a\b\c\d.txt"))

res = os.path.exists(r"D:\a\b")
print(res)

print(os.path.isabs(r"D:\a\b\c\d.txt"))
print(os.path.isabs(r"c\d.txt"))

print(os.path.join("D:",'a',"b","c.txt"))


# os路径处理
# 方式一：
#     获取路径文件夹---》获取当前文件夹的上一级文件夹
print(os.path.dirname(os.path.dirname(__file__)))

# 方式二：
res = os.path.normpath(os.path.join(__file__,"..",'..'))
print(res)

• sys模块

  这个模块可供访问由解释器使用或维护的变量和与解释器进行交互的函

  sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境

1 sys.argv           命令行参数List，第一个元素是程序本身路径
2 sys.exit(n)        退出程序，正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称


import sys

# print(sys.argv)  # sys.argv 从命令行中接收用户输入

src_file = sys.argv[1]
dst_file = sys.argv[2]

with open(r'%s' %src_file,mode='rb') as f1,\
    open(r'%s' %dst_file,mode='wb') as f2:
    for line in f1:
        f2.write(line)

打印进度条

#=========知识储备==========
#进度条的效果
[#             ]
[##            ]
[###           ]
[####          ]

#指定宽度
print('[%-15s]' %'#')
print('[%-15s]' %'##')
print('[%-15s]' %'###')
print('[%-15s]' %'####')

#打印%
print('%s%%' %(100)) #第二个%号代表取消第一个%的特殊意义

#可传参来控制宽度
print('[%%-%ds]' %50) #[%-50s]
print(('[%%-%ds]' %50) %'#')
print(('[%%-%ds]' %50) %'##')
print(('[%%-%ds]' %50) %'###')


#=========实现打印进度条函数==========
import sys
import time

def progress(percent,width=50):
    if percent >= 1:
        percent=1
    show_str=('[%%-%ds]' %width) %(int(width*percent)*'#')
    print('\r%s %d%%' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')


#=========应用==========
data_size=1025
recv_size=0
while recv_size < data_size:
    time.sleep(0.1) #模拟数据的传输延迟
    recv_size+=1024 #每次收1024

    percent=recv_size/data_size #接收的比例
    progress(percent,width=70) #进度条的宽度70

---

• configparser模块

  该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节（section），

  每个节可以有多个参数（键=值）。节与java原先的配置文件相同的格式

• 配置文件：

# config.ini 配置文件

# 注释1
; 注释2

[mysqld]   # 标题
k1 = v1    # 配置项 key：value的形式
k2:v2
user=egon
age=18
is_admin=true
salary=31
log_path = D:\a\b\c.log

[client]
k1 = v1

• 解析配置文件

# configparser模块  #  用来解析配置文件的

import configparser

config = configparser.ConfigParser()  # 返回一个对象
config.read('config.ini') #，用这个对象执行.read（配置文件）

res = config.sections()  # 拿到config.ini配置文件下所有的标题
print(res)

res = config.options('mysqld') # 拿到标题mysqld下所有配置项key=value的key

res = config.items('mysqld') # 拿到标题mysqld下所有配置项key=value的(key,value)格式
print(res)

res = config.get('mysqld', 'log_path') # 指定拿到标题mysqld下log_path日志的路径
print(res)

res = config.getint('mysqld', 'age') # 拿到标题mysqld下age的值=>整数格式

res = config.getboolean('mysqld', 'is_admin') #拿到标题mysqld下is_admin的值=>布尔值格式
print(res,type(res))

res = conf.getfloat('mysqld','salary') # 拿到标题mysqld下salary的值=>浮点型格式
print（res）