python第二十三天 XML模块，面向对象思想与类的定义

Bertha 。 2021-11-05 12:08 123阅读 0赞

**今日内容**

**XML模块，面向对象思想，类的定义**

**1.XML模块**

xml是一种可扩展的标记语言格式如下

使用 <> 作为标签格式

标签的三个组成部分：

tag : 是标签名字

123：是文本内容

<tag></tag> : 双标签，有头有尾

<tag> : 单标签，没有文本，一般用于设计的结构，比如换行等

作为一门语言，那他的文件格式肯定有一定的规范：

1. 有开始，必须有结束

2. 所有的 属性 必须在双引号内

3.只能有一个根标签（最外层只能有一个标签）

4.开始标签和结束标签的顺序是相反的，最先打开谁，就最后关闭谁，最后打开的最后关闭

\# 文档可以写声明，也可以不写，声明的主要作用是告诉浏览器该如何解析

**获取某个标签的详细内容：**

import xml.etree.ElementTree as ET
    
    tree = ET.parse('test1.xml')     # 解析xml文件
    root = tree.getroot()    # 获取根标签
    
    # 在根标签下找到所有的country子标签
    es = root.findall('country')
    
    # for e in es:
    #     print(e.tag)     # e.tag 获取标签名称
    #     print(e.attrib)  # e.attrib 获取标签的所有属性，返回一个字典
    #     print(e.text)    # e.text 获取标签的文本内容
    
    # 获取所有国家的 邻居的名称
    for c in es:
        print('%s的邻居如下：'% c.attrib.get('name'))  # 每次获得一个子标签内带'name'的key
        for n in c.findall('neighbor'):                # 每次获取一个kye是'neighbor'的子标签
            print(n.attrib.get('name'))                # 输出结果是依次对应的是name 对应的 neighbor
        print('更新时间：%s'% c.find('year').text)     # 找到子标签'year'中的文本内容
        print('-----------')

**修改标签的某个属性**

import xml.etree.ElementTree as ET
    from xml.etree.ElementTree import Element
    
    # tree = ET.parse('test.xml')  # 解析一个文件
    # root = tree.getroot()        # 获取根标签
    
    # 修改文本
    # root.text = '这是根标签的文本'
    #
    # # 修改属性，没有则添加，有则覆盖
    # root.set('name','jack')
    #
    # # 修改标签名字
    # root.tag = 'data'
    #
    # tree.write('test.xml',encoding='utf-8',xml_declaration=True) # declaration：是否添加文档注释
    
    
    # 把test.xml 中所有vear 标签的text 改值
    # tree = ET.parse('test1.xml')
    # root = tree.getroot()
    # for e in root.iter('year'):
    #     e.text = str(int(e.text) +5)
    # tree.write('test1.xml')
    
    
    # 把test1.xml 中的所有gdppc删除
    # remove 函数，需要一个标签作为参数，即要被删除的标签，然后只能有父类标签来删除子标签
    # tree = ET.parse('test1.xml')
    # root = tree.getroot()
    #
    # for c in root.iter('country'):  # 循环遍历country 子标签
    #     gdppc = c.find('gdppc')  # 查找'gdppc'
    #     if gdppc != None:  # 如果有值
    #         c.remove(gdppc)  # 那么就删除gdppc
    #
    # tree.write('test2.xml')
    
    # 添加标签
    
    tree = ET.parse('test1.xml')
    root = tree.getroot()  # type:Element
    
    # 创建需要被添加的子标签
    new_tag = Element('ThisIsNewTag')
    new_tag.text = '123'  # 设置文本
    root.append(new_tag)  # 添加到root下
    tree.write('test3.xml') # 写入文件

** 代码生成xml文档**

import xml.etree.ElementTree as et
    
    # 创建标签
    tag = et.Element('data')
    tag.text = '123'
    tag.set('name','jack')
    
    
    # 创建一个元素树，并把tag添加到上面
    tree = et.ElementTree(tag)
    tree.write('test4.xml')

**2.面向对象思想**

面向对象的优点：

不需要关注具体细节，可以更好的关注业务逻辑，扩展性提高了，维护性高，复用性高

缺点：

对比面向过程而言，程序需要先设计，结构更复杂，编程复杂度提高了，无法准确预知执行结果

应用场景：

对于扩展性要求较高的应用程序

对象：

具备某种特征与行为的集合体，并且是具体存在的就是对象

类：

具备相同特性和相同行为的集合体，是一种抽象的概念

对象和类的方法：

在生活中，先有对象，再有类

在代码中，先有类，再有对象

类的定义：

关键字：class

class ’类名‘    类名的书写规范：使用大驼峰，所有单词首字母大写

# 类的使用方法与定义
    class Student:
        # 描述特征使用变量
        school = 'oldBoy'
    
        # 描述技能使用函数(方法)
        def say_hi():
            print('hello i am tiger')
    
        # class 中的代码仅在第一次加载时执行
        print('华丽的分割线--------')
        pass
    
    
    print(Student.say_hi)
    Student.say_hi()  # 类方法可以使用.来调用内部的所有数据，包括函数
    print(Student.school)
    
    stu1 = Student()   # 也可以赋值给其他变量
    stu1.say_hi()      # 其他变量也同样拥有类的功能

对象的使用：

class Person:
        country = 'China'
    
        def eat(self):
            print('正在吃饭中。。。')
    
    
    p1 = Person()  # 拿到类这个对象
    # print(p1)
    
    
    p1.eat()  # 调用类中的函数
    
    # 为对象添加属性
    p1.name = '王勇'  # 在p1对象中添加一个叫 '王勇' 的值，然后赋值给name，并没有真的添加到类中，原类没有修改
    print(p1.name)
    
    # 给p1 对象单独添加country ，它并不会更改到类中
    p1.country = 'USA'
    
    # 在访问时优先访问自己的名称空间，如果找不到，会自动去类中寻找对应的属性
    print(p1.country)  # 'USA'
    print(Person.country) # 'China'
    
    
    # 每个对象都会存储自己所在类的地址，可以使用__class__来访问
    print(p1.__class__)
    print(type(p1))  # type() 原理就是调用了__class__方法
    
    # 查看名称空间中的内容
    print(p1.__dict__)
    print(Person.__dict__)
    
    # 还可以在别的文件中调用类

面向过程编程思想  
关注的点就是完成任务的过程  
第一步  
第二步  
一步一步按照固定顺序来完成任务  
是一种机械化的思维,就像一条流水线,指定流水线只能生产指定产品  
缺点:  
牵一发而动全身 扩展性非常低,可维护性差  
优点:  
将复杂的事情,简单化,并流程化  
应用场景:  
对扩展要求较低的程序  
系统内核,shell脚本,计算器啥的

面向对象编程  
是一种编程思想  
面向:朝着 向着  
对象是什么  
面向对象关注点是对象,把你的思维角度从具体操作这 变成了一个指挥者  
例如把大象装进冰箱  
1.打开冰箱  
2.塞入大象  
3.关闭冰箱  
以上就是典型面向过程思想  
换成面向对象  
找一个具备装大象这个技能的对象 然后命令它装大象

注意:对象不是凭空产生的 需要我们自己先设计对象 然后在使用它们

面向对象优点:  
不需要在关注具体的实现细节 可以更好的关注业务逻辑  
扩展性提高了,维护性高,复用性高  
缺点:  
对比面向过程而言.程序需要先设计,结构更复杂,编程复杂度提高了  
无法准确预知执行结果  
应用场景:  
对于扩展性要求较高的应用程序  
qq,微信,王者荣耀

面向对象是一种编程思想,让你不需要关心具体实现细节,而是关注对象  
优点:扩展性高,复用性,维护性

什么是对象?  
万事万物都是对象  
对象:具备某种特征与行为的集合体并且是具体存在的就称之为对象  
如来佛祖,owen  
类: 某些具备相同特征和相同行为的集合体 ,是一种抽象概念 类型==类  
人,动物,狗,老男孩的老师

特征==属性  
行为==技能

对象和类的关系  
在生活中 先有对象 再有类  
在代码中 必须现有类 才能产生对象 (因为你需要提前告诉计算机这个对象是什么样的有什么技能)

编程思想不是某一个具体语言或技术 ,  
面向对象的语言:  
python,Java,C++,C\#  
面向过程:  
C,ruby

今天讲到的知识点  
xml模块  
tree = ElementTree.parser("文件")  
root = tree.getroot()  
\# 查  
root.iter/find/findall  
\# 增  
root.append(标签对象)  
\# 删  
root.remove(标签对象)

修改  
root.text = "新值"  
root.tag = "新名字"  
root.set("key","value")  
tree.write()

1.面向对象是什么?  
2.面向对象与面向过程的优缺点对比 以及使用场景对比  
3.什么是对象 什么是类  
4.类和对象的关系  
5.如何定义一个类  
6.如何创建对象  
7.属性的访问顺序  
8.类和对象的名称空间是独立的

转载于:https://www.cnblogs.com/liguodeboke/p/10871523.html