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，继续这个规则寻找方法。