python day 9
2019/10/12
学习资料来自老男孩教育
目录
1. xml模块
xml模块是在json没有出来之前，用于不同语言之间通信，交换，处理xml格式数据的一种方式。
1.1 初识xml
import requests
from xml.etree import ElementTree as ET
# 使用第三方模块requests发送HTTP请求，或者XML格式内容
response = requests.get('http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=375132083')
result = response.text # 字符串类型
# 使用xml包中的ElementTree解析XML格式内容
# XML接收一个字符串作为参数，将其格式化特殊的对象
node = ET.XML(result)
#获取内容
if node.text =='Y':
print('在线')
import requests
response2 = requests.get('http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=K234&UserID=starpinlan')
result2 = response2.text #字符串str
from xml.etree import ElementTree as ET
root = ET.XML(result2) #<class 'xml.etree.ElementTree.Element'>
# print(type(node2))
for node in root.iter('TrainDetailInfo'): #iter方法是找到root这个对象中的后代标签名是TrainDetailInfo的所有元素
print(node.tag,node.attrib) #输出它的标签名，以及它的属性
print(node.find('TrainStation').text) #find方法是找到指定名称的第一个子标签
1.2 遍历xml文档的指定节点
- 创建一个xml文档，写入如下内容：
s1 = '''
<data>
<country name="Liechtenstein">
<rank updated="yes">2</rank>
<year id="year">2024</year>
<gdppc>141100</gdppc>
<neighbor direction="E" name="Austria" />
<neighbor direction="W" name="Switzerland" />
</country>
<country name="Singapore">
<rank updated="yes">5</rank>
<year id="year">2027</year>
<gdppc>59900</gdppc>
<neighbor direction="N" name="Malaysia" />
</country>
<country name="Panama">
<rank updated="yes">69</rank>
<year id="year">2027</year>
<gdppc>13600</gdppc>
<neighbor direction="W" name="Costa Rica" />
<neighbor direction="E" name="Colombia" />
</country>
</data>
'''
with open('xmltest.xml','w+',encoding='utf-8') as f:
f.write(s1)
f.flush()
- 读取xml文档，不修改原文件
from xml.etree import ElementTree as ET
#使用XML格式化字符串
root = ET.XML(open('xmltest.xml',encoding='utf-8').read()) #此种方式只能读取，不可修改文件
print(root.tag)
for node in root.iter('country'):
print(node.tag,node.attrib,node.find('year').text)
child_node = node.find('year') #找到标签名为year的所有节点
new_year = int(child_node.text)+1 #将year标签的值加1
child_node.text = str(new_year)
child_node.set('name','year') #设置属性name，其值为year
# del child_node.attrib['name'] #删除name属性键值对
#保存文件需要另创建一个新文件
tree = ET.ElementTree(root) #创建一个内容为root的ElementTree对象
tree.write('newxml.xml',encoding='utf-8') #一定要通过write写入文件。
- 使用parse方法解析文件，可以修改原文件。
#使用ElementTree的parse方法解析文件
from xml.etree import ElementTree as ET
tree = ET.parse('xmltest.xml') #parse方法可以打开文件，并解析其内容
# print(tree,type(tree)) # <class 'xml.etree.ElementTree.ElementTree'>
root = tree.getroot() # getroot方法获得最顶层的根节点
# print(root.tag) # data
for node in root.iter('year'):
print(node.tag,node.text)
new_year = int(node.text) + 1
node.text = str(new_year)
node.set('id','year') # 设置id属性，其值为year，
print(node.attrib) # attrib是字典形式
tree.write('xmltest.xml') #parse可以直接修改原文件
- 查看一个节点都有哪些方法
from xml.etree import ElementTree as ET
tree = ET.parse('xmltest.xml')
root = tree.getroot()
print(dir(root)) #查看节点都有哪些方法
'''
['__class__', '__copy__', '__deepcopy__', '__delattr__', '__delitem__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__',
'__hash__', '__init__', '__init_subclass__', '__le__', '__len__', '__lt__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__setstate__', '__sizeof__',
'__str__', '__subclasshook__', 'append', 'attrib', 'clear', 'extend', 'find', 'findall', 'findtext',
'get', 'getchildren', 'getiterator', 'insert', 'items', 'iter', 'iterfind', 'itertext', 'keys', 'makeelement',
'remove', 'set', 'tag', 'tail', 'text']
#常用tag,attrib,find,text,set,iter,get,append,clear,extend,findall,getchildren,insert,makeelement
'''
1.3 通过python手工创建xml文档
from xml.etree import ElementTree as ET
root = ET.Element('namelist') #通过Element类创建一个名为namelist的xml元素（对象）
print(root,type(root)) # <Element 'namelist' at 0x00000184AD6C21D8> <class 'xml.etree.ElementTree.Element'>
name1 = ET.SubElement(root,'name',attrib={'enrolled':'yes'}) # 给root创建子节点，子节点的标签名是name，属性
name1.text = 'lanxing' #给内容赋值
age1 = ET.SubElement(name1,'age',attrib={'checked':'no'}) # 给name1创建子节点
age1.text = '18'
sex1 = ET.SubElement(name1,'sex',attrib={'sex':'male'})
sex1.text = 'male'
name2 = ET.SubElement(root,'name',attrib={'enrolled':'yes'}) # 给root创建子节点，子节点的标签名是name，属性
name2.text = '蓝星' #给内容赋值
age2 = ET.SubElement(name2,'age',attrib={'checked':'no'}) # 给name1创建子节点
age2.text = '28' # 必须是字符串才可以序列化
sex2 = ET.SubElement(name2,'sex',attrib={'sex':'male'})
sex2.text = 'female'
tree = ET.ElementTree(root) # 通过ElementTree类生成文档对象
tree.write('xmltest2.xml',encoding='utf-8',xml_declaration=True) #将文档对象写入文件，declaration表示声明文件，相当于注释。
1.4 创建节点的两种方式
from xml.etree import ElementTree as ET
tree = ET.parse('xmltest.xml')
root = tree.getroot()
# 创建新节点的第一种方式：makeelement
son = root.makeelement('son',{'sex':'male'})
print(son,type(son)) # <Element 'son' at 0x000002E1E1B10138> <class 'xml.etree.ElementTree.Element'>
# 创建新节点的第二种方式：通过Element类进行创建，实际第一种方式也是调用Element类
son2 = ET.Element('son2',{'sex':'male'})
son2.text = '男'
# 将新节点添加到root上
root.append(son)
root.append(son2)
tree.write('xmltest.xml',encoding='utf-8',short_empty_elements=False) # short参数是控制是否可简写的。
1.5 总结
XML:
1，解析：
str：ElementTree.XML(str)
文件：ElementTree.parse(file)
2，Element对象操作：
tag,text,find,iter,get,set,findall,append,insert,remove。
3，重新写入文件：
ElementTree(Element(tag,attrib)).write(filepath,encoding=None)
必须是ElementTree对象才有写入方法。
4，创建XML：
root= Element(tag,attrib)
ele = root.makeelement(tag,attrib)
root.append(ele)
ElementTree.SubElement(root,tag,attrib)
5，缩进
from xml.dom import minidom
def prettify(root):
'''将节点转换成字符串，并添加缩进'''
rough_string = ET.tostring(root,'utf-8')
reparsed = minidom.parseString(rough_string)
return reparsed.topprettyxml(indent='\t')
6，命名空间
7，非常重要
一切皆对象，type(obj)查看对象的类。dir(obj)查看对象具有的方法。
2. configparser模块
configparser模块用来处理配置文件，配置文件是以.ini结尾的文件，长得像下面这样。
[AutoUpdate] #[xxx]叫做节点
configfileurl = https://update.pan.baidu.com/autoupdate # 键值对，左边的叫key，右边的叫value
autoupdatecheckdelay = 30
configfilekey1 = EDAD921681272C3E37F34020450A6963
configfilekey2 = 132150629469920000
lstm_autoupdate = 1570589347
isautoupdate = 0[PackageInstallInfo]
default = 2
c6aa1078e4d92ff0573452220ca2d8ae = 4
import configparser
con = configparser.ConfigParser() # 创建一个ConfigParser对象
con.read('config.ini',encoding='utf-8') # 打开文件并读取文件内容，放进内存
# 1，获取所有节点
# con对象的sections方法，内存中寻找所有的[xxx],一个[xxx]就是一个配置文件的节点
ret = con.sections() # 获取所有的节点名称，并返回一个列表
print(ret) # ['AutoUpdate', 'PackageInstallInfo']
# 2，获取指定节点下所有的键值对,将key与值作为元组，元组作为列表的元素返回。
ret2 = con.items('AutoUpdate')
print(ret2) # [('configfileurl', 'https://update.pan.baidu.com/autoupdate'), ('isautoupdate', '0'), ('autoupdatecheckdelay', '30'), ('configfilekey1', 'EDAD921681272C3E37F34020450A6963'), ('configfilekey2', '132150629469920000'), ('lstm_autoupdate', '1570589347')]
# 3，获取指定节点所有的键
ret3 = con.options('PackageInstallInfo')
print(ret3) # ['default', 'c6aa1078e4d92ff0573452220ca2d8ae']
# 4, 获取指定节点下指定key的值,get(sections,key)
value1 = con.get('PackageInstallInfo','default') #默认返回字符串
print(value1,type(value1))
# 可以使用getint方法，自动将字符串转换为整数返回
value2 = con.getint('PackageInstallInfo','default')
print(value2,type(value2))
# 可以使用getfloat方法，自动将字符串转换为浮点数返回
value3 = con.getfloat('PackageInstallInfo','default')
print(value3,type(value3))
# 如果值是布尔值，可以使用getboolean方法，自动将字符串转换为布尔值返回
# value4 = con.getboolean('PackageInstallInfo','default') # 会报错，因为其值不是布尔值
# 5，检查，添加，删除节点
has_sec = con.has_section('AutoUpdate') #判断是否有节点，如果有返回True
print(has_sec)
con.add_section('name')
con.remove_section('name')
# 添加，删除操作必须重新写入文件，否则不能持久化保存。
# 6，检查，删除，设置指定节点内的键值对
#检查
has_opt =con.has_option('AutoUpdate','IsAutoUpdate')
#删除
con.remove_option('AutoUpdate','IsAutoUpdate')
#设置
con.set('AutoUpdate','IsAutoUpdate','0')
con.write(open('config.ini','w')) #write写入得接收一个文件对象
3. shutil模块
shutil模块是高级的文件，文件夹，压缩包处理模块。
import shutil
# 将文件内容复制到另一个文件中
# shutil.copyfileobj(fsrc,fdst[,length]) 将一个文件流对象复制给另一个文件流对象，长度是可选的。
f1 =open('1.txt','r',encoding='utf-8')
f2 =open('2.txt','w',encoding='utf-8')
shutil.copyfileobj(f1,f2)
f1.close()
f2.close()
# shutil.copyfile(src,dst),复制文件
shutil.copyfile('1.txt','3.txt')
# shutil.copymode(src,dst) 仅复制文件的权限，用户，组和内容都不变
shutil.copymode('1.txt','2.txt') #dst要存在
# shutil.copystat(src,dst) 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags
shutil.copystat('1.txt', '2.txt')
# shutil.copy(src,dst) #复制文件和权限
shutil.copy('1.txt','2.txt')
# shutil.copy2(src,dst) # 复制文件和状态信息
shutil.copy2('1.txt','2.txt')
# shutil.ignore_patterns(*patterns)忽略某些格式的文件
# shutil.copytree(src, dst, symlinks=False, ignore=None) 递归地去复制文件夹
shutil.copytree('.','../day10',symlinks=True,ignore=shutil.ignore_patterns('*.py'))
# shutil.rmtree(path[, ignore_errors[, onerror]])
shutil.rmtree('../day10')# 递归的去删除文件
# shutil.move(src, dst) 递归的去移动文件，它类似mv命令，其实就是重命名。
shutil.make_archive(base_name, format[,root_dir[,owner[,group[,logger]]]])
# 创建压缩包并返回文件路径，
# 其中base_name是指压缩包的文件包，也可以压缩包的路径。
# format：压缩包种类，zip,tar,bztar,gztar.
# root_dir: 要压缩的文件夹路径(默认当前目录)
# owner：用户，默认当前用户
# group：组，默认当前组
# logger：用于记录日志，通常是logging.Logger对象
shutil.make_archive('../test1','tar','.')
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，
import zipfile
# 压缩
z = zipfile.ZipFile('laxi.zip', 'w') #创建一个zip的压缩包对象
z.write('a.log') # 往压缩包里面加入文件
z.write('data.data')
z.close()
# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall() # 解压所有文件
print(z.namelist()) # 获得压缩包内的所有文件名
z.extract('1.txt') # 单独解压指定文件
z.close()
import tarfile
# 压缩
tar = tarfile.open('your.tar','w') # 创建tar格式的压缩包
tar.add('/Users/wupeiqi/PycharmProjects/bbs2.log', arcname='bbs2.log') #往里面加入压缩文件，可以另外设置名字为bbs2.log
tar.add('/Users/wupeiqi/PycharmProjects/cmdb.log', arcname='cmdb.log')
tar.close()
# 解压
tar = tarfile.open('your.tar','r')
tar.extractall() # 可设置解压地址
print(tar.getmembers()) #返回压缩包内的所有文件名
tar.extractfile('1.txt') #单独解压指定文件
tar.close()
4. subprocess模块
专门用于python执行系统命令
import subprocess
ret = subprocess.call('ipconfig') # call执行系统命令，返回状态码
print(ret) # 成功的返回码是0
ret2 = subprocess.check_call('ipconfig') # 执行命令，返回状态码
print(ret2)
ret3 = subprocess.check_output('ipconfig') # 执行命令，返回字节类型的命令结果
print(ret3)
'''
Popen()用于执行复杂的系统命令
参数：
args：shell命令，可以是字符串或者序列类型（如：list，元组）
bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
shell：同上
cwd：用于设置子进程的当前目录
env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
startupinfo与createionflags只在windows下有效
将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等
'''
subprocess.Popen('mkdir test',shell=True,cwd='.') # shell是True的情况下，就是将前面的字符串当作命令来输入
subprocess.Popen(['ipconfig','dir']) # 执行多个命令
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")
obj.stdin.close()
cmd_out = obj.stdout.read()
obj.stdout.close()
cmd_error = obj.stderr.read()
obj.stderr.close()
print(cmd_out)
print(cmd_error)
5. logging模块
线程安全，方便，多人来写时不会写脏数据。
- 只写单文件日志
import logging
logging.basicConfig(filename='log.log',
format='%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=logging.INFO,) #level表示大于10的才会记录
'''
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
'''
logging.critical('c')
logging.fatal('f')
logging.error("sssssss")
logging.warning('w')
logging.info('i')
logging.debug('d')
logging.log(logging.INFO,'333') #本质上都是调用的log方法。
'''
- 写多文件日志
'''
#logging模块写多文件日志取决于两个方法：
一个专门用于写日志
一个用于比较
def w():
pass
def w2():
pass
def b():
if agr>30:
w()
w2()
b()
定义文件：
创建文件
file_1_1 = logging.FileHandler('11_1.log','a')
创建格式
fmt = logging.Formatter(fmt="%s(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s")
文件应用格式
file_1_1.setFormatter(fmt)
file_1_2 = logging.FileHandler('11_2.log','a')
创建格式
fmt = logging.Formatter(fmt="%s(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s")
文件应用格式
file_1_1.setFormatter(fmt)
用于比较的函数：
logger1 = logging.Logger('s1',level=logging.ERROR) # 就是b()
logger1.addHandler(file_1_1) # 将文件加入进来
logger1.addHandler(file_1_2)
写日志：
logger1.critical('1111')
'''
6. 生成器(generator)与迭代器(iterator)
能够使用for循环都叫可迭代对象(iterable)，可以被next()函数调用并不断返回下一个值的对象叫迭代器(iterator)。
生成器与迭代器都是可迭代对象，生成器都是迭代器对象，可迭代对象不一定是迭代器。可以通过iter()函数将可迭代对象转换为迭代器。
-
生成器
python中，一边循环一边计算的机制叫做生成器，generator。
创建生成器，有两种方法。第一种通过列表生成式。a = (x for x in range(10) if x>=2)像这种通过列表生成式的就是一个生成器，可以通过for循环或者next()内置函数来获得生成器的值，生成器如果迭代完毕，则会报错。li = [x for x in rang(10) ]这个叫做列表推导式。与下面的函数是一个功能。
li = []
for i in range(10):
li.append(i)
通过关键字yield来声明是生成器。
def f():
for x in range(10):
yield x
# 这时 f()就是一个生成器
print(next(f())) # 可以next(generator)函数来创建生成器的下一个值
print(f().__next__()) # 也可以通过__next__()方法
for i in f():
print i
7. 反射
'''
# 反射
通过字符串的形式，导入模块
通过字符串的形式，去模块中寻找指定的函数，并执行
反射：根据字符串的形式去某个对象中去操作它的成员
getattr:
import random
寻找函数
target_func = getattr(random,'randint',None)
target_func()
寻找变量
target_var = getattr(random,'sample',None)
hasattr:
hasattr(random,'randint')
setattr:
setattr(random,'randxy',lambda x,y:x+y)
delattr:
delattr(random,'randxy')
扩展：
导入模块：
import random as rd
rd = __import__('random.randint',fromlist=True)
'''
import random as rd
# 本质是调用__import__来导入模块
rm = __import__('random')
# r1 = rm.randint(1,20)
# print(r1)
f1 = getattr(rm,'randint') # random.randint本质上是调用了getattr方法，这种就叫做反射
print(f1(1,20))