Day07 常用模块(二) 面向对象
常用模块(二)###
xml模块####
xml示例文件如下:
<data>
<country name="Liechtenstein">
<rank updated="yes">2</rank>
<year>2023</year>
<gdppc>141100</gdppc>
<neighbor direction="E" name="Austria" />
<neighbor direction="W" name="Switzerland" />
</country>
<country name="Singapore">
<rank updated="yes">5</rank>
<year>2026</year>
<gdppc>59900</gdppc>
<neighbor direction="N" name="Malaysia" />
</country>
<country name="Panama">
<rank updated="yes">69</rank>
<year>2026</year>
<gdppc>13600</gdppc>
<neighbor direction="W" name="Costa Rica" />
<neighbor direction="E" name="Colombia" />
</country>
</data>
利用ElementTree.parse将文件直接解析成xml对象
from xml.etree import ElementTree as ET
#实例化xml对象
tree = ET.parse('xo.xml')
#取得根节点数据
root = tree.getroot()
#循环,遍历取到根节点下每个子节点的名称,属性,内容
for child in root:
print(child.tag, child.attrib, child.text)
for gradechild in child:
print(gradechild.tag, gradechild.text)
利用ElementTree.XML将字符串解析成xml对象
# 打开文件,读取XML内容
from xml.etree import ElementTree as ET
str_xml = open('xo.xml', 'r').read()
# 将字符串解析成xml特殊对象,root代指xml文件的根节点
root = ET.XML(str_xml)
# 顶层标签
print(root.tag)
# 循环所有的year节点
for node in root.iter('year'):
# 将year节点中的内容自增一
new_year = int(node.text) + 1
node.text = str(new_year)
# 设置属性
node.set('name', 'alex')
node.set('age', '18')
# 删除属性
del node.attrib['name']
# 保存文件
tree = ET.ElementTree(root)
tree.write("new.xml", encoding='utf-8')
创建xml文件
from xml.etree import ElementTree as ET
# 创建根节点
root = ET.Element("famliy")
# 创建节点大儿子
son1 = ET.Element('son', {'name': '儿1'})
# 创建小儿子
son2 = ET.Element('son', {"name": '儿2'})
# 在大儿子中创建两个孙子
grandson1 = ET.Element('grandson', {'name': '儿11'})
grandson2 = ET.Element('grandson', {'name': '儿12'})
son1.append(grandson1)
son1.append(grandson2)
# 把儿子添加到根节点中
root.append(son1)
root.append(son1)
tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', xml_declaration=True, short_empty_elements=False)
创建xml文件(带有缩进)
from xml.etree import ElementTree as ET
from xml.dom import minidom
def prettify(elem):
"""将节点转换成字符串,并添加缩进。
"""
rough_string = ET.tostring(elem, 'utf-8')
reparsed = minidom.parseString(rough_string)
return reparsed.toprettyxml(indent="\t")
# 创建根节点
root = ET.Element("famliy")
# 创建大儿子
# son1 = ET.Element('son', {'name': '儿1'})
son1 = root.makeelement('son', {'name': '儿1'})
# 创建小儿子
# son2 = ET.Element('son', {"name": '儿2'})
son2 = root.makeelement('son', {"name": '儿2'})
# 在大儿子中创建两个孙子
# grandson1 = ET.Element('grandson', {'name': '儿11'})
grandson1 = son1.makeelement('grandson', {'name': '儿11'})
# grandson2 = ET.Element('grandson', {'name': '儿12'})
grandson2 = son1.makeelement('grandson', {'name': '儿12'})
son1.append(grandson1)
son1.append(grandson2)
# 把儿子添加到根节点中
root.append(son1)
root.append(son1)
raw_str = prettify(root)
f = open("xxxoo.xml",'w',encoding='utf-8')
f.write(raw_str)
f.close()
压缩解压文件模块 zipfile####
import zipfile
z = zipfile.ZipFile('test.zip', 'a')
#将文件追加压缩到test.zip
z.write('__init__.py')
z.write('s1.py')
z.close()
zi = zipfile.ZipFile('test.zip', 'r')
#解压缩有文件
zi.extractall()
#查看压缩包内的所有文件
for i in zi.namelist():
print(i, type(i))
za = zipfile.ZipFile('test.zip', 'r')
#解压指定文件到指定文件夹下,没有该文件夹则创建
zi.extract('s1.py', 'test')
压缩解压文件模块 tarfile####
import tarfile
t = tarfile.TarFile('test.tar', 'w')
#将文件以arcname的命名追加压缩到test.tar
t.add('s1.py', arcname='ss1.py')
t.add('s2.py', arcname='ss2.py')
t.close()
#查看压缩包所有文件
t = tarfile.TarFile('test.tar', 'r')
for i in t:
print(i)
t.extractall()
#获取指定文件对象
obj = t.getmember('ss3.py')
#解压指定文件对象
t.extract(obj)
面向对象###
类的三特性,封装,继承,多态
#创建类
class Foo:
#构造函数(只要实例化对象,该方法就会执行)
def __init__(self, name, age, msg):
self.name = name
self.age = age
self.msg = msg
self.add = 'something'
#普通方法
def m1(self):
print(self.name,self.age,self.msg,self.add)
#实例化对象obj1,obj2,普通方法m1调用
obj1 = Foo('alex', '30', 'python')
obj2 = Foo('eric', '40', 'Java')
obj1.m1()
obj2.m1()
类的封装####
class c1:
def __init__(self, name, obj):
self.name = name
self.obj = obj
class c2:
def __init__(self,name):
self.name = name
def m(self):
print(self.name)
return "OK"
class c3:
def __init__(self, name):
self.name = name
#实例化对象c2_obj
c2_obj = c2('alex')
#将c2_obj封装到c1_obj
c1_obj = c1('eric', c2_obj)
#将C1_obj封装到c3_obj
c3_obj = c3(c1_obj)
ret = c3_obj.name.obj.m()
print(ret)
类的继承####
class F1:
def bar(self):
print("Test")
return "OK"
def show(self):
print("F1.show")
class F2(F1):
def __init__(self, name):
self.name = name
def show(self):
print("F2.show")
#实例化对象obj
obj = F2('alex')
#对象obj调用普通方法bar,F2中没有方法bar,但是继承了父类的方法bar
obj.bar()
#对象obj调用普通方法show,F2虽然继承了父类,父类也有方法show,但自身的show方法优先级更高
obj.show()
继承多个父类,方法调用的优先级和顺序
class c1:
def f1(self):
print("c1.f1")
def f2(self):
print("c1.f2")
class c2(c1):
def f1(self):
print("c2.f1")
class c3:
def f4(self):
print("c3.f1")
class c4(c3):
def f1(self):
print("c4.f1")
def f2(self):
print("c4.f2")
class c5(c2, c4):
def ff(self):
pass
obj = c5()
obj.f2()
obj.f4()
输出:
c1.f2
c3.f1
c5继承c2,c4,若c2和c4的根父类没有共同继承,,先从c2找f2,没有从c2的父类c1找,c1没有,继续从c4找如此继续,一旦找到就立即返回,后面的同名方法不再有效
上面的情况若改成c2和c4的根父类有共同继承c0, 那么则从继承多个父类左边开始,由子类往父类找,c2的分支往上找到根停止,没有则从c4的分支往上找到c0,继续这个规则寻找方法。